Equations of Structure Double 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 Double Pointer ` * :ref:`Step 1 : Understand different methods to declare Double Pointer ` * :ref:`Declaration 1 : Structure x, Single Pointer p, Double Pointer q are declared and assigned in same line ` * :ref:`Declaration 2 : Structure x, Single Pointer p, Double Pointer q are declared and assigned in separate lines ` * :ref:`Declaration 3 : Structure x, Single Pointer p, Double Pointer q are declared in one line and assigned in another line ` * :ref:`Table of Declarations for Double Pointer ` * :ref:`Step 2 : Split pointer declarations and assignments into separate lines ` * :ref:`Step 3 : Derive Equations ` * :ref:`Step 4 : Apply above equations to analyse C statements ` * :ref:`Table of Equations for Single Pointer ` * :ref:`Table of Equations for Double Pointer ` * :ref:`Properties of a variable ` * :ref:`Property 1 : Type ` * :ref:`Property 2 : sizeof() ` * :ref:`Property 3 : Scope, Lifetime and Memory of a variable ` * :ref:`Properties of Expressions ` * :ref:`Table of Expressions ` * :ref:`Table of Size (for Expressions) ` * :ref:`Table of Types (for Expressions) ` * :ref:`Table of Address/Value (for Expression) ` * :ref:`Table of Function Prototype (for Expression) ` * :ref:`Summary ` 1. Equations of Double 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 Double pointer ? * How to apply these equations to understand C statements ? .. _variable_and_ptr_dp_struct_ptr_ex_1: .. tab-set:: .. tab-item:: Derive Equations for Double 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_dp_struct_ptr_ex_2: .. tab-set:: .. tab-item:: Step 1 : Understand different methods to declare Double Pointer .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow There are many methods in C, using which a Double pointer can be declared. See below .. _variable_and_ptr_dp_struct_ptr_ex_3: .. tab-set:: .. tab-item:: Declaration 1 : Structure ``x``, Single Pointer ``p``, Double Pointer ``q`` are declared and assigned in same line .. code-block:: c :linenos: :emphasize-lines: 12 #include struct ABC { int a; int b; int c; }; int main(void) { struct ABC x = {.a = 1, .b = 2, .c = 3}, *p = &x, **q = &p; printf("x.a = %d\n", x.a); printf("x.b = %d\n", x.b); printf("x.c = %d\n", x.c); printf("(**q).a = %d\n", (**q).a); printf("(**q).b = %d\n", (**q).b); printf("(**q).c = %d\n", (**q).c); printf("(*q)[0].a = %d\n", (*q)[0].a); printf("(*q)[0].b = %d\n", (*q)[0].b); printf("(*q)[0].c = %d\n", (*q)[0].c); printf("(*q)->a = %d\n", (*q)->a); printf("(*q)->b = %d\n", (*q)->b); printf("(*q)->c = %d\n", (*q)->c); printf("q[0][0].a = %d\n", q[0][0].a); printf("q[0][0].b = %d\n", q[0][0].b); printf("q[0][0].c = %d\n", q[0][0].c); return 0; } * Output is as below .. code-block:: c x.a = 1 x.b = 2 x.c = 3 (**q).a = 1 (**q).b = 2 (**q).c = 3 (*q)[0].a = 1 (*q)[0].b = 2 (*q)[0].c = 3 (*q)->a = 1 (*q)->b = 2 (*q)->c = 3 q[0][0].a = 1 q[0][0].b = 2 q[0][0].c = 3 .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow In this example, * ``x`` is a structure * ``p`` is an single structure pointer * ``q`` is an double structure pointer * ``x``, ``p``, ``q`` are declared in one Single Line * ``x``, ``p``, ``q`` are assigned in one Single Line * ``x`` is assigned with value 10 * ``p`` is assigned with address of ``x`` * ``q`` is assigned with address of ``p`` .. _variable_and_ptr_dp_struct_ptr_ex_4: .. tab-set:: .. tab-item:: Declaration 2 : Structure ``x``, Single Pointer ``p``, Double Pointer ``q`` are declared and assigned in separate lines .. code-block:: c :linenos: :emphasize-lines: 12, 13, 14 #include struct ABC { int a; int b; int c; }; int main(void) { struct ABC x = {.a = 1, .b = 2, .c = 3}; struct ABC *p = &x; struct ABC **q = &p; printf("x.a = %d\n", x.a); printf("x.b = %d\n", x.b); printf("x.c = %d\n", x.c); printf("(**q).a = %d\n", (**q).a); printf("(**q).b = %d\n", (**q).b); printf("(**q).c = %d\n", (**q).c); printf("(*q)[0].a = %d\n", (*q)[0].a); printf("(*q)[0].b = %d\n", (*q)[0].b); printf("(*q)[0].c = %d\n", (*q)[0].c); printf("(*q)->a = %d\n", (*q)->a); printf("(*q)->b = %d\n", (*q)->b); printf("(*q)->c = %d\n", (*q)->c); printf("q[0][0].a = %d\n", q[0][0].a); printf("q[0][0].b = %d\n", q[0][0].b); printf("q[0][0].c = %d\n", q[0][0].c); return 0; } * Output is as below .. code-block:: c x.a = 1 x.b = 2 x.c = 3 (**q).a = 1 (**q).b = 2 (**q).c = 3 (*q)[0].a = 1 (*q)[0].b = 2 (*q)[0].c = 3 (*q)->a = 1 (*q)->b = 2 (*q)->c = 3 q[0][0].a = 1 q[0][0].b = 2 q[0][0].c = 3 .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow In this example, * ``x`` is a structure * ``p`` is a single structure pointer * ``q`` is a double structure pointer * ``x`` is declared in a separate line * ``p`` is declared in a separate line * ``q`` is declared in a separate line * ``x`` is assigned in the same line of declaration * ``p`` is assigned in the same line of declaration * ``q`` is assigned in the same line of declaration * ``x`` is assigned with value 10 * ``p`` is assigned with address of ``x`` * ``q`` is assigned with address of ``p`` .. _variable_and_ptr_dp_struct_ptr_declaration_3: .. _variable_and_ptr_dp_struct_ptr_ex_5: .. tab-set:: .. tab-item:: Declaration 3 : Structure ``x``, Single Pointer ``p``, Double Pointer ``q`` are declared in one line and assigned in another line .. code-block:: c :linenos: :emphasize-lines: 12, 13, 14, 20, 22 #include struct ABC { int a; int b; int c; }; int main(void) { struct ABC x; struct ABC *p; struct ABC **q; x.a = 1; x.b = 2; x.c = 3; p = &x; q = &p; printf("x.a = %d\n", x.a); printf("x.b = %d\n", x.b); printf("x.c = %d\n", x.c); printf("(**q).a = %d\n", (**q).a); printf("(**q).b = %d\n", (**q).b); printf("(**q).c = %d\n", (**q).c); printf("(*q)[0].a = %d\n", (*q)[0].a); printf("(*q)[0].b = %d\n", (*q)[0].b); printf("(*q)[0].c = %d\n", (*q)[0].c); printf("(*q)->a = %d\n", (*q)->a); printf("(*q)->b = %d\n", (*q)->b); printf("(*q)->c = %d\n", (*q)->c); printf("q[0][0].a = %d\n", q[0][0].a); printf("q[0][0].b = %d\n", q[0][0].b); printf("q[0][0].c = %d\n", q[0][0].c); return 0; } * Output is as below .. code-block:: c x.a = 1 x.b = 2 x.c = 3 (**q).a = 1 (**q).b = 2 (**q).c = 3 (*q)[0].a = 1 (*q)[0].b = 2 (*q)[0].c = 3 (*q)->a = 1 (*q)->b = 2 (*q)->c = 3 q[0][0].a = 1 q[0][0].b = 2 q[0][0].c = 3 .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow In this example, * ``x`` is a structure * ``p`` is a single structure pointer * ``q`` is a double structure pointer * ``x`` is declared in a separate line * ``p`` is declared in a separate line * ``q`` is declared in a separate line * ``x`` is assigned and is not part of declaration * ``p`` is assigned and is not part of declaration * ``q`` is assigned and is not part of declaration * ``x`` is assigned with value 10 * ``p`` is assigned with address of ``x`` * ``q`` is assigned with address of ``p`` .. _variable_and_ptr_dp_struct_ptr_ex_6: .. tab-set:: .. tab-item:: Table of Declarations for Double Pointer ========== ================================================ ====================================================================================================== Decl # Declaration Description ========== ================================================ ====================================================================================================== Decl 1 * struct ABC x, \*p = &x, \*\*q = &p; Structure x, Single Pointer p, Double Pointer q are declared and assigned in same line Decl 2 * struct ABC x; Structure x, Single Pointer p, Double Pointer q are declared and assigned in separate lines * struct ABC \*p = &x; * struct ABC \*\*q = &p; Decl 3 * struct ABC x; Structure x, Single Pointer p, Double Pointer q are declared in one line and assigned in another line * struct ABC \*p; * struct ABC \*\*q; * x.a = 1; * x.b = 2; * x.c = 3; * p = &x; * q = &p; ========== ================================================ ====================================================================================================== .. _variable_and_ptr_dp_struct_ptr_ex_7: .. tab-set:: .. tab-item:: Step 2 : Split pointer declarations and assignments into separate lines .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow * 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_dp_struct_ptr_ex_8: .. tab-set:: .. tab-item:: Step 3 : Derive Equations .. tab-set:: .. tab-item:: Derive Equations of Single Pointer .. _variable_and_ptr_dp_struct_ptr_eq_1: * Equation 1 : Obtained from ``Step 2`` .. code-block:: c p = &x; .. _variable_and_ptr_dp_struct_ptr_eq_2: * Equation 2 : Move ``&`` to the left of First Equation. It turns in to ``*`` .. code-block:: c *p = x; .. _variable_and_ptr_dp_struct_ptr_eq_3: * Equation 3 : * and [0] can be used interchangeably. Hence ``*p`` and ``p[0]`` are one and the same ! .. code-block:: c p[0] = x; .. _variable_and_ptr_dp_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; .. tab-set:: .. tab-item:: Derive Equations of Double Pointer .. _variable_and_ptr_dp_struct_ptr_eq_5: * Equation 5 : Obtained from ``Step 2`` .. code-block:: c q = &p; .. _variable_and_ptr_dp_struct_ptr_eq_6: * Equation 6 : Move & to the left of First Equation. It turns in to \* .. code-block:: c *q = p; .. _variable_and_ptr_dp_struct_ptr_eq_7: * Equation 7 : \* and [0] can be used interchangeably. Hence \*q and q[0] are one and the same ! .. code-block:: c q[0] = p; .. _variable_and_ptr_dp_struct_ptr_eq_8: * Equation 8 : From Equation 6, Equation 7, we can derive that ``p``, ``*q``, ``q[0]`` all are same ! .. code-block:: c *q = q[0] = p; .. _variable_and_ptr_dp_struct_ptr_eq_9: * Equation 9 : From Equation 1, we know ``p = &x``. Hence Replace ``p`` with ``&x`` in Equation 8 .. code-block:: c *q = q[0] = &x; .. _variable_and_ptr_dp_struct_ptr_eq_10: * Equation 10 : Move & to the left of Equation 9. It turns in to * .. code-block:: c **q = *q[0] = x; .. _variable_and_ptr_dp_struct_ptr_eq_11: * Equation 11 : \* and [0] can be used interchangeably .. code-block:: c q[0][0] = x; .. _variable_and_ptr_dp_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 \* and [0] can be used interchangeably. Hence \*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 =========== ================== =========================================================================== .. _variable_and_ptr_dp_struct_ptr_ex_22: .. tab-set:: .. tab-item:: Table of Equations for Double Pointer =========== ================== =========================================================================== Equation # Equation Description =========== ================== =========================================================================== Equation 5 q = &p Base condition Equation 6 \*q = p From Equation 5, Move & from RHS to LHS to get \* on LHS Equation 7 q[0] = p \* and [0] can be used interchangeably. Hence \*q and q[0] are synonyms Equation 8 \*q = q[0] = p From Equation 6, Equation 7, we can derive that p, \*q, q[0] all are same ! Equation 9 \*q = q[0] = &x From Equation 1, we know p = &x. Hence Replace p with &x in Equation 8 Equation 10 \*\*q = \*q[0] = x From Equation 9, Move & from RHS to LHS to get \* on LHS Equation 11 q[0][0] = x \* and [0] can be used interchangeably =========== ================== =========================================================================== .. _variable_and_ptr_dp_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 ` : 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 ` : 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 : :ref:`See Equation 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:: Example 4 : 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 5 : :ref:`See Equation 10 ` : Changing ``**q`` changes the value of ``x`` .. code-block:: c (**q).a = 100; printf("x.a = %d, (**q).a = %d\n", x.a, (**q).a); .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow Output : ``x.a`` = 100, ``(**q).a`` = 100 .. tab-set:: .. tab-item:: Example 6 : :ref:`See Equation 10 ` : Changing ``*q[0]`` changes the value of ``x`` .. code-block:: c (*q)[0].a = 100; printf("x.a = %d, (*q)[0].a = %d\n", x.a, (*q)[0].a); .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow Output : ``x.a`` = 100, ``(*q)[0].a`` = 100 .. tab-set:: .. tab-item:: Example 7 : :ref:`See Equation 11 ` : Changing ``q[0][0]`` changes the value of ``x`` .. code-block:: c q[0][0].a = 100; printf("x.a = %d, q[0][0].a = %d\n", x.a, q[0][0].a); .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow Output : ``x.a`` = 100, ``q[0][0].a`` = 100 .. tab-set:: .. tab-item:: Example 8 : :ref:`See Equation 6 ` : ``*q``, ``p`` are synonyms. Means chaning ``*q`` also changes ``p`` .. code-block:: c struct ABC x, y, *p, **q; x.a = 100; p = &x; q = &p; printf("(*p).a = %d, p[0].a = %d, (**q).a = %d\n", (*p).a, p[0].a, (**q).a); y.a = 200; // *q, p are synonyms. // Means *q = &y also means p = &y *q = &y; printf("(*p).a = %d, p[0].a = %d, (**q).a = %d\n", (*p).a, p[0].a, (**q).a); .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow Output : ``(*p).a`` = 100, ``p[0].a`` = 100, ``(**q).a`` = 100 ``(*p).a`` = 200, ``p[0].a`` = 200, ``(**q).a`` = 200 .. tab-set:: .. tab-item:: Example 9 : :ref:`See Equation 7 ` : ``q[0]``, ``p`` are synonyms. Means chaning ``q[0]`` also changes ``p`` .. code-block:: c struct ABC x, y, *p, **q; x.a = 100; p = &x; q = &p; printf("(*p).a = %d, p[0].a = %d, (**q).a = %d\n", (*p).a, p[0].a, (**q).a); y.a = 200; // q[0], p are synonyms. // Means q[0] = &y also means p = &y q[0] = &y; printf("(*p).a = %d, p[0].a = %d, (**q).a = %d\n", (*p).a, p[0].a, (**q).a); .. panels:: :container: container pb-4 :column: col-lg-12 p-2 :card: shadow Output : ``(*p).a`` = 100, ``p[0].a`` = 100, ``(**q).a`` = 100 ``(*p).a`` = 200, ``p[0].a`` = 200, ``(**q).a`` = 200 .. tab-set:: .. tab-item:: Step 5 : Complete program .. code-block:: c :linenos: #include struct ABC { int a; int b; int c; }; int main(void) { struct ABC x; struct ABC *p; struct ABC **q; x.a = 10; p = &x; q = &p; printf("x.a = %d, (*p).a = %d, p[0].a = %d, (**q).a = %d\n", x.a, (*p).a, p[0].a, (**q).a); x.a = 20; printf("x.a = %d, (*p).a = %d, p[0].a = %d, (**q).a = %d\n", x.a, (*p).a, p[0].a, (**q).a); (*p).a = 30; printf("x.a = %d, (*p).a = %d, p[0].a = %d, (**q).a = %d\n", x.a, (*p).a, p[0].a, (**q).a); p[0].a = 40; printf("x.a = %d, (*p).a = %d, p[0].a = %d, (**q).a = %d\n", x.a, (*p).a, p[0].a, (**q).a); (**q).a = 50; printf("x.a = %d, (*p).a = %d, p[0].a = %d, (**q).a = %d\n", x.a, (*p).a, p[0].a, (**q).a); return 0; } * Output is as below .. code-block:: c x.a = 10, (*p).a = 10, p[0].a = 10, (**q).a = 10 x.a = 20, (*p).a = 20, p[0].a = 20, (**q).a = 20 x.a = 30, (*p).a = 30, p[0].a = 30, (**q).a = 30 x.a = 40, (*p).a = 40, p[0].a = 40, (**q).a = 40 x.a = 50, (*p).a = 50, p[0].a = 50, (**q).a = 50 2. Properties of a variable *********************************************************************** .. _variable_and_ptr_dp_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_dp_struct_ptr_ex_12: .. tab-set:: .. tab-item:: Property 1 : Type .. _variable_and_ptr_dp_struct_ptr_property_1_1_1_1: .. tab-set:: .. tab-item:: Property 1.1 : type_of(variable) .. code-block:: c :linenos: :emphasize-lines: 1, 3, 5 struct ABC x; struct ABC *p; struct ABC **q; p = &x; q = &p; * In above code snippet, there are three variables ``x``, ``p``, ``q`` =========== ================== ============================================================================== Variable Type Description =========== ================== ============================================================================== type_of(x) struct ABC See Line 1 type_of(p) struct ABC \* See Line 3 type_of(q) struct ABC \*\* See Line 5 =========== ================== ============================================================================== .. _variable_and_ptr_dp_struct_ptr_property_1_1_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, 5 struct ABC x; struct ABC *p; struct ABC **q; p = &x; q = &p; * 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 **`` type_of(&q) struct ABC \*\*\* * ``type_of(q)`` is ``struct ABC **`` * Hence, ``type_of(&q)`` is ``struct ABC ***`` =========== ======================= ============================================================================== .. _variable_and_ptr_dp_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_dp_struct_ptr_property_1_1_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;`` ======================= ======= ======================== ======================= ======= ======================== 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_dp_struct_ptr_property_1_1_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: 1, 3, 5 struct ABC x; struct ABC *p; struct ABC **q; p = &x; q = &p; * In above code snippet, there are three variables ``x``, ``p``, ``q`` ======================= ======== ================================================================================ 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`` sizeof(q) 8 Bytes * How ? * Step 1 : ``sizeof(q)`` equals ``sizeof(typeof(q))`` * Step 2 : ``type_of(q)`` is ``struct ABC **`` * Step 3 : ``sizeof(struct ABC **)`` is ``8 Bytes`` * Hence, ``sizeof(q)`` is ``8 Bytes`` ======================= ======== ================================================================================ .. _variable_and_ptr_dp_struct_ptr_ex_14: .. tab-set:: .. tab-item:: Property 3 : Scope, Lifetime and Memory of a variable * Global Scope and Lifetime. * Local Scope and Lifetime 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_dp_struct_ptr_ex_15: .. tab-set:: .. tab-item:: Properties of Expressions .. tab-set:: .. tab-item:: Let us write-down expression tables for below code snippet .. code-block:: c :linenos: :emphasize-lines: 1, 3, 5 struct ABC x; struct ABC *p; struct ABC **q; p = &x; q = &p; (*p).a = 100; // or p->a = 100; (**q).a = 100; // or (*q)->a = 100; .. _variable_and_ptr_dp_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 ` p[0] * ``p[0]`` is a structure, because ``p[0] = x``. :ref:`See Equation 3 ` q * ``q`` is a double pointer and holds the address of a single pointer &q * ``&q`` is address of a double pointer * ``&q`` is a triple pointer \*q * ``*q`` holds the address of structure x. :ref:`See Equation 9 ` * ``*q`` is a single pointer. ``*q = p``. :ref:`See Equation 8 ` q[0] * ``q[0]`` holds the address of structure x. :ref:`See Equation 9 ` * ``q[0]`` is a single pointer. ``*q = p``. :ref:`See Equation 8 ` \*\*q * ``**q`` is a structure. :ref:`See Equation 10 ` \*q[0] * ``*q[0]`` is a structure. :ref:`See Equation 10 ` q[0][0] * ``q[0][0]`` is a structure. :ref:`See Equation 11 ` ========== =============================================================================================================================== .. _variable_and_ptr_dp_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 ` sizeof(&x) 8 Bytes * :ref:`See Property 2.3 ` sizeof(p) 8 Bytes * :ref:`See Property 2.4 ` sizeof(&p) 8 Bytes * :ref:`See Property 2.3 ` sizeof(\*p) 12 Bytes * Step 1 : ``sizeof(*p)`` equals ``sizeof(x)`` :ref:`See Equation 2 ` * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See 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 ` * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See Property 1.1 ` * Step 4 : ``sizeof(struct ABC)`` equals 12 Bytes sizeof(q) 8 Bytes * :ref:`See Property 2.4 ` sizeof(&q) 8 Bytes * :ref:`See Property 2.3 ` sizeof(\*q) 8 Bytes * Step 1 : ``sizeof(*q)`` equals ``sizeof(p)``. :ref:`See Equation 8 ` * Step 2 : ``sizeof(p)``, equals ``sizeof(type_of(p))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(p))`` equals ``sizeof(struct ABC *)`` :ref:`See Property 1.1 ` * Step 4 : ``sizeof(struct ABC *)`` equals 8 Bytes sizeof(q[0]) 8 Bytes * Step 1 : ``sizeof(q[0])`` equals ``sizeof(p)`` :ref:`See Equation 8 ` * Step 2 : ``sizeof(p)`` equals ``sizeof(type_of(p))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(p))`` equals ``sizeof(struct ABC *)`` :ref:`See Property 1.1 ` * Step 4 : ``sizeof(struct ABC *)`` * equals 8 Bytes sizeof(\*\*q) 12 Bytes * Step 1 : ``sizeof(**q)`` equals ``sizeof(x)`` :ref:`See Equation 10 ` * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See Property 1.1 ` * Step 4 : ``sizeof(struct ABC)`` equals 12 Bytes sizeof(\*q[0]) 12 Bytes * Step 1 : ``sizeof(*q[0])`` equals ``sizeof(x)`` :ref:`See Equation 10 ` * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See Property 1.1 ` * Step 4 : ``sizeof(struct ABC)`` equals 12 Bytes sizeof(q[0][0]) 12 Bytes * Step 1 : ``sizeof(q[0][0])`` equals ``sizeof(x)`` :ref:`See Equation 11 ` * Step 2 : ``sizeof(x)`` equals ``sizeof(type_of(x))`` :ref:`See Property 2.4 ` * Step 3 : ``sizeof(type_of(x))`` equals ``sizeof(struct ABC)`` :ref:`See Property 1.1 ` * Step 4 : ``sizeof(struct ABC)`` equals 12 Bytes =============== ======== ======================================================================================================================================================= .. _variable_and_ptr_dp_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 ` type_of(&x) struct ABC \* * :ref:`See Property 1.2 ` type_of(p) struct ABC \* * :ref:`See Property 1.1 ` type_of(&p) struct ABC \*\* * :ref:`See Property 1.2 ` type_of(\*p) struct ABC * Step 1 : ``type_of(*p)`` equals ``type_of(x)``, because ``*p = x``. :ref:`See Equation 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 ` * Step 2 : ``type_of(x)`` equals ``struct ABC`` type_of(q) struct ABC \*\* * :ref:`See Property 1.1 ` type_of(&q) struct ABC \*\*\* * :ref:`See Property 1.2 ` type_of(\*q) struct ABC \* * Step 1 : ``type_of(*q)`` equals ``type_of(p)``. :ref:`See Equation 8 ` * Step 2 : ``type_of(p)``, equals ``struct ABC *`` :ref:`See Property 1.1 ` type_of(q[0]) struct ABC \* * Step 1 : ``type_of(q[0])`` equals ``type_of(p)`` :ref:`See Equation 8 ` * Step 2 : ``type_of(p)`` equals ``struct ABC *`` :ref:`See Property 1.1 ` type_of(\*\*q) struct ABC * Step 1 : ``type_of(**q)`` equals ``type_of(x)`` :ref:`See Equation 10 ` * Step 2 : ``type_of(x)`` equals ``struct ABC`` :ref:`See Property 1.1 ` type_of(\*q[0]) struct ABC * Step 1 : ``type_of(*q[0])`` equals ``type_of(x)`` :ref:`See Equation 10 ` * Step 2 : ``type_of(x)`` equals ``struct ABC`` :ref:`See Property 1.1 ` type_of(q[0][0]) struct ABC * Step 1 : ``type_of(q[0][0])`` equals ``type_of(x)`` :ref:`See Equation 11 ` * Step 2 : ``type_of(x)`` equals ``struct ABC`` :ref:`See Property 1.1 ` ================ ======================== ====================================================================================================================================== .. _variable_and_ptr_dp_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 ` * Step 2 : & operator indicates address &p Address * & operator indicates address \*p Value * Step 1 : ``*p`` is a structure. ``*p = x`` :ref:`See Equation 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 ` * Step 2 : Hence ``p[0]`` is a value q Address * Step 1 : ``q = &p`` :ref:`See Equation 5 ` * Step 2 : & operator indicates address &q Address * & operator indicates address \*q Address * Step 1 : ``*q = p`` :ref:`See Equation 6 ` * Step 2 : ``p = &x`` * Step 3 : & operator indicates address q[0] Address * Step 1 : ``q[0] = p`` :ref:`See Equation 7 ` * Step 2 : ``p = &x`` * Step 3 : & operator indicates address \*\*q Value * Step 1 : ``**q = x`` :ref:`See Equation 10 ` * Step 2 : ``x`` is a structure * Step 3 : ``**q`` is a Value \*q[0] Value * Step 1 : ``*q[0] = x`` :ref:`See Equation 10 ` * Step 2 : ``x`` is a structure * Step 3 : ``*q[0]`` is a Value q[0][0] Value * Step 1 : ``q[0][0] = x`` :ref:`See Equation 11 ` * Step 2 : ``x`` is a structure * Step 3 : ``q[0][0]`` is a Value ========== ============== =========================================================================================================================== .. _variable_and_ptr_dp_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 ` fun(&x) void fun(struct ABC \*p); * :ref:`See Property 1.2 ` fun(p) void fun(struct ABC \*p); * :ref:`See Property 1.1 ` fun(&p) void fun(struct ABC \*\*p); * :ref:`See Property 1.2 ` fun(\*p) void fun(struct ABC x); * Step 1 : ``fun(*p)`` equals ``fun(x)``:ref:`See Equation 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 ` * Step 2 : ``fun(x)`` equals ``fun(type_of(x))`` * Step 3 : ``fun(type_of(x))`` equals ``fun(struct ABC)`` fun(q) void fun(struct ABC \*\*q); * :ref:`See Property 1.1 ` fun(&q) void fun(struct ABC \*\*\*q); * :ref:`See Property 1.2 ` fun(\*q) void fun(struct ABC \*q); * Step 1 : ``fun(*q)`` equals ``fun(p)`` * Step 2 : ``fun(p)`` equals ``fun(type_of(p))`` * Step 3 : ``fun(type_of(p))`` equals ``fun(struct ABC *)`` fun(q[0]) void fun(struct ABC \*q); * Step 1 : ``fun(q[0])`` equals ``fun(p)`` * Step 2 : ``fun(p)`` equals ``fun(type_of(p))`` * Step 3 : ``fun(type_of(p))`` equals ``fun(struct ABC *)`` fun(\*\*q) void fun(struct ABC x); * Step 1 : ``fun(**q)`` equals ``fun(x)`` :ref:`See Equation 10 ` * Step 2 : ``fun(x)`` equals ``fun(type_of(x))`` * Step 3 : ``fun(type_of(x))`` equals ``fun(struct ABC)`` fun(\*q[0]) void fun(struct ABC x); * Step 1 : ``fun(*q[0])`` equals ``fun(x)`` :ref:`See Equation 10 ` * Step 2 : ``fun(x)`` equals ``fun(type_of(x))`` * Step 3 : ``fun(type_of(x))`` equals ``fun(struct ABC)`` fun(q[0][0]) void fun(struct ABC x); * Step 1 : ``fun(q[0][0])`` equals ``fun(x)`` :ref:`See Equation 11 ` * Step 2 : ``fun(x)`` equals ``fun(type_of(x))`` * Step 3 : ``fun(type_of(x))`` equals ``fun(struct ABC)`` ============= ========================================= ================================================================================================================= .. _variable_and_ptr_dp_struct_ptr_ex_21: 4. Summary *********************************************************************** ======= ============== ============= ==================== ================ ============= ===================================== # ? Size in Bytes Type Address or Value Function call Function Prototype ======= ============== ============= ==================== ================ ============= ===================================== x Structure 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 Structure 12 struct ABC Value fun(\*p) void fun(struct ABC x); p[0] Structure 12 struct ABC Value fun(p[0]) void fun(struct ABC x); q Double Pointer 8 struct ABC \*\* Address fun(q) void fun(struct ABC \*\*q); &q Triple Pointer 8 struct ABC \*\*\* Address fun(&q) void fun(struct ABC \*\*\*r); \*q Single Pointer 8 struct ABC \* Address fun(\*q) void fun(struct ABC \*p); q[0] Single Pointer 8 struct ABC \* Address fun(q[0]) void fun(struct ABC \*p); \*\*q Structure 12 struct ABC Value fun(\*\*q) void fun(struct ABC x); \*q[0] Structure 12 struct ABC Value fun(\*q[0]) void fun(struct ABC x); q[0][0] Structure 12 struct ABC Value fun(q[0][0]) void fun(struct ABC x); ======= ============== ============= ==================== ================ ============= ===================================== .. card:: See Also * :doc:`sp_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`