Pointer to a Double 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 Double 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_dp_ex_1>`
		* :ref:`Pointer to an array increments by size of the array <ptr_to_array_int_dp_ex_2>`
		* :ref:`Pointer to an array : Passed as function arguement : Call by Value <ptr_to_array_int_dp_ex_3>`
		* :ref:`Pointer to an array : Passed as function arguement : Call by Reference <ptr_to_array_int_dp_ex_8>`
        	* :ref:`Pointer to an array : Pointing to Double dimension array inside a Double dimension array <ptr_to_array_int_dp_ex_6>`

.. _ptr_to_array_int_dp_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 ) [ row_size ] [ col_size ];

		An example is as below

		.. code-block:: c

			int a[2][4] = { {1, 2, 3, 4}, {10, 20, 30, 40} };

			int (*ptr)[2][4];

			ptr = &a;

.. _ptr_to_array_int_dp_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 double dimension array

		.. code-block:: c

			int a[2][4] = { {1, 2, 3, 4}, {10, 20, 30, 40} };

		* Step 2 : Define a pointer to an array

		.. code-block:: c

			int (*ptr)[2][4];

		* Step 3 : Let pointer to an array, point to double 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[2][4] = { {1, 2, 3, 4}, {10, 20, 30, 40} };

				int (*ptr)[2][4];

				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 = 7ffcac29b980
			After  Increment : ptr = 7ffcac29b9a0

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

			Observe that difference is 32 !

				* Size of two dimensional array is 32 Bytes

				* Hence incrementing ``ptr`` will increment by 32 Bytes
		
.. _ptr_to_array_int_dp_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 double dimension array

		.. code-block:: c

			int a[2][4] = {
					{1, 2, 3, 4},
					{10, 20, 30, 40}
				};

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        int (*ptr)[2][4];

		* Step 3 : Let pointer to an array, point to double 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)[2][4] )
			{
			}

		* Step 6 : Print individual integers inside ``fun``

		.. code-block:: c

			void fun( int (*p)[2][4] )
			{
				//print Individual integers
				printf("Print integers using %%d\n");
				for (int i = 0; i < 2; i++)
				{
					for (int j = 0; j < 4; 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 inside ``main``

			.. code-block:: c

				ptr = &a

			* Rule 2 : Base Rule inside ``fun``
			
			.. code-block:: c

				p = ptr

			* Rule 3 : From Rule 1 and Rule 2
				
			.. code-block:: c

				p = &a

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

			.. code-block:: c

				*p = a;

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

			.. code-block:: c

				*p = &a[0]

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

			.. code-block:: c

				**p = a[0]

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

			.. code-block:: c

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

			* Rule 8 : Extending Rule 7

			.. code-block:: c

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

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

			.. code-block:: c

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

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

			.. code-block:: c

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

			* Rule 11 : * and [ ] can be used interchangeably

			.. code-block:: c

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

			* Rule 12 : Extending Rule 11

			.. code-block:: c

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

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

			Hence we proved, if ``a[i][j]`` is an integer then ``(*p)[i][j]`` is also an integer

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

			Another way to understand !

			* ``int (*p)[2][4]`` is the declaration of pointer ``p``

			* ``(*p)[ ][ ]`` is dereferenced to maximum level. Hence is an integer

		* Step 7 : Print individual integers inside ``fun``

		.. code-block:: c

			void fun( int (*p)[2][4] )
			{
				//print Individual integers
				printf("Print integers using %%d\n");
				for (int i = 0; i < 2; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						printf("%d ", (*p)[i][j]);
					}
					printf("\n");
				}
			}

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun( int (*p)[2][4] )
			{
				//print Individual integers
				printf("Print integers using %%d\n");
				for (int i = 0; i < 2; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						printf("%d ", (*p)[i][j]);
					}
					printf("\n");
				}
			}

			int main(void)
			{
				int a[2][4] = {
					{1, 2, 3, 4},
					{10, 20, 30, 40}
				};

			        int (*ptr)[2][4];

			        ptr = &a;

			        fun(ptr);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			Print integers using %d
			1 2 3 4
			10 20 30 40

.. _ptr_to_array_int_dp_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[2][4] = {
				{1, 2, 3, 4},
				{10, 20, 30, 40}
			};

		* Step 2 : Define a pointer to an array

		.. code-block:: c

			int (*ptr)[2][4];

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

		.. code-block:: c

		        ptr = &a;

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

		.. code-block:: c

		        fun(&ptr);

		* Step 5 : Define function ``fun`` and print individual integers

		.. code-block:: c

			void fun(int (**p)[2][4])
			{
			        // Print individual integers
			        printf("Print integers using %%d\n");
			        for (int i = 0; i < 2; i++) {
			                for (int j = 0; j < 4; 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;

			* 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

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

			.. code-block:: c

				**p = a

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

			.. code-block:: c

				(*p)[0] = a

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

			.. code-block:: c

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

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

			.. code-block:: c

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

			* Rule 8 : Extending Rule 7

			.. code-block:: c

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

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

			.. code-block:: c

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

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

			.. code-block:: c

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

			* Rule 11 : * and [ ] can be used interchangeably

			.. code-block:: c

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

			* Rule 12 : Extending Rule 11

			.. code-block:: c

				(**p)[i][j] = a[i][j]
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Hence we proved if ``a[i][j]`` is a integer then ``(**p)[i][j]`` is also a integer

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun(int (**p)[2][4])
			{
			        // Print individual integers
			        printf("Print integers using %%d\n");
			        for (int i = 0; i < 2; i++) {
			                for (int j = 0; j < 4; j++) {
			                        printf("%d ", (**p)[i][j]);
			                }
			                printf("\n");
			        }
			}

			int main(void)
			{
			        int a[2][4] = {
			                {1, 2, 3, 4},
			                {10, 20, 30, 40}
			        };

			        int (*ptr)[2][4];

			        ptr = &a;

			        fun(&ptr);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			Print integers using %d
			1 2 3 4
			10 20 30 40

.. _ptr_to_array_int_dp_ex_6:

.. tab-set::

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

		* Step 1 : Define a triple dimension array of integers

		.. code-block:: c

			int a[2][3][4] = {
				{
					{1, 2, 3, 4},
					{5, 6, 7, 8},
					{9, 10, 11, 12}
				},
				{
					{10, 20, 30, 40},
					{50, 60, 70, 80},
					{90, 100, 110, 120}
				},
			};

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

		.. code-block:: c

			  int (*ptr)[3][4];

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

		.. code-block:: c

			ptr = &a[0];

		* Step 4 : Print the individual integers : Method 1

		.. code-block:: c

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

		* Step 5 : Print the individual integers : Method 2

		.. code-block:: c

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

		.. 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][0] = a[0][0]

			* Rule 6 : Extending Rule 3

			.. code-block:: c

				ptr[i][j] = a[i][j]

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

			.. code-block:: c

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

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

			.. code-block:: c

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

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

			.. code-block:: c

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

			* Rule 10 : Extending Rule 9

			.. code-block:: c

				ptr[i][j][k] = a[i][j][k]

		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow
			
			Hence we proved, if ``a[i][j][k]`` is an integer then ``p[i][j][k]`` is also also an integer

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
				int a[2][3][4] = {
					{
						{1, 2, 3, 4},
						{5, 6, 7, 8},
						{9, 10, 11, 12}
					},
					{
						{10, 20, 30, 40},
						{50, 60, 70, 80},
						{90, 100, 110, 120}
					},
				};

				int (*ptr)[3][4];

				ptr = &a[0];

				//Method 1 : print Integers
				for (int i = 0; i < 2; i++) {
					for (int j = 0; j < 3; j++) {
						for (int k = 0; k < 4; k++) {
							printf("ptr[%d][%d][%d] = %d\n", i, j, k, ptr[i][j][k]);
						}
					}
				}

				printf("\n");

				//Method 2 : print Integers
				for (int i = 0; i < 2; i++) {
					for (int j = 0; j < 3; j++) {
						for (int k = 0; k < 4; k++) {
							printf("(*ptr)[%d][%d] = %d\n", j, k, (*ptr)[j][k]);
						}
					}
					ptr++;
				}

				return 0;
			}

		* Output is as below

		.. code-block:: c

			ptr[0][0][0] = 1
			ptr[0][0][1] = 2
			ptr[0][0][2] = 3
			ptr[0][0][3] = 4
			ptr[0][1][0] = 5
			ptr[0][1][1] = 6
			ptr[0][1][2] = 7
			ptr[0][1][3] = 8
			ptr[0][2][0] = 9
			ptr[0][2][1] = 10
			ptr[0][2][2] = 11
			ptr[0][2][3] = 12
			ptr[1][0][0] = 10
			ptr[1][0][1] = 20
			ptr[1][0][2] = 30
			ptr[1][0][3] = 40
			ptr[1][1][0] = 50
			ptr[1][1][1] = 60
			ptr[1][1][2] = 70
			ptr[1][1][3] = 80
			ptr[1][2][0] = 90
			ptr[1][2][1] = 100
			ptr[1][2][2] = 110
			ptr[1][2][3] = 120

			(*ptr)[0][0] = 1
			(*ptr)[0][1] = 2
			(*ptr)[0][2] = 3
			(*ptr)[0][3] = 4
			(*ptr)[1][0] = 5
			(*ptr)[1][1] = 6
			(*ptr)[1][2] = 7
			(*ptr)[1][3] = 8
			(*ptr)[2][0] = 9
			(*ptr)[2][1] = 10
			(*ptr)[2][2] = 11
			(*ptr)[2][3] = 12
			(*ptr)[0][0] = 10
			(*ptr)[0][1] = 20
			(*ptr)[0][2] = 30
			(*ptr)[0][3] = 40
			(*ptr)[1][0] = 50
			(*ptr)[1][1] = 60
			(*ptr)[1][2] = 70
			(*ptr)[1][3] = 80
			(*ptr)[2][0] = 90
			(*ptr)[2][1] = 100
			(*ptr)[2][2] = 110
			(*ptr)[2][3] = 120

.. 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`