Pointer to a Single Dimension Array of Integers
==================================================

In this section, you are going to learn

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

		How to define and use Pointer to Single Dimension Arrays ?

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

		Pointer to an Array

		* :ref:`Syntax of Pointer to an array <ptr_to_array_int_sp_ex_1>`
		* :ref:`Pointer to an array increments by size of the array <ptr_to_array_int_sp_ex_2>`
		* :ref:`Pointer to an array : Passed as function arguement : Call by Value <ptr_to_array_int_sp_ex_3>`
		* :ref:`Pointer to an array : Passed as function arguement : Call by Reference <ptr_to_array_int_sp_ex_8>`
		* :ref:`Method 1 : Pointer to an array : How to print contents of single dimension array ? <ptr_to_array_int_sp_ex_4>`
		* :ref:`Method 2 : Pointer to an array : How to print contents of single dimension array ? <ptr_to_array_int_sp_ex_5>`
        	* :ref:`Pointer to an array : Pointing to Single dimension array inside a Double dimension array <ptr_to_array_int_sp_ex_6>`
		* :ref:`Pointer to an array : Pointing to a block of memory in heap <ptr_to_array_int_sp_ex_7>`

.. _ptr_to_array_int_sp_ex_1:

.. tab-set::

        .. tab-item:: Syntax of Pointer to an array

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

			type ( \*ptr ) [ size_of_array ];

		An example is as below

		.. code-block:: c

		        int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		        int (*ptr)[10];

		        ptr = &a;


.. _ptr_to_array_int_sp_ex_2:


.. tab-set::

        .. tab-item:: Pointer to an array increments by size of the array

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

			Pointer to an Array when incremented, increments by size of the array to which it is pointing to !

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

			Pointer to an Array when decremented, decrements by size of the array to which it is pointing to !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        int (*ptr)[10];

		* Step 3 : Let pointer to an array, point to single dimension array

		.. code-block:: c

		        ptr = &a;

		* Step 4 : Check pointer arithmetic

		.. code-block:: c

		        printf("Before Increment : ptr = %lx\n", (unsigned long int) ptr);

		        ptr++;

		        printf("After Increment : ptr = %lx\n", (unsigned long int) ptr);

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
		        	int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

			        int (*ptr)[10];

			        ptr = &a;

			        printf("Before Increment : ptr = %lx\n", (unsigned long int) ptr);

			        ptr++;

			        printf("After Increment : ptr = %lx\n", (unsigned long int) ptr);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			Before Increment : ptr = 7ffc4ed5b130
			After Increment  : ptr = 7ffc4ed5b158

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

			Observe that difference is 40 !

				* Which is equal to 10 Integers

		
.. _ptr_to_array_int_sp_ex_3:


.. tab-set::

        .. tab-item:: Pointer to an array : Passed as function arguement : Call by Value

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

			When Pointer to an Array is passed as argument, Prototype of function should match the type properly !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

	        	int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        int (*ptr)[10];

		* Step 3 : Let pointer to an array, point to single dimension array

		.. code-block:: c

		        ptr = &a;

		* Step 4 : Pass ``ptr`` as argument to function ``fun``

		.. code-block:: c

		        fun(ptr);

		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun( int (*p)[10] )
			{
			}

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun( int (*p)[10] )
			{
			}

			int main(void)
			{
	        		int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

			        int (*ptr)[10];

			        ptr = &a;

			        fun(ptr);

			        return 0;
			}


.. _ptr_to_array_int_sp_ex_8:

.. tab-set::

        .. tab-item:: Pointer to an array : Passed as function arguement : Call by Reference

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

                        When Pointer to an Array is passed as argument by call by reference, Prototype of function should match the type properly !

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

                        Let us see how it is done. See below

                * Step 1 : Define a Double dimension array

                .. code-block:: c

			int a[3][5] = {
		                {1, 2, 3, 4, 5},
		                {10, 20, 30, 40, 50},
		                {100, 200, 300, 400, 500}
		              };

                * Step 2 : Define a pointer to an array

                .. code-block:: c

                        int (*ptr)[5];

                * Step 3 : Let pointer to an array, point to single dimension array

                .. code-block:: c

                        ptr = &a[0];

                * Step 4 : Pass ``ptr`` as argument to function ``fun``. Call by reference

                .. code-block:: c

                        fun(&ptr);

                * Step 5 : Define function ``fun``

                .. code-block:: c

			void fun(int (**p)[5])
			{
			        for (int i = 0; i < 3; i++) {
			                for (int j = 0; j < 5; j++) {
			                        printf("%d ", (*p)[i][j]);
			                }
			                printf("\n");
			        }
			}

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

                        This is easy to understand ! Let us derive the rules

                        * Rule 1 : Base rule in ``main``

                        .. code-block:: c

                                ptr = &a[0];

                        * Rule 2 : Base rule in ``fun``

                        .. code-block:: c

                                p = &ptr

                        * Rule 2 : Move & from RHS to LHS. This becomes * on LHS

                        .. code-block:: c

                                *p = ptr

                        * Rule 3 : Replace ``ptr`` referring to Rule 1 

                        .. code-block:: c

                                *p = &a[0]

                        * Rule 4 : Move & from RHS to LHS. This becomes * on LHS

                        .. code-block:: c

                                **p = a[0]

                        * Rule 5 : ``*`` and ``[ ]`` can be used interchangeably

                        .. code-block:: c

                                (*p)[0] = a[0]

                        * Rule 6 : ``*`` and ``[ ]`` can be used interchangeably

                        .. code-block:: c

                                p[0][0] = a[0]

                        * Rule 7 : ``*`` and ``[ ]`` can be used interchangeably

                        .. code-block:: c

                                p[0][0] = &a[0][0]

                        * Rule 8 : Move & from RHS to LHS. This becomes * on LHS

                        .. code-block:: c

                                (*p)[0][0] = a[0][0]

			* Rule 9 : Extending Rule 8

                        .. code-block:: c

                                (*p)[i][j] = a[i][j]

                * See full program below

                .. code-block:: c

			#include <stdio.h>

			void fun(int (**p)[5])
			{
			        for (int i = 0; i < 3; i++) {
			                for (int j = 0; j < 5; j++) {
			                        printf("%d ", (*p)[i][j]);
			                }
			                printf("\n");
			        }
			}

			int main(void)
			{
			        int a[3][5] = {
			                {1, 2, 3, 4, 5},
			                {10, 20, 30, 40, 50},
			                {100, 200, 300, 400, 500}
			        };

			        int (*ptr)[5];

			        ptr = &a[0];

			        fun(&ptr);

			        return 0;
			}

                * Output is as below

                .. code-block:: c

			1 2 3 4 5
			10 20 30 40 50
			100 200 300 400 500


.. _ptr_to_array_int_sp_ex_4:


.. tab-set::

        .. tab-item:: Method 1 : Pointer to an array : How to print contents of single dimension array ? 

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

			We can use pointer to an array directly inorder to print the contents of array to which it is pointing to !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

        		int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        int (*ptr)[10];

		* Step 3 : Let pointer to an array, point to single dimension array

		.. code-block:: c

		        ptr = &a;

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

			We can derive other rules from this base rule !

			* Rule 1 : Base rule
			
			.. code-block:: c
		        
				ptr = &a;

			* Rule 2 : Move ``&`` from RHS to LHS. This becomes ``*`` on LHS

			.. code-block:: c

				*ptr = a

			* Rule 3 : ``a`` is also equals to ``&a[0]``

			.. code-block:: c

				*ptr = &a[0]

			* Rule 4 : ``*ptr`` is equal to ``ptr[0]``

			.. code-block:: c

				ptr[0] = &a[0]

			* Rule 5 : Move ``&`` from RHS to LHS. This becomes ``*`` on LHS

			.. code-block:: c

				(*ptr)[0] = a[0]

			* Rule 6 : ``(*ptr)[0]`` is equal to ``ptr[0][0]``

			.. code-block:: c

				ptr[0][0] = a[0]

			* Rule 7 : Extending Rule 5

			.. code-block:: c

				(*ptr)[i] = a[i]

		* Step 4 : Access individual integers using ``(*ptr)[i]``

		.. code-block:: c

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

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
        			int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

			        int (*ptr)[10];

			        ptr = &a;

			        // Print individual integers
			        for (int i = 0; i < 10; i++) {
			                printf("%d\n", (*ptr)[i]);
        			}

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			0
			1
			2
			3
			4
			5
			6
			7
			8
			9

.. _ptr_to_array_int_sp_ex_5:

.. tab-set::

        .. tab-item:: Method 2 : Pointer to an array : How to print contents of single dimension array ? 

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

			We can use pointer to an array directly inorder to print the contents of array to which it is pointing to !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

       			int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		* Step 2 : Pass address of array ``a`` as an argument to function ``fun``

		.. code-block:: c

		        fun(&a, sizeof(a));

		* Step 3 : Define function ``fun`` 

		.. code-block:: c

			void fun(int (*p)[10], int size)
			{

			}

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

			Note the function definition !

			* Since first argument is passed as address of array ``a``, prototype must have pointer to an array in first parameter

		* Step 4 : Let us write the code to access individual integers of single dimension array inside function ``fun``

		.. code-block:: c

			void fun(int (*p)[10], int size)
			{
			        for (int i = 0; i < size; i++) {
			                printf("%d\n", (*p)[i]);
			        }

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

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

			This is easy to understand ! Let us derive the rules

			* Rule 1 : Base rule

			.. code-block:: c

				p = &a

			Where,

				* LHS ``p`` is a variable on stack of function fun ``fun``
				* RHS ``&a`` is actual argument passed to function ``fun``

			* Rule 2 : Move ``&`` from RHS to LHS. This becomes ``*`` on LHS

			.. code-block:: c

				*p = a

			* Rule 3 : a is also equals to &a[0]

			.. code-block:: c

				*p = &a[0]

			* Rule 4 : Move ``&`` from RHS to LHS. This becomes ``*`` on LHS

			.. code-block:: c

				**p = a[0]

			* Rule 5 : ``*`` and ``[ ]`` can be used interchangeably

			.. code-block:: c

				(*p)[0] = a[0]

			* Rule 6 : ``*`` and ``[ ]`` can be used interchangeably

			.. code-block:: c

				p[0][0] = a[0]

			* Rule 7 : Extending Rule 5

			.. code-block:: c

				(*p)[i] = a[i]

			* Rule 8 : Extending Rule 5

			.. code-block:: c

				p[0][i] = a[i]

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun(int (*p)[10], int size)
			{
			        int *sp;

			        sp = *p;

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

				printf("\n");

			        for (int i = 0; i < size; i++) {
			                printf("%d ", (*p)[i]);
			        }

				printf("\n");

			        for (int i = 0; i < size; i++) {
			                printf("%d ", p[0][i]);
			        }

				printf("\n");
			}

			int main(void)
			{
				int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

			        fun(&a, sizeof(a) / sizeof(a[0]) );

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			0 1 2 3 4 5 6 7 8 9 
			0 1 2 3 4 5 6 7 8 9 
			0 1 2 3 4 5 6 7 8 9 

.. _ptr_to_array_int_sp_ex_6:

.. tab-set::

        .. tab-item:: Pointer to an array : Pointing to Single dimension array inside a Double dimension array

		* Step 1 : Define a double dimension array of integers

		.. code-block:: c

			int a[3][5] = { 
					{1, 2, 3, 4, 5},
					{10, 20, 30, 40, 50},
					{100, 200, 300, 400, 500}
				      };

		* Step 2 : Define a pointer to an array of single dimension

		.. code-block:: c

			int (*ptr)[5];

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

			Here everytime ``ptr`` increments, it increments by 5 Integers (equal to 20 Bytes) !

		* Step 3 : Let the pointer to point to Single dimension array inside a Double dimension array

		.. code-block:: c

			ptr = &a[0];

		* Step 4 : Access individual integers using ``ptr``

		.. code-block:: c

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

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

			This is easy to understand ! Let us derive the rules

			* Rule 1 : Base rule

			.. code-block:: c

				ptr = &a[0];

			* Rule 2 : Move & from RHS to LHS. This becomes * on LHS

			.. code-block:: c

				*ptr = a[0];

			* Rule 3 : ``a[0]`` is equal to ``&a[0][0]``

			.. code-block:: c

				*ptr = &a[0][0];

			* Rule 4 : Move & from RHS to LHS. This becomes * on LHS

			.. code-block:: c

				**ptr = a[0][0];

			* Rule 5 : ``*`` and ``[ ]`` can be used interchangeably

			.. code-block:: c

				*ptr[0] = a[0][0]

			* Rule 6 : ``*`` and ``[ ]`` can be used interchangeably

			.. code-block:: c

				ptr[0][0] = a[0][0]

			* Rule 7 : Extending Rule 6

			.. code-block:: c

				ptr[i][j] = a[i][j]
			
		* See full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
			        int a[3][5] = { 
				                {1, 2, 3, 4, 5}, 
			        	        {10, 20, 30, 40, 50},
				                {100, 200, 300, 400, 500}
				             };

			        int (*ptr)[5];

			        ptr = &a[0];

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

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			1 2 3 4 5 
			10 20 30 40 50 
			100 200 300 400 500 

.. _ptr_to_array_int_sp_ex_7:

.. tab-set::

        .. tab-item:: Pointer to an array : Pointing to a block of memory in heap

		* Step 1 : Allocate a block of memory in Heap

		.. code-block:: c

			int *a;

		        a = malloc(15 * sizeof(int));

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

			Allocates 15 Integers (60 Bytes of memory in Heap)

		* Step 2 : Assign User Data in Heap memory

		.. code-block:: c

		        int arr0[] = {1, 2, 3, 4, 5};
		        int arr1[] = {10, 20, 30, 40, 50};
		        int arr2[] = {100, 200, 300, 400, 500};

		        memset(a, 0, 60);
		        memcpy(a, arr0, 5 * sizeof(int) );
		        memcpy(a + 5, arr1, 5 * sizeof(int) );
		        memcpy(a + 10, arr2, 5 * sizeof(int) );

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

			We have split the Heap into 3 blocks, with each block containing 5 Integers

		* Step 3 : Let ``ptr`` point to block of memory in Heap

		.. code-block:: c

		        ptr = (int (*)[5])a;

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

			Note the typecasting done !

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

			Key is to remember that, ``ptr`` should point to block of continuous memory for it to access User data properly !

		* Step 4 : Access the memory block in Heap using ``ptr``

		.. code-block:: c

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

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

			Everytime ``ptr`` is indexed with ``i`` it points to block of 5 Integers

			* ``ptr[0]`` points to ``Byte 0`` in Heap
			* ``ptr[1]`` points to ``Byte 20`` in Heap
			* ``ptr[2]`` points to ``Byte 40`` in Heap

		* Step 6 : Free Heap memory after use

		.. code-block:: c

		        free(a);

		* See full program below

		.. code-block:: c

			#include <string.h>
			#include <stdlib.h>

			int main(void)
			{
			        int *a;
			        int arr0[] = {1, 2, 3, 4, 5};
			        int arr1[] = {10, 20, 30, 40, 50};
			        int arr2[] = {100, 200, 300, 400, 500};

			        int (*ptr)[5];

			        a = malloc(15 * sizeof(int));

			        memset(a, 0, 60);

			        memcpy(a, arr0, 5 * sizeof(int) );
			        memcpy(a + 5, arr1, 5 * sizeof(int) );
			        memcpy(a + 10, arr2, 5 * sizeof(int) );

			        ptr = (int (*)[5])a;

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

			        free(a);

			        return 0;
			}

.. card:: See Also

        * Current Module

                * :doc:`../ptr_to_array`

        * Previous Module

                * :doc:`../../array_of_ptr/array_of_ptr`

        * Next Module

                * :doc:`../../function_ptr/function_ptr`

        * Other Modules

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