Equations of Structure Single Pointer
=============================================================

In this section, you are going to learn

.. panels::
        :container: container pb-4
        :column: col-lg-12 p-2
        :card: shadow

	What are the different ways of declarations ?

.. panels::
        :container: container pb-4
        :column: col-lg-12 p-2
        :card: shadow

	How to dervie equations ?

.. panels::
        :container: container pb-4
        :column: col-lg-12 p-2
        :card: shadow

	What are the Properties of Variable ?

.. panels::
        :container: container pb-4
        :column: col-lg-12 p-2
        :card: shadow

	What are the Properties of Expression ?

.. panels::
        :container: container pb-4
        :column: col-lg-12 p-2
        :card: shadow

        Topics in this section,

		* :ref:`Derive Equations for Single Pointer <variable_and_ptr_sp_struct_ptr_ex_1>`

		* :ref:`Step 1 : Understand different methods to declare Single Pointer <variable_and_ptr_sp_struct_ptr_ex_2>`

			* :ref:`Declaration 1 : struct ABC x, Pointer p are declared and assigned in same line <variable_and_ptr_sp_struct_ptr_ex_3>`
			* :ref:`Declaration 2 : struct ABC x, Pointer p are declared and assigned in separate lines <variable_and_ptr_sp_struct_ptr_ex_4>`
			* :ref:`Declaration 3 : struct ABC x, Pointer p are declared in one line and assigned in another line <variable_and_ptr_sp_struct_ptr_ex_5>`
			* :ref:`Table of Declarations for Single Pointer <variable_and_ptr_sp_struct_ptr_ex_6>`

		* :ref:`Step 2 : Split pointer declarations and assignments into separate lines <variable_and_ptr_sp_struct_ptr_ex_7>`

		* :ref:`Step 3 : Derive Equations <variable_and_ptr_sp_struct_ptr_ex_8>`

		* :ref:`Step 4 : Apply above equations to analyse C statements <variable_and_ptr_sp_struct_ptr_ex_9>`

		* :ref:`Table of Equations for Single Pointer <variable_and_ptr_sp_struct_ptr_ex_10>`

		* :ref:`Properties of a variable <variable_and_ptr_sp_struct_ptr_ex_11>`

			* :ref:`Property 1 : Type <variable_and_ptr_sp_struct_ptr_ex_12>`
			* :ref:`Property 2 : sizeof() <variable_and_ptr_sp_struct_ptr_ex_13>`
			* :ref:`Property 3 : Scope, Lifetime and Memory of a variable <variable_and_ptr_sp_struct_ptr_ex_14>`

		* :ref:`Properties of Expressions <variable_and_ptr_sp_struct_ptr_ex_15>`

			* :ref:`Table of Expressions <variable_and_ptr_sp_struct_ptr_ex_16>`
			* :ref:`Table of Size (for Expressions) <variable_and_ptr_sp_struct_ptr_ex_17>`
			* :ref:`Table of Types (for Expressions) <variable_and_ptr_sp_struct_ptr_ex_18>`
			* :ref:`Table of Address/Value (for Expression) <variable_and_ptr_sp_struct_ptr_ex_19>`
			* :ref:`Table of Function Prototype (for Expression) <variable_and_ptr_sp_struct_ptr_ex_20>`

		* :ref:`Summary <variable_and_ptr_sp_struct_ptr_ex_21>`


1. Equations of Single Pointer
***********************************************************************

.. panels::
	:container: container pb-4
	:column: col-lg-12 p-2
	:card: shadow

	In this section, you are going to learn

        	* How to derive pointer equations for single pointer ?
	        * How to apply these equations to understand C statements ?

.. _variable_and_ptr_sp_struct_ptr_ex_1:

.. tab-set::

    .. tab-item:: Derive Equations for Single Pointer

	.. panels::
		:container: container pb-4
		:column: col-lg-12 p-2
		:card: shadow

		You can derive equations looking at C declarations !

.. _variable_and_ptr_sp_struct_ptr_ex_2:

        .. tab-set::

            .. tab-item:: Step 1 : Understand different methods to declare Single Pointer

		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

	                There are many methods in C, using which a single pointer can be declared. See below

.. _variable_and_ptr_sp_struct_ptr_ex_3:

                .. tab-set::

                    .. tab-item:: Declaration 1 : struct ABC ``x``, Pointer ``p`` are declared and assigned in same line

                        .. code-block:: c
                                :linenos:
				:emphasize-lines: 12

				#include <stdio.h>

                                struct ABC
                                {
                                        int a;
                                        int b;
                                        int c;
                                };

				int main(void)
				{
					struct ABC x = {.a = 1, .b = 2, .c = 3}, *p = &x;

					p->a = 10;
					p->b = 20;
					p->c = 30;

					printf("x.a = %d\n", x.a);
					printf("x.b = %d\n", x.b);
					printf("x.c = %d\n", x.c);

                                        // Use "p->" notation to access contents of "x"
					printf("p->a = %d\n", p->a);
					printf("p->b = %d\n", p->b);
					printf("p->c = %d\n", p->c);

                                        // Use "p[0]" notation to access contents of "x"
					printf("p[0].a = %d\n", p[0].a);
					printf("p[0].b = %d\n", p[0].b);
					printf("p[0].c = %d\n", p[0].c);

                                        // Use "(*p)." notation to access contents of "x"
					printf("(*p).a = %d\n", (*p).a);
					printf("(*p).b = %d\n", (*p).b);
					printf("(*p).c = %d\n", (*p).c);

					return 0;
				}

                        Output is as below

                        .. code-block:: c

                                x.a = 10
                                x.b = 20
                                x.c = 30

                                p->a = 10
                                p->b = 20
                                p->c = 30

                                p[0].a = 10
                                p[0].b = 20
                                p[0].c = 30

                                (*p).a = 10
                                (*p).b = 20
                                (*p).c = 30

                        .. panels::
                            :container: container pb-4
                            :column: col-lg-12 p-2
                            :card: shadow

                            In this example,
                                * ``x`` is a structure
                                * ``p`` is a structure pointer
                                * ``x`` and ``p`` are declared in one Single Line
                                * ``x`` and ``p`` are assigned in one Single Line
                                * ``x`` is assigned with value 10
                                * ``p`` is assigned with address of ``x``

.. _variable_and_ptr_sp_struct_ptr_ex_4:

                .. tab-set::

                    .. tab-item:: Declaration 2 : struct ABC ``x``, Pointer ``p`` are declared and assigned in separate lines

                        .. code-block:: c
                                :linenos:
				:emphasize-lines: 12, 14

				#include <stdio.h>

                                struct ABC
                                {
                                        int a;
                                        int b;
                                        int c;
                                };

				int main(void)
				{
					struct ABC x = {.a = 1, .b = 2, .c = 3};

					struct ABC *p = &x;

					p->a = 10;
					p->b = 20;
					p->c = 30;

					printf("x.a = %d\n", x.a);
					printf("x.b = %d\n", x.b);
					printf("x.c = %d\n", x.c);

                                        // Use "p->" notation to access contents of "x"
					printf("p->a = %d\n", p->a);
					printf("p->b = %d\n", p->b);
					printf("p->c = %d\n", p->c);

                                        // Use "p[0]" notation to access contents of "x"
					printf("p[0].a = %d\n", p[0].a);
					printf("p[0].b = %d\n", p[0].b);
					printf("p[0].c = %d\n", p[0].c);

                                        // Use "(*p)." notation to access contents of "x"
					printf("(*p).a = %d\n", (*p).a);
					printf("(*p).b = %d\n", (*p).b);
					printf("(*p).c = %d\n", (*p).c);

					return 0;
				}

                        Output is as below

                        .. code-block:: c

                                x.a = 10
                                x.b = 20
                                x.c = 30

                                p->a = 10
                                p->b = 20
                                p->c = 30

                                p[0].a = 10
                                p[0].b = 20
                                p[0].c = 30

                                (*p).a = 10
                                (*p).b = 20
                                (*p).c = 30

                        .. panels::
                            :container: container pb-4
                            :column: col-lg-12 p-2
                            :card: shadow

                            In this example,
                                * ``x`` is a structure
                                * ``p`` is a structure pointer
                                * ``x`` is declared in a separate line
                                * ``p`` is declared in a separate line
                                * ``x`` is assigned in the same line of declaration
                                * ``p`` is assigned in the same line of declaration
                                * ``x`` is assigned with value 10
                                * ``p`` is assigned with address of ``x``


.. _variable_and_ptr_sp_struct_ptr_ex_5:

.. _variable_and_ptr_sp_struct_ptr_declaration_3:

                .. tab-set::

                    .. tab-item:: Declaration 3 : struct ABC ``x``, Pointer ``p`` are declared in one line and assigned in another line

                        .. code-block:: c
                                :linenos:
				:emphasize-lines: 12, 18, 19

				#include <stdio.h>

                                struct ABC
                                {
                                        int a;
                                        int b;
                                        int c;
                                };

				int main(void)
				{
					struct ABC x;

                                        x.a = 10;
                                        x.b = 20;
                                        x.c = 30;

					struct ABC *p;
                                        p = &x;

					p->a = 10;
					p->b = 20;
					p->c = 30;

					printf("x.a = %d\n", x.a);
					printf("x.b = %d\n", x.b);
					printf("x.c = %d\n", x.c);

                                        // Use "p->" notation to access contents of "x"
					printf("p->a = %d\n", p->a);
					printf("p->b = %d\n", p->b);
					printf("p->c = %d\n", p->c);

                                        // Use "p[0]" notation to access contents of "x"
					printf("p[0].a = %d\n", p[0].a);
					printf("p[0].b = %d\n", p[0].b);
					printf("p[0].c = %d\n", p[0].c);

                                        // Use "(*p)." notation to access contents of "x"
					printf("(*p).a = %d\n", (*p).a);
					printf("(*p).b = %d\n", (*p).b);
					printf("(*p).c = %d\n", (*p).c);

					return 0;
				}

                        Output is as below

                        .. code-block:: c

                                x.a = 10
                                x.b = 20
                                x.c = 30

                                p->a = 10
                                p->b = 20
                                p->c = 30

                                p[0].a = 10
                                p[0].b = 20
                                p[0].c = 30

                                (*p).a = 10
                                (*p).b = 20
                                (*p).c = 30

                        .. panels::
                            :container: container pb-4
                            :column: col-lg-12 p-2
                            :card: shadow

                            In this example,
                                * ``x`` is a structure
                                * ``p`` is a structure pointer
                                * ``x`` is declared in a separate line
                                * ``p`` is declared in a separate line
                                * ``x`` is assigned and is not part of declaration
                                * ``p`` is assigned and is not part of declaration
                                * ``x`` is assigned with value 10
                                * ``p`` is assigned with address of ``x``

.. _variable_and_ptr_sp_struct_ptr_ex_6:

	.. tab-set::

	    .. tab-item:: Table of Declarations for Single Pointer

		==========  ===================================  =================================================================================
		Decl #      Declaration                          Description
		==========  ===================================  =================================================================================
		Decl 1      * struct ABC x, \*p = &x;            struct ABC x, Pointer p are declared and assigned in same line
		Decl 2      * struct ABC x;                      struct ABC x, Pointer p are declared and assigned in separate lines
                            * struct ABC \*p = &x;
		Decl 3      * struct ABC x;                      struct ABC x, Pointer p are declared in one line and assigned in another line
                                    * x.a = 10;
                                    * x.b = 20;
                                    * x.c = 30;
                            * struct ABC \*p;
                            * p = &x;
		==========  ===================================  =================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_7:

        .. tab-set::

            .. tab-item:: Step 2 : Split pointer declarations and assignments into separate lines

                * Whenever we see any of the above methods of declarations, we need to rewrite them such that, declarations and assignments are not in same line. Similar to :ref:`Declaration 3 <variable_and_ptr_sp_struct_ptr_declaration_3>`
        
.. _variable_and_ptr_sp_struct_ptr_ex_8:

        .. tab-set::

            .. tab-item:: Step 3 : Derive Equations

		.. _variable_and_ptr_sp_struct_ptr_eq_1:
        
                * Equation 1 : Obtained from ``Step 2``

                .. code-block:: c

                        p = &x;

                .. panels::
                        :container: container pb-4
                        :column: col-lg-12 p-2
                        :card: shadow

                        Implication : ``p`` holds the address of ``x``

		.. _variable_and_ptr_sp_struct_ptr_eq_2:

                * Equation 2 : Move ``&`` to the left of First Equation. It turns in to ``*``

                .. code-block:: c

                        *p = x;
                
                .. panels::
                        :container: container pb-4
                        :column: col-lg-12 p-2
                        :card: shadow

                        Implication : ``x`` and ``*p`` are one and the same !

		.. _variable_and_ptr_sp_struct_ptr_eq_3:

                * Equation 3 : ``*p`` has an alias ``p[0]``. Means ``*p`` and ``p[0]`` are one and the same !

                .. code-block:: c

                        p[0] = x;
                .. panels::
                        :container: container pb-4
                        :column: col-lg-12 p-2
                        :card: shadow

                        Implication : ``x`` and ``p[0]`` are one and the same !

		.. _variable_and_ptr_sp_struct_ptr_eq_4:

                * Equation 4 : From Equation 2, Equation 3, we can derive that ``x``, ``*p``, ``p[0]`` all are same !

                .. code-block:: c

                        *p = p[0] = x;

.. _variable_and_ptr_sp_struct_ptr_ex_9:

        .. tab-set::

            .. tab-item:: Step 4 : Apply above equations to analyse C statements

		.. tab-set::

		    .. tab-item:: Example 1 : :ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`: Changing ``*p`` changes the value of ``x``.

	                .. code-block:: c

                                (*p).a = 10;
                                (*p).b = 20;
                                (*p).c = 30;

                                printf("(*p).a = %d\n", (*p).a);
                                printf("(*p).b = %d\n", (*p).b);
                                printf("(*p).c = %d\n", (*p).c);

                        Output is as below

                        .. code-block:: c

                                (*p).a = 10
                                (*p).b = 20
                                (*p).c = 30

        	.. tab-set::

	            .. tab-item:: Example 2 : :ref:`See Equation 3 <variable_and_ptr_sp_struct_ptr_eq_3>` : Changing ``p[0]`` changes the value of ``x``

	                .. code-block:: c

                                p[0].a = 10;
                                p[0].b = 20;
                                p[0].c = 30;

                                printf("p[0].a = %d\n", p[0].a);
                                printf("p[0].b = %d\n", p[0].b);
                                printf("p[0].c = %d\n", p[0].c);

                        Output is as below

                        .. code-block:: c

                                p[0].a = 10
                                p[0].b = 20
                                p[0].c = 30

        	.. tab-set::

	            .. tab-item:: Example 3 : Use "p->" notation of pointer to change contents of variable "x" 

	                .. code-block:: c

                                p->a = 10;
                                p->b = 20;
                                p->c = 30;

                                printf("p->a = %d\n", p->a);
                                printf("p->b = %d\n", p->b);
                                printf("p->c = %d\n", p->c);

                        Output is as below

                        .. code-block:: c

                                p->a = 10
                                p->b = 20
                                p->c = 30

        	.. tab-set::

	            .. tab-item:: Example 4 : :ref:`See Equation 4 <variable_and_ptr_sp_struct_ptr_eq_4>` : Changing ``x`` changes the value of ``*p`` and ``p[0]``

	                .. code-block:: c

        	                x.a = 100;

                                printf("x.a = %d\n", x.a);
                                printf("(*p).a = %d\n", (*p).a);
                                printf("p[0].a = %d\n", p[0].a);
                                printf("p->a = %d\n", p->a);

                        Output is as below

                        .. code-block:: c

                                x.a    = 100
                                (*p).a = 100
                                p[0].a = 100
                                p->a   = 100

        .. tab-set::

            .. tab-item:: Step 5 : Complete program

                	.. code-block:: c
                                :linenos:

				#include <stdio.h>

                                struct ABC
                                {
                                        int a;
                                        int b;
                                        int c;
                                };

				int main(void)
				{
					struct ABC x;

					struct ABC *p;

					x.a = 10;

					p = &x;

					printf("x.a = %d, (*p).a = %d, p[0].a = %d, p->a = %d\n", x.a, (*p).a, p[0].a, p->a);

					x.a = 20;

					printf("x.a = %d, (*p).a = %d, p[0].a = %d, p->a = %d\n", x.a, (*p).a, p[0].a, p->a);

					(*p).a = 30;

					printf("x.a = %d, (*p).a = %d, p[0].a = %d, p->a = %d\n", x.a, (*p).a, p[0].a, p->a);

					p[0].a = 40;

					printf("x.a = %d, (*p).a = %d, p[0].a = %d, p->a = %d\n", x.a, (*p).a, p[0].a, p->a);

					p->a = 50;

					printf("x.a = %d, (*p).a = %d, p[0].a = %d, p->a = %d\n", x.a, (*p).a, p[0].a, p->a);

					return 0;
				}

                        * Output is as below

                	.. code-block:: c

                                x.a = 10, (*p).a = 10, p[0].a = 10, p->a = 10
                                x.a = 20, (*p).a = 20, p[0].a = 20, p->a = 20
                                x.a = 30, (*p).a = 30, p[0].a = 30, p->a = 30
                                x.a = 40, (*p).a = 40, p[0].a = 40, p->a = 40
                                x.a = 50, (*p).a = 50, p[0].a = 50, p->a = 50

.. _variable_and_ptr_sp_struct_ptr_ex_10:

	.. tab-set::

	    .. tab-item:: Table of Equations for Single Pointer

		==========  ==============  ============================================================
		Equation #  Equation        Description
		==========  ==============  ============================================================
		Equation 1  p = &x          Base condition
		Equation 2  \*p = x         From Equation 1, Move & from RHS to LHS to get * on LHS
		Equation 3  p[0] = x        \*p and p[0] are synonyms
		Equation 4  \*p = p[0] = x  From Equation 2, 3 we can conclude \*p, p[0], x are synonyms
		==========  ==============  ============================================================

2. Properties of a variable
***********************************************************************

.. _variable_and_ptr_sp_struct_ptr_ex_11:

.. tab-set::

    .. tab-item:: Properties of a variable

	.. panels::
		:container: container pb-4
		:column: col-lg-12 p-2
		:card: shadow

		In this section, you are going to learn

		* Properties of a variable

			* Type of a variable ?
			* Size of a variable ?
			* Scope, Lifetime and Memory of a variable ?

.. _variable_and_ptr_sp_struct_ptr_ex_12:

	.. tab-set::

	    .. tab-item:: Property 1 : Type

		.. _variable_and_ptr_sp_struct_ptr_property_1_1:

		.. tab-set::

		    .. tab-item:: Property 1.1 : type_of(variable)

        	        .. code-block:: c
				:linenos:
				:emphasize-lines: 1, 3

	                        struct ABC x;

				struct ABC *p;

				p = &x;

				p->a = 10;

			* In above code snippet, there are two variables ``x``, ``p``

			===========  ============== ==============================================================================
			Variable     Type           Description
			===========  ============== ==============================================================================
			type_of(x)   struct ABC     See Line 1
			type_of(p)   struct ABC \*  See Line 3
			===========  ============== ==============================================================================

		.. _variable_and_ptr_sp_struct_ptr_property_1_2:

		.. tab-set::

		    .. tab-item:: Property 1.2 : type_of(&variable)

                	.. panels::
                        	:container: container pb-4
	                        :column: col-lg-12 p-2
        	                :card: shadow

				Adress of variable must be stored in next level pointer type always

        	        .. code-block:: c
				:linenos:
				:emphasize-lines: 1, 3

	                        struct ABC x;

				struct ABC *p;

				p = &x;

				p->a = 10;

			* In above code snippet, there are two variables ``x``, ``p``

			===========  ===================== ==============================================================================
			Variable     Type                  Description
			===========  ===================== ==============================================================================
			type_of(&x)  struct ABC \*         * ``type_of(x)`` is ``struct ABC``
					                   * Hence, ``type_of(&x)`` is ``struct ABC *``
			type_of(&p)  struct ABC \*\*       * ``type_of(p)`` is ``struct ABC *``
					                   * Hence, ``type_of(&p)`` is ``struct ABC **``
			===========  ===================== ==============================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_13:

	.. tab-set::

	    .. tab-item:: Property 2 : sizeof()

		.. tab-set::

		    .. tab-item:: Property 2.1 : sizeof() of basic types

			======================= =======
			Sizeof(type)            Size   
			======================= =======
			sizeof(char)            1 Byte
			sizeof(int)             4 Bytes
			sizeof(float)           4 Bytes
			sizeof(double)          8 Bytes
			======================= =======

		.. tab-set::

		    .. tab-item:: Property 2.2 : sizeof() of pointer types

                	.. panels::
                        	:container: container pb-4
	                        :column: col-lg-12 p-2
        	                :card: shadow

				``sizeof(pointer types)`` is always 8 Bytes, where pointer is single, double, triple etc.,:

			======================= =======
			Sizeof(type \*)         Size   
			======================= =======
			sizeof(char \*)         8 Bytes
			sizeof(int \*)          8 Bytes
			sizeof(float \*)        8 Bytes
			sizeof(double \*)       8 Bytes
			sizeof(struct xyz \*)   8 Bytes
			sizeof(union xyz \*)    8 Bytes
			======================= =======

			======================= =======
			Sizeof(type \*\*)       Size   
			======================= =======
			sizeof(char \*\*)       8 Bytes
			sizeof(int \*\*)        8 Bytes
			sizeof(float \*\*)      8 Bytes
			sizeof(double \*\*)     8 Bytes
			sizeof(struct xyz \*\*) 8 Bytes
			sizeof(union xyz \*\*)  8 Bytes
			etc., 
			======================= =======

		.. _variable_and_ptr_sp_struct_ptr_property_2_3:

		.. tab-set::

		    .. tab-item:: Property 2.3 : sizeof(&variable) - sizeof address of variable

                	.. panels::
                        	:container: container pb-4
	                        :column: col-lg-12 p-2
        	                :card: shadow
			
				``sizeof(&variable)`` is always 8 Bytes, where ``type_of(variable)`` can be anything

			======================= ======= ========================
			Sizeof(&variable)       Size    Declaration
			======================= ======= ========================
			sizeof(&x)              8 Bytes ``char x;``
			sizeof(&x)              8 Bytes ``int x;``
			sizeof(&x)              8 Bytes ``float x;``
			sizeof(&x)              8 Bytes ``double x;``
			sizeof(&x)              8 Bytes ``struct xyz x;``
			sizeof(&x)              8 Bytes ``union xyz x;``
			======================= ======= ========================

			======================= ======= ========================
			Sizeof(&variable)       Size    Declaration
			======================= ======= ========================
			sizeof(&x)              8 Bytes ``char *x;``
			sizeof(&x)              8 Bytes ``int *x;``
			sizeof(&x)              8 Bytes ``float *x;``
			sizeof(&x)              8 Bytes ``double *x;``
			sizeof(&x)              8 Bytes ``struct xyz *x;``
			sizeof(&x)              8 Bytes ``union xyz *x;``
			======================= ======= ========================

		.. _variable_and_ptr_sp_struct_ptr_property_2_4:

		.. tab-set::

		    .. tab-item:: Property 2.4 : sizeof() of variable
		
                	.. panels::
                        	:container: container pb-4
	                        :column: col-lg-12 p-2
        	                :card: shadow

				``sizeof(variable)`` equals ``sizeof(typeof(variable))``	

	                .. code-block:: c
				:linenos:
				:emphasize-lines: 8, 10

                                struct ABC
                                {
                                        int a;
                                        int b;
                                        int c;
                                };

	                        struct ABC x;

				struct ABC *p;

				p = &x;

				p->a = 10;

			* In above code snippet, there are two variables ``x``, ``p``

			======================= ======== ================================================================================
			Sizeof(Variable)        Size     Description
			======================= ======== ================================================================================
			sizeof(x)               12 Bytes * How ?
               	                                            * Step 1 : ``sizeof(x)`` equals ``sizeof(typeof(x))``
                       	                                    * Step 2 : ``type_of(x)`` is ``struct ABC``
                               	                            * Step 3 : ``sizeof(struct ABC)`` is ``12 Bytes``
                                       	                    * Hence, ``sizeof(x)`` is ``12 Bytes``
			sizeof(p)               8 Bytes  * How ?
       	                                                    * Step 1 : ``sizeof(p)`` equals ``sizeof(typeof(p))``
               	                                            * Step 2 : ``type_of(p)`` is ``struct ABC *``
                       	                                    * Step 3 : ``sizeof(struct ABC *)`` is ``8 Bytes``
                               	                            * Hence, ``sizeof(p)`` is ``8 Bytes``
			======================= ======== ================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_14:

	.. tab-set::

	    .. tab-item:: Property 3 : Scope, Lifetime and Memory of a variable

		* Global Scope and Lifetime

                .. code-block:: c
			:linenos:
			:emphasize-lines: 8, 10

                        struct ABC
                        {
                                int a;
                                int b;
                                int c;
                        };

                        struct ABC x;

			struct ABC *p;

			int main(void)
			{
				p = &x;

				p->a = 10;
				p->b = 20;
				p->c = 30;

				return 0;
			}

		* In above code snippet,

			* Scope
				* Two variables ``x``, ``p`` are defined in Global Scope at Lines 8, 10
				* Which means, they can be accessed in any function defined in current file
				* Which means, they can be accessed in any function defined in other files using extern keyword

                			.. code-block:: c
						:linenos:
						:emphasize-lines: 1, 3

						extern struct ABC x;

						extern struct ABC *p;

						void display(void)
						{
							printf("x.a = %d, p->a = %d\n", x.a, p->a );
							printf("x.b = %d, p->b = %d\n", x.a, p->b );
							printf("x.c = %d, p->c = %d\n", x.a, p->c );
						}

			* Lifetime
				* Lifetime of variables ``x``, ``p`` is same as Lifetime of Process(Program)

			* Memory
				* Memory of ``12 Bytes`` for variable ``x`` is reserved/allocated on Data Segment of the Process
				* Memory of ``8 Bytes`` for variable ``p`` is reserved/allocated on Data Segment of the Process

		* Local Scope and Lifetime

                .. code-block:: c
			:linenos:
			:emphasize-lines: 10, 12

                        struct ABC
                        {
                                int a;
                                int b;
                                int c;
                        };

			int do_calc(void)
			{
				struct ABC x;

				struct ABC *p;

				p = &x;

				p->a = 10;

				return 0;
			}

			int main(void)
			{
				do_calc();

				return 0;
			}

		* In above code snippet,

			* Scope
				* Two variables ``x``, ``p`` are defined in Local Scope at Lines 10, 12 inside function ``do_calc``
				* Which means, they can be accessed only inside a function ``do_calc`` and not anywhere else

			* Lifetime
				* Lifetime of variables ``x``, ``p`` is same as Lifetime of function ``do_calc``

			* Memory
				* When a function call is made for ``do_calc``, stack frame for function ``do_calc`` is created
				* Memory of ``12 Bytes`` for variable ``x`` is reserved/allocated on stack frame of function ``do_calc``
				* Memory of ``8 Bytes`` for variable ``p`` is reserved/allocated on stack frame of function ``do_calc``
				
				* When a function ``do_calc`` returns at Line 18, stack frame for function ``do_calc`` is deleted
				* With this memory of variables ``x``, ``p`` are also deleted

3. Properties of Expressions
***********************************************************************

.. panels::
	:container: container pb-4
	:column: col-lg-12 p-2
	:card: shadow

	In this section, you are going to learn

	* Properties of Expressions

		* What is an Expression ?
		* Table of Expressions
		* Table of Size (for Expressions)
		* Table of Type (for Expressions)
		* Table of Address/Value (for Expression)
		* Table of Function Prototype (for Expression)

.. _variable_and_ptr_sp_struct_ptr_ex_15:

.. tab-set::

    .. tab-item:: Properties of Expressions

                * Let us consider an example program as below

                .. code-block:: c
			:linenos:

                        #include <stdio.h>

                        struct ABC
                        {
                                int a;
                                int b;
                                int c;
                        };

                        int main(void)
                        {
                                struct ABC x;

                                struct ABC *p, *q;

                                int sum;

                                //Write to x
                                x.a = 10;
                                x.b = 20;
                                x.c = 30;

                                //Read from x
                                sum = x.a + x.b + x.c;

                                //Write to p
                                p = &x;

                                //Read from p
                                q = p;

                                //Write to *p or Write to x
                                p->a = 100;
                                p->b = 200;
                                p->c = 300;

                                //Read from *p or Read from x
                                sum = p->a + p->b + p->c;

                                printf("sum = %d\n", sum);

                                return 0;
                        }


                * Output is as below

                .. code-block:: c

                        sum = 600

		.. tab-set::

		    .. tab-item:: What is an Expression ?

			* Expressions must be understood always in a non-declaration C statement

			* Expressions are the valid operations on a given variable - (I am defining this for simplicity !)

		.. tab-set::

		    .. tab-item:: Valid Operations/Expressions of variable ``x``

			* Write of ``x``
				* At Line 19, 20, 21, ``Write`` operation is done on variable ``x``
			* Read of ``x``
				* At Line 24, ``Read`` operation is done on variable ``x`` which is reading content of variable ``x``
			* Fetch Address of ``x`` (&x)
				* At Line 27, Address of variable ``x`` is being fetched and assigned to  pointer variable ``p``

		.. tab-set::

		    .. tab-item:: Valid Operations/Expressions of variable ``p``

			* Write of ``p``
				* At Line 33, 34, 35, ``Write`` operation is done on variable ``p`` which is storing address of ``x`` into ``p``

			* Read of ``p``
				* At Line 38, ``Read`` operation is done on variable ``p`` which is reading content of ``p``

					* ``p`` contains address of ``x``

		.. tab-set::

		    .. tab-item:: Let us write-down expression tables for below code snippet

			.. code-block:: c
				:linenos:
				:emphasize-lines: 1, 3

				struct ABC x;

				struct ABC *p;

				p = &x;

				p->a = 10;

.. _variable_and_ptr_sp_struct_ptr_ex_16:

		.. tab-set::

		    .. tab-item:: Table of Expressions

                        ==========  =====================================================================================================================
                        Expression  Description
                        ==========  =====================================================================================================================
                        x           * ``x`` is a structure
                        &x          * ``&x`` is address of a structure
                                    * ``&x`` is a single pointer
                        p           * ``p`` is a pointer to a structure
                                    * ``p`` is a single pointer
                        &p          * ``&p`` is address of a pointer
                                    * ``&p`` is a double pointer
                        \*p         * ``*p`` is a structure, because ``*p = x``. :ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`
                        p[0]        * ``p[0]`` is a structure, because ``p[0] = x``. :ref:`See Equation 3 <variable_and_ptr_sp_struct_ptr_eq_3>`
                        ==========  =====================================================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_17:

		.. tab-set::

		    .. tab-item:: Table of Size (for Expressions)

                        ===============  ======== ==========================================================================================================================================
                        Expression       Size     Description
                        ===============  ======== ==========================================================================================================================================
                        sizeof(x)        12 Bytes * :ref:`See Property 2.4 <variable_and_ptr_sp_struct_ptr_property_2_4>`
                        sizeof(&x)       8 Bytes  * :ref:`See Property 2.3 <variable_and_ptr_sp_struct_ptr_property_2_3>`
                        sizeof(p)        8 Bytes  * :ref:`See Property 2.4 <variable_and_ptr_sp_struct_ptr_property_2_4>`
                        sizeof(&p)       8 Bytes  * :ref:`See Property 2.3 <variable_and_ptr_sp_struct_ptr_property_2_3>`
                        sizeof(\*p)      12 Bytes * Step 1 : ``sizeof(*p)`` equals ``sizeof(x)`` :ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`
                                                  * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 <variable_and_ptr_sp_struct_ptr_property_2_4>`
                                                  * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See Property 1.1 <variable_and_ptr_sp_struct_ptr_property_1_1>`
                                                  * Step 4 : ``sizeof(struct ABC)`` equals 12 Bytes
                        sizeof(p[0])     12 Bytes * Step 1 : ``sizeof(p[0])`` equals ``sizeof(x)``= x`` :ref:`See Equation 3 <variable_and_ptr_sp_struct_ptr_eq_3>`
                                                  * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 <variable_and_ptr_sp_struct_ptr_property_2_4>`
                                                  * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See Property 1.1 <variable_and_ptr_sp_struct_ptr_property_1_1>`
                                                  * Step 4 : ``sizeof(struct ABC)`` equals 12 Bytes
                        ===============  ======== ==========================================================================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_18:

		.. tab-set::

		    .. tab-item:: Table of Types (for Expressions)

                        ================  ================== =====================================================================================================================================
                        Expression        Type               Description
                        ================  ================== =====================================================================================================================================
                        type_of(x)        struct ABC         * :ref:`See Property 1.1 <variable_and_ptr_sp_struct_ptr_property_1_1>`
                        type_of(&x)       struct ABC \*      * :ref:`See Property 1.2 <variable_and_ptr_sp_struct_ptr_property_1_2>`
                        type_of(p)        struct ABC \*      * :ref:`See Property 1.1 <variable_and_ptr_sp_struct_ptr_property_1_1>`
                        type_of(&p)       struct ABC \*\*    * :ref:`See Property 1.2 <variable_and_ptr_sp_struct_ptr_property_1_2>`
                        type_of(\*p)      struct ABC         * Step 1 : ``type_of(*p)`` equals ``type_of(x)``, because ``*p = x``. :ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`
                                                             * Step 2 : ``type_of(x)`` equals ``struct ABC``
                        type_of(p[0])     struct ABC         * Step 1 : ``type_of(p[0])`` equals ``type_of(x)``, because ``p[0] = x``. :ref:`See Equation 3 <variable_and_ptr_sp_struct_ptr_eq_3>`
                                                             * Step 2 : ``type_of(x)`` equals ``struct ABC``
                        ================  ================== =====================================================================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_19:

		.. tab-set::

		    .. tab-item:: Table of Address/Value (for Expression)


                        ==========  ============== =================================================================================================================
                        Expression  Address/Value  Description
                        ==========  ============== =================================================================================================================
                        x           Value          * Step 1 : ``x`` is a structure
                                                   * Step 2 : Hence ``x`` is a value
                        &x          Address        * & operator indicates address
                        p           Address        * Step 1 : ``p = &x`` :ref:`See Equation 1 <variable_and_ptr_sp_struct_ptr_eq_1>`
                                                   * Step 2 : & operator indicates address
                        &p          Address        * & operator indicates address
                        \*p         Value          * Step 1 : ``*p`` is a structure. ``*p = x`` :ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`
                                                   * Step 2 : Hence ``*p`` is a value
                        p[0]        Value          * Step 1 : ``p[0]`` is a structure. ``p[0] = x`` :ref:`See Equation 3 <variable_and_ptr_sp_struct_ptr_eq_3>`
                                                   * Step 2 : Hence ``p[0]`` is a value
                        ==========  ============== =================================================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_20:

		.. tab-set::

		    .. tab-item:: Table of Function Prototype (for Expression)
                        
			.. panels::
                            :container: container pb-4
                            :column: col-lg-12 p-2
                            :card: shadow

			    If ``fun(v)`` is function call
			    then, ``fun(type_of(v))`` is the prototype

                        =============  ============================== ========================================================================================================
                        Function call  Function Prototype             Description
                        =============  ============================== ========================================================================================================
                        fun(x)         void fun(struct ABC x);        * :ref:`See Property 1.1 <variable_and_ptr_sp_struct_ptr_property_1_1>`
                        fun(&x)        void fun(struct ABC \*p);      * :ref:`See Property 1.2 <variable_and_ptr_sp_struct_ptr_property_1_2>`
                        fun(p)         void fun(struct ABC \*p);      * :ref:`See Property 1.1 <variable_and_ptr_sp_struct_ptr_property_1_1>`
                        fun(&p)        void fun(struct ABC \*\*p);    * :ref:`See Property 1.2 <variable_and_ptr_sp_struct_ptr_property_1_2>`
                        fun(\*p)       void fun(struct ABC x);        * Step 1 : ``fun(*p)`` equals ``fun(x)``:ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`
                                                                      * Step 2 : ``fun(x)`` equals ``fun(type_of(x))``
                                                                      * Step 3 : ``fun(type_of(x))`` equals ``fun(struct ABC)``
                        fun(p[0])      void fun(struct ABC x);        * Step 1 : ``fun(p[0])`` equals ``fun(x)``:ref:`See Equation 2 <variable_and_ptr_sp_struct_ptr_eq_2>`
                                                                      * Step 2 : ``fun(x)`` equals ``fun(type_of(x))``
                                                                      * Step 3 : ``fun(type_of(x))`` equals ``fun(struct ABC)``
                        =============  ============================== ========================================================================================================

.. _variable_and_ptr_sp_struct_ptr_ex_21:

4. Summary
***********************************************************************

======= ============== ============= =================  ================ ============= ===============================
#       ?              Size in Bytes Type               Address or Value Function call Function Prototype
======= ============== ============= =================  ================ ============= ===============================
x       struct ABC     12            struct ABC         Value            fun(x)        void fun(struct ABC x);    
&x      Single Pointer 8             struct ABC \*      Address          fun(&x)       void fun(struct ABC \*p);
p       Single Pointer 8             struct ABC \*      Address          fun(p)        void fun(struct ABC \*p);
&p      Double Pointer 8             struct ABC \*\*    Address          fun(&p)       void fun(struct ABC \*\*q);
\*p     struct ABC     12            struct ABC         Value            fun(\*p)      void fun(struct ABC x); 
p[0]    struct ABC     12            struct ABC         Value            fun(p[0])     void fun(struct ABC x); 
======= ============== ============= =================  ================ ============= ===============================

.. card:: See Also

        * :doc:`dp_struct_ptr`
        * :doc:`tp_struct_ptr`

.. card:: See Also

        * Current Module

                * :doc:`variable_and_ptr`

        * Next Module

                * :doc:`../array_n_ptrs/array_n_ptrs`


        * Other Modules

                * :doc:`../malloc_ptr/malloc_ptr`
                * :doc:`../typecasting_n_ptr/typecasting_n_ptr`
                * :doc:`../funcs_n_ptrs/funcs_n_ptrs`
                * :doc:`../memcpy_ptr/memcpy_ptr`
                * :doc:`../const_ptr/const_ptr`
                * :doc:`../void_ptr/void_ptr`
                * :doc:`../array_of_ptr/array_of_ptr`
                * :doc:`../ptr_to_array/ptr_to_array`
                * :doc:`../function_ptr/function_ptr`
                * :doc:`../pre_incr_ptr/pre_incr_ptr`
                * :doc:`../post_incr_ptr/post_incr_ptr`
                * :doc:`../pre_decr_ptr/pre_decr_ptr`
                * :doc:`../post_decr_ptr/post_decr_ptr`