Functions and Integer 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 calling conventions of integer single pointer ?

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

	Call by Value

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

	Call by Reference

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

	Revisit Basics : :doc:`../../basic_ptr/basic_int_ptr/int_sp`

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

	Topics in this section,

		* :ref:`Integer Single Pointer : Syntax <funcs_n_ptrs_int_sp_ex_0_0>`
		* :ref:`Integer Single Pointer : FAQs <funcs_n_ptrs_int_sp_ex_0_1>`
		* :ref:`Integer Single Pointer : fun(expression) <funcs_n_ptrs_int_sp_ex_6>`

                * :ref:`Rules for Call By Value  <funcs_n_ptrs_int_sp_rules_for_call_by_value>`

                * :ref:`Rules for Call By Reference <funcs_n_ptrs_int_sp_rules_for_call_by_reference>`

                * :ref:`Examples of Call by Value <funcs_n_ptrs_int_sp_examples_call_by_value>`

        		* :ref:`Example 1 : Call by Value with [ ] <funcs_n_ptrs_int_sp_ex_7>`
		        * :ref:`Example 2 : Call by Value with * <funcs_n_ptrs_int_sp_ex_8>`

                * :ref:`Examples of Call by Reference <funcs_n_ptrs_int_sp_examples_call_by_reference>`

	        	* :ref:`Example 3 : Call by Reference WITH &sp[ ] <funcs_n_ptrs_int_sp_ex_9>`
        		* :ref:`Example 4 : Call by Reference WITH (sp + x) <funcs_n_ptrs_int_sp_ex_10>`
        		* :ref:`Example 5 : Pass full array to a function <funcs_n_ptrs_int_sp_ex_12>`
	        	* :ref:`Example 6 : Pass part of the array by reference <funcs_n_ptrs_int_sp_ex_13>`
		        * :ref:`Example 7 : Address of full array and Pointer to an Array <funcs_n_ptrs_int_sp_ex_14>`

.. _funcs_n_ptrs_int_sp_ex_0_0:

.. tab-set::

        .. tab-item:: Integer Single Pointer : Syntax

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

                        int \*sp;

.. _funcs_n_ptrs_int_sp_ex_0_1:

.. tab-set::

        .. tab-item:: Integer Single Pointer : FAQs

                Consider a Integer Single Pointer

                .. code-block:: c

                        int *sp;

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

                        Let us answer few basic questions about integer single pointer


.. _funcs_n_ptrs_int_sp_ex_6:

.. tab-set::

        .. tab-item:: Integer Single Pointer : fun(expression)

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

			If ``fun(x)`` is the function call, then ``fun(typeof(x))`` is the prototype / definition

		================== =============================== ==========================================================================
		Function Call      Function Definition             Observations
		================== =============================== ==========================================================================
		fun(sp[0])         void fun(int x) { }		   * Call by Value
		fun(sp[1])         void fun(int x) { }             * Call by Value
		fun(sp[9])         void fun(int x) { }             * Call by Value
		fun(&sp[0])        void fun(int \*p) { }           * Call by Reference
		fun(&sp[1])        void fun(int \*p) { }           * Call by Reference
		fun(&sp[9])        void fun(int \*p) { }           * Call by Reference
		fun(\*sp)          void fun(int x) { }             * Call by Value
		fun(\*(sp + 1))    void fun(int x) { }             * Call by Value
		fun(\*(sp + 9))    void fun(int x) { }             * Call by Value
		fun(sp)            void fun(int \*p) { }           * Call by Reference
		fun(sp + 1)        void fun(int \*p) { }           * Call by Reference
		fun(sp + 9)        void fun(int \*p) { }           * Call by Reference
		fun(&sp)           void fun(int \*\*p) { }         * Call by Reference
		================== =============================== ==========================================================================

.. _funcs_n_ptrs_int_sp_rules_for_call_by_value:

.. tab-set::

        .. tab-item:: Rules for Call by Value

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

                        If Declaration has ONE dereference operator, and
        
                                * Expression has ONE dereference operator [], and
        
                                * Expression does not have ``&``
        
                                * then it is call by value

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

                        If Declaration has ONE dereference operators, and
        
                                * Expression has ONE dereference operator \*, and
        
                                * Expression does not have ``&``
        
                                * then it is call by value

.. _funcs_n_ptrs_int_sp_rules_for_call_by_reference:

.. tab-set::

        .. tab-item:: Rules for Call by Reference

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

                        If Declaration has ONE dereference operator, and

                                * Expression has ONE dereference operators [] or \*, and

                                * Expression has ONE &

                                * then it is call by reference

                                * Example : &sp[0]

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

                        If Declaration has ONE dereference operator, and

                                * Expression has ZERO dereference operator [ ] or \*, and

                                * Expression has ZERO & operator

                                * then it is call by reference

                                * Example : sp + 1, sp + 4

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

                        If Declaration has ONE dereference operator, and

                                * Expression has ZERO dereference operator [ ] or \*, and

                                * Expression has ONE & operator

                                * then it is call by reference

                                * Example : &sp

.. _funcs_n_ptrs_int_sp_examples_call_by_value:

.. tab-set::

        .. tab-item:: Examples of Call by Value

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

                        Let us look at examples of Call by Value

.. _funcs_n_ptrs_int_sp_ex_7:

.. tab-set::

        .. tab-item:: Example 1 : Call by Value with [ ]

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

			Example for Call By Value with [ ]

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass an individual integer ``sp[2]`` to a function. Call by Value

		.. code-block:: c

		        fun(sp[2]);

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

			Individual heap elements can be accessed using [ ]

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

			In this case ``sp[2]`` is third integer in the heap

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

			``sp[2]`` is fully dereferenced and there is no ``&`` symbol in ``fun(sp[2])``. Hence this is Call By Value

		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun(int x)
			{

			}

		* Step 6 : Change value of ``x`` inside function ``fun``

		.. code-block:: c

			void fun(int x)
			{
			        x = 100;

			        printf("x = %d\n", x);
			}

		* Step 7 : Free heap memory after use

		.. code-block:: c

                        free(sp);

		* See the full program below

		.. code-block:: c

			#include <stdio.h>
                        #include <stdlib.h>

			void fun(int x)
			{
			        x = 100;

			        printf("x = %d\n", x);
			}

			int main(void)
			{
        		        int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;

                                printf("----- Before call by value -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

			        fun(sp[2]);

                                printf("----- After call by value -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by value -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

                        x = 100

                        ----- After call by value -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

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

			Changing value of ``x`` inside function ``fun`` DOES NOT change ``sp[2]``

.. _funcs_n_ptrs_int_sp_ex_8:

.. tab-set::

        .. tab-item:: Example 2 : Call by Value with ``*``

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

			Example for Call By Value with ``*``

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass an individual integer ``*(a + 2)`` to a function. Call by Value

		.. code-block:: c

		        fun( *(sp + 2) );

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

			Individual array elements can be accessed using ``*``

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

			In this case ``*(sp + 2)`` is third integer in the array

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

			``*(sp + 2)`` is fully dereferenced and there is no ``&`` symbol in ``fun( *(sp + 2) )``. Hence this is Call By Value

		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun(int x)
			{

			}

		* Step 6 : Change value of ``x`` inside function ``fun``

		.. code-block:: c

			void fun(int x)
			{
			        x = 100;

			        printf("x = %d\n", x);
			}

                * Step 7 : Free heap memory after use

		.. code-block:: c

                        free(sp);

		* See the full program below

		.. code-block:: c

                        #include <stdio.h>
                        #include <stdlib.h>

			void fun(int x)
			{
			        x = 100;

			        printf("x = %d\n", x);
			}

			int main(void)
			{
                                int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;

                                printf("----- Before call by value -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

			        fun( *(sp + 2) );

                                printf("----- After call by value -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by value -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

                        x = 100

                        ----- After call by value -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

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

			Changing value of ``x`` inside function ``fun`` DOES NOT change ``*(sp + 2)``

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

			Remember ``sp[2]`` and ``*(sp + 2)`` are one and the same

.. _funcs_n_ptrs_int_sp_examples_call_by_reference:

.. tab-set::

        .. tab-item:: Examples of Call by Reference

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

                        Let us look at examples of Call by Reference

.. _funcs_n_ptrs_int_sp_ex_9:

.. tab-set::

        .. tab-item:: Example 3 : Call by Reference WITH &sp[ ]

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

			Example for Call By Reference with ``&sp[ ]``

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass address of an individual integer ``&sp[2]`` to a function. Call by Reference

		.. code-block:: c

		        fun( &sp[2] );

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

			Address of individual heap elements can be accessed using ``&``

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

			In this case ``&sp[2]`` is the address of third integer in the heap

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

			Since we are passing address of third integer to function ``fun``, it is called call by reference with respect to third integer


		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun(int *x)
			{

			}

		* Step 6 : Change value of ``*x`` inside function ``fun``

		.. code-block:: c

			void fun(int *x)
			{
			        *x = 100;

			        printf("*x = %d\n", *x);
			}

                * Step 7 : Free heap memory after use
		
                .. code-block:: c

                        free(sp);

		* See the full program below

		.. code-block:: c

                        #include <stdio.h>
                        #include <stdlib.h>

			void fun(int *x)
			{
			        *x = 100;

			        printf("*x = %d\n", *x);
			}

			int main(void)
			{
                                int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;

                                printf("----- Before call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }
                                
			        fun( &sp[2] );

                                printf("----- After call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55
                        *x = 100

                        ----- After call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 100
                        sp[3] = 44
                        sp[4] = 55

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

			Changing value of ``*x`` inside function ``fun`` CHANGES ``sp[2]`` in  ``sp``

.. _funcs_n_ptrs_int_sp_ex_10:

.. tab-set::

        .. tab-item:: Example 4 : Call by Reference WITH ``(sp + x)``

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

			Example for Call By Reference with ``(sp + x)``

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass address of individual integer ``sp + 2`` to a function. Call by Reference

		.. code-block:: c

		        fun( sp + 2 );

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

			In this case ``sp + 2`` is the address of third integer in the heap

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

			Since we are passing address of third integer to function ``fun``, it is called call by reference with respect to third integer


		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun(int *x)
			{

			}

		* Step 6 : Change value of ``*x`` inside function ``fun``

		.. code-block:: c

			void fun(int *x)
			{
			        *x = 100;

			        printf("*x = %d\n", *x);
			}

                * Step 7 : Free heap memory after use

		.. code-block:: c

                        free(sp);

		* See the full program below

		.. code-block:: c

			#include <stdio.h>
                        #include <stdlib.h>

			void fun(int *x)
			{
			        *x = 100;

			        printf("*x = %d\n", *x);
			}

			int main(void)
			{
                                int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;

                                printf("----- Before call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

			        fun( sp + 2 );

                                printf("----- After call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

                        *x = 100

                        ----- After call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 100
                        sp[3] = 44
                        sp[4] = 55

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

			Changing value of ``*x`` inside function ``fun`` CHANGES ``sp[2]``

.. _funcs_n_ptrs_int_sp_ex_12:

.. tab-set::

        .. tab-item:: Example 5 : Pass full array to a function

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass full array array to a function

		.. code-block:: c

			fun( sp );

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

			Note that we are passing starting address of array

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

			Hence function ``fun`` has read and write access to all Bytes of array

		* Step 5 : Define a function

		.. code-block:: c

			void fun(int *x)
			{
                                x[0] = 111;
                                x[1] = 222;
                                x[2] = 333;
                                x[3] = 444;
                                x[4] = 555;
			}

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

			function ``fun`` has access to all integers

                * Step 6 : Free heap memory after use                        

		.. code-block:: c

                        free(sp);
                        
		* See full program below

		.. code-block:: c

                        #include <stdio.h>
                        #include <stdlib.h>

			void fun(int *x)
			{
                                x[0] = 111;
                                x[1] = 222;
                                x[2] = 333;
                                x[3] = 444;
                                x[4] = 555;
			}

			int main(void)
			{
                                int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;

                                printf("----- Before call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

			        fun(sp);

                                printf("----- After call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

                        ----- After call by reference -----
                        sp[0] = 111
                        sp[1] = 222
                        sp[2] = 333
                        sp[3] = 444
                        sp[4] = 555

.. _funcs_n_ptrs_int_sp_ex_13:

.. tab-set::

        .. tab-item:: Example 6 : Pass part of the array by reference

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass full array by reference with relative addressing

		.. code-block:: c

			fun( sp + 2 );

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

			Note that we are passing part of the array by reference

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

			In this case, we are passing address of 3rd integer

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

			Hence function ``fun`` has read and write access to Integers at indexes 2,3,4 in forward direction

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

			Hence function ``fun`` has read and write access to Integers 0, 1 in backward direction

		* Step 5 : Define a function

		.. code-block:: c

			void fun(int *x)
			{
			        x[-2] = 111; // Same as sp[0]
			        x[-1] = 222; // Same as sp[1]
			        x[0]  = 333; // Same as sp[2]
			        x[1]  = 444; // Same as sp[3]
			        x[2]  = 555; // Same as sp[4]
			}

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

			Note the relative access mechanism used inside function ``fun``

		* See full program below

		.. code-block:: c

                        #include <stdio.h>
                        #include <stdlib.h>
             
			void fun(int *x)
			{
			        x[-2] = 111; // Same as sp[0]
			        x[-1] = 222; // Same as sp[1]
			        x[0]  = 333; // Same as sp[2]
			        x[1]  = 444; // Same as sp[3]
			        x[2]  = 555; // Same as sp[4]
			}

			int main(void)
			{
                                int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;                                

                                printf("----- Before call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

			        fun(sp + 2);

                                printf("----- After call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

                        ----- After call by reference -----
                        sp[0] = 111
                        sp[1] = 222
                        sp[2] = 333
                        sp[3] = 444
                        sp[4] = 555

.. _funcs_n_ptrs_int_sp_ex_14:

.. tab-set::

        .. tab-item:: Example 7 : Pass address of integer single pointer to a function

		* Step 1 : Define a integer single pointer ``sp``

		.. code-block:: c

		        int *sp;

                * Step 2 : Allocate heap memory of Bytes

		.. code-block:: c

                        sp = malloc(5 * sizeof(int));

                * Step 3 : Copy string to heap memory pointed to by ``sp``

		.. code-block:: c

                        sp[0] = 11;
                        sp[1] = 22;
                        sp[2] = 33;
                        sp[3] = 44;
                        sp[4] = 55;

		* Step 4 : Pass the address of array ``sp`` to function ``fun``

		.. code-block:: c

		        fun(&sp);

		* Step 5 : Define the function ``fun``

		.. code-block:: c

			void fun( int **dp)
			{       

			}

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

			Note that ``int **dp`` is a pointer to a integer single pointer


		* Step 6 : Access individual integers inside function ``fun``

		.. code-block:: c

			void fun( int **dp )
			{       
			        //Change individual integers
			        (*dp)[0] = 111;
			        (*dp)[1] = 222;
			        (*dp)[2] = 333;
			        (*dp)[3] = 444;
			        (*dp)[4] = 555;
			}

                * Step 8 : Free heap memory after use                        

		.. code-block:: c

                        free(sp);

		* See the full program below

		.. code-block:: c

                        #include <stdio.h>
                        #include <stdlib.h>

			void fun( int **dp )
			{       
			        //Change individual integers
			        (*dp)[0] = 111;
			        (*dp)[1] = 222;
			        (*dp)[2] = 333;
			        (*dp)[3] = 444;
			        (*dp)[4] = 555;
			}

			int main(void)
			{
                                int *sp;

                                sp = malloc(5 * sizeof(int));

                                sp[0] = 11;
                                sp[1] = 22;
                                sp[2] = 33;
                                sp[3] = 44;
                                sp[4] = 55;                                

                                printf("----- Before call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

			        fun(&sp);

                                printf("----- After call by reference -----\n");

                                for (int i = 0; i < 5; i++)
                                {
                                        printf("sp[%d] = %d\n", i, sp[i]);
                                }

                                free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        ----- Before call by reference -----
                        sp[0] = 11
                        sp[1] = 22
                        sp[2] = 33
                        sp[3] = 44
                        sp[4] = 55

                        ----- After call by reference -----
                        sp[0] = 111
                        sp[1] = 222
                        sp[2] = 333
                        sp[3] = 444
                        sp[4] = 555

.. card:: See Also

	* Other topics of integer and functions

                * :doc:`./int`
                * :doc:`./int_sd_array`
                * :doc:`./int_dd_array`
                * :doc:`./int_td_array`
                * :doc:`./int_sp`
                * :doc:`./int_dp`
                * :doc:`./int_tp`

        * Current Module

                * :doc:`../funcs_n_ptrs`

        * Previous Module

                * :doc:`../../typecasting_n_ptr/typecasting_n_ptr`

        * Next Module

                * :doc:`../../memcpy_ptr/memcpy_ptr`

        * Other Modules

                * :doc:`../../variable_and_ptr/variable_and_ptr`
                * :doc:`../../array_n_ptrs/array_n_ptrs`
                * :doc:`../../malloc_ptr/malloc_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`