Array of char Double Pointers
==============================

In this section, you are going to learn

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

                How to use Double Pointers ?

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

                How to use Array of Double Pointers ?

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

		* :ref:`Basics of Array of Double Pointers <array_of_ptr_char_dp_mt_2>`
		* :ref:`Functions and Array of Double Pointers <array_of_ptr_char_dp_mt_3>`

.. _array_of_ptr_char_dp_mt_2:

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

		Basics of Array of Double Pointers

		* :ref:`Example 1 : Array of character double pointers : Pointers pointing to variables <array_of_ptr_char_dp_ex20>`
		* :ref:`Example 2 : Array of character double pointers : Pointers pointing to strings of double dimension arrays <array_of_ptr_char_dp_ex21>`
		* :ref:`Example 3 : Array of character double pointers : Pointers pointing to Heap : Method 1 <array_of_ptr_char_dp_ex22>`
		* :ref:`Example 4 : Array of character double pointers : Pointers pointing to Heap : Method 2 <array_of_ptr_char_dp_ex23>`
		* :ref:`Example 5 : Array of character double pointers : Pointers pointing to Heap : Method 3 <array_of_ptr_char_dp_ex24>`

.. _array_of_ptr_char_dp_ex20:

.. tab-set::

        .. tab-item:: Example 1 : Array of character double pointers : Pointers pointing to variables

		* Step 1 : Create 3 characters

		.. code-block:: c

			char c0 = 65, c1 = 66, c2 = 67;
	
		OR

		.. code-block:: c

			char c0, c1, c2;

		        c0 = 65; 
		        c1 = 66; 
		        c2 = 67; 

		* Step 2 : Create 3 Single Pointers pointing to 3 Characters

		.. code-block:: c

			char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;

		OR

		.. code-block:: c

		        char *sp0, *sp1, *sp2;

		        sp0 = &c0;
		        sp1 = &c1;
		        sp2 = &c2;

		* Step 3 : Create 3 Double pointers pointing to 3 Single pointers

		.. code-block:: c

			char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

		OR

		.. code-block:: c

		        char **dp0, **dp1, **dp2;

		        dp0 = &sp0;
		        dp1 = &sp1;
		        dp2 = &sp2;

		* Step 4 : Define array of double pointers

		.. code-block:: c

			char **ptr[] = { dp0, dp1, dp2 };

		OR

		.. code-block:: c

		        char **ptr[3];

		        ptr[0] = dp0;
		        ptr[1] = dp1;
		        ptr[2] = dp2;

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

			There are 3 double pointers in this example. dp0, dp1, dp2

		* See the full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
				char c0 = 65, c1 = 66, c2 = 67;
				char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;
				char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

				char **ptr[] = { dp0, dp1, dp2 };

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

			        return 0;
			}

		OR

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
				char c0 = 65, c1 = 66, c2 = 67;
				char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;

				char **ptr[] = { &sp0, &sp1, &sp2 };

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

			        return 0;
			}

.. _array_of_ptr_char_dp_ex21:

.. tab-set::

        .. tab-item:: Example 2 : Array of character double pointers : Pointers pointing to strings of double dimension arrays

		* Step 1 : Define a double dimension array

		.. code-block:: c

			char darr[][10] = {"Laptop", "Mouse", "Keyboard"};

		* Step 2 : Define 3 Single pointers

		.. code-block:: c

			char *sp0 = darr[0], *sp1 = darr[1], *sp2 = darr[2];

		OR

		.. code-block:: c

			char *sp0, *sp1, *sp2;

			sp0 = darr[0];
			sp1 = darr[1];
			sp2 = darr[2];

		OR

		.. code-block:: c

			char *sp0, *sp1, *sp2;

			sp0 = &darr[0][0];
			sp1 = &darr[1][0];
			sp2 = &darr[2][0];

		* Step 3 : Define array of double pointers

		.. code-block:: c

			char **ptr[3] = {&sp0, &sp1, &sp2};

		OR

		.. code-block:: c

			char **ptr[3];

			ptr[0] = &sp0;
			ptr[1] = &sp1;
			ptr[2] = &sp2;

		* Step 4 : Access strings using array of double pointers

		.. code-block:: c

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

		* See the full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
				char darr[][10] = {"Laptop", "Mouse", "Keyboard"};

				char *sp0 = darr[0], *sp1 = darr[1], *sp2 = darr[2];

				char **ptr[3] = {&sp0, &sp1, &sp2};

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

				return 0;
			}

.. _array_of_ptr_char_dp_ex22:

.. tab-set::

        .. tab-item:: Example 3 : Array of character double pointers : Pointers pointing to Heap : Method 1

		* Step 1 : Define 3 single pointers

		.. code-block:: c

			char *sp0, *sp1, *sp2;

		* Step 2 : Allocate Heap memory

		.. code-block:: c

			sp0 = malloc(10 * sizeof(char));
			sp1 = malloc(10 * sizeof(char));
			sp2 = malloc(10 * sizeof(char));

		* Step 3 : Copy user data (strings) to heap memory

		.. code-block:: c

			strcpy(sp0, "Laptop");
			strcpy(sp1, "Mouse");
			strcpy(sp2, "KeyBoard");

		* Step 4 : Define array of double pointers

		.. code-block:: c

			char **ptr[3] = {&sp0, &sp1, &sp2};

		* Step 5 : Use array of pointers to access strings

		.. code-block:: c

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

		* Step 6 : Free the heap memory after use

		.. code-block:: c

		        free(sp0);
		        free(sp1);
		        free(sp2);

		OR

		.. code-block:: c

		        for(int i = 0; i < 3; i++) {
		                free(*ptr[i]);
		        }   

		* See the full program below

		.. code-block:: c

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

			int main(void)
			{
			        char *sp0, *sp1, *sp2;

			        sp0 = malloc(10 * sizeof(char));
			        sp1 = malloc(10 * sizeof(char));
			        sp2 = malloc(10 * sizeof(char));

			        strcpy(sp0, "Laptop");
			        strcpy(sp1, "Mouse");
			        strcpy(sp2, "KeyBoard");

			        char **ptr[3] = {&sp0, &sp1, &sp2};


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

				/* Free after Use : Method 1*/
			        free(sp0);
			        free(sp1);
			        free(sp2);

				/* Free after Use : Method 2*/
				/*
			        for(int i = 0; i < 3; i++) {
			                free(*ptr[i]);
			        }
				*/ 

			        return 0;
			}

.. _array_of_ptr_char_dp_ex23:

.. tab-set::

        .. tab-item:: Example 4 : Array of character double pointers : Pointers pointing to Heap : Method 2

		* Step 1 : Define 3 double pointers

		.. code-block:: c

			char **dp0, **dp1, **dp2;

		* Step 2 : Allocate Heap memory twice per double pointer

		.. code-block:: c

			dp0 = malloc(sizeof(char *));
			*dp0 = malloc(10 * sizeof(char));

			dp1 = malloc(sizeof(char *));
			*dp1 = malloc(10 * sizeof(char));

			dp2 = malloc(sizeof(char *));
			*dp2 = malloc(10 * sizeof(char));

		* Step 3 :  Copy User data (strings) to heap

		.. code-block:: c

		        strcpy(*dp0, "Laptop");
		        strcpy(*dp1, "Mouse");
		        strcpy(*dp2, "Keyboard");

		* Step 4 : Define array of double pointers

		.. code-block:: c

		        char **ptr[3] = {dp0, dp1, dp2};

		* Step 5 : Access User data using array of pointers

		.. code-block:: c

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

		* Step 6 : Free after Use : Free \*dp0, \*dp1, \*dp2

		.. code-block:: c

			free(*dp0);
			free(*dp1);
			free(*dp2);

		OR

		.. code-block:: c

			for(int i = 0; i < 3; i++) {
				free(*ptr[i]);
			}

		* Step 7 : Free after Use : Free dp0, dp1, dp2

		.. code-block:: c

			free(dp0);
			free(dp1);
			free(dp2);

		OR

		.. code-block:: c

			for(int i = 0; i < 3; i++) {
				free(ptr[i]);
			}

		* See the full program below

		.. code-block:: c

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

			int main(void)
			{
			        char **dp0, **dp1, **dp2;

        			dp0 = malloc(sizeof(char *));
			        *dp0 = malloc(10 * sizeof(char));

			        dp1 = malloc(sizeof(char *));
			        *dp1 = malloc(10 * sizeof(char));

			        dp2 = malloc(sizeof(char *));
			        *dp2 = malloc(10 * sizeof(char));

			        strcpy(*dp0, "Laptop");
			        strcpy(*dp1, "Mouse");
			        strcpy(*dp2, "Keyboard");

			        char **ptr[3] = {dp0, dp1, dp2};

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

			        for(int i = 0; i < 3; i++) {
			                free(*ptr[i]);
			        }

			        for(int i = 0; i < 3; i++) {
			                free(ptr[i]);
			        }

			        return 0;
			}

.. _array_of_ptr_char_dp_ex24:

.. tab-set::

        .. tab-item:: Example 5 : Array of character double pointers : Pointers pointing to Heap : Method 3

		* Step 1 : Define array of double pointers

		.. code-block:: c

			char **ptr[3];

		* Step 2 : Allocate heap memory twice per double pointer

		.. code-block:: c

			ptr[0] = malloc(sizeof(char *));
			*ptr[0] = malloc(10 * sizeof(char));

			ptr[1] = malloc(sizeof(char *));
			*ptr[1] = malloc(10 * sizeof(char));

			ptr[2] = malloc(sizeof(char *));
			*ptr[2] = malloc(10 * sizeof(char));

		OR

		.. code-block:: c

			for (int i = 0; i < 3; i++) {
				ptr[i] = malloc(sizeof(char *));
				*ptr[i] = malloc(10 * sizeof(char));
			}

		* Step 3 : Copy User data (Strings) to heap using array of double pointers

		.. code-block:: c

			strcpy(*ptr[0], "Laptop");
			strcpy(*ptr[1], "Mouse");
			strcpy(*ptr[2], "Keyboard");

		* Step 4 : Read User data (Strings) from heap using array of double pointers

		.. code-block:: c

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

		* Step 5 : Free after use

		.. code-block:: c

			for(int i = 0; i < 3; i++) {
				free(*ptr[i]);
			}

			for(int i = 0; i < 3; i++) {
				free(ptr[i]);
			}

		* See the full program below

		.. code-block:: c

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

			int main(void)
			{
			        char **ptr[3];

			        ptr[0] = malloc(sizeof(char *));
			        *ptr[0] = malloc(10 * sizeof(char));

			        ptr[1] = malloc(sizeof(char *));
			        *ptr[1] = malloc(10 * sizeof(char));

			        ptr[2] = malloc(sizeof(char *));
			        *ptr[2] = malloc(10 * sizeof(char));

			        strcpy(*ptr[0], "Laptop");
			        strcpy(*ptr[1], "Mouse");
			        strcpy(*ptr[2], "Keyboard");

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

			        for(int i = 0; i < 3; i++) {
			                free(*ptr[i]);
			        }

			        for(int i = 0; i < 3; i++) {
			                free(ptr[i]);
			        }

			        return 0;
			}


.. _array_of_ptr_char_dp_mt_3:

* Now let us look at,

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

		Functions and Array of Double Pointers

		* :ref:`Example 6 : Array of Double Pointers : Pass by Value : Without typedef <array_of_ptr_char_dp_ex25>`
		* :ref:`Example 7 : Array of Double Pointers : Pass by Value : With typedef <array_of_ptr_char_dp_ex26>`
		* :ref:`Example 8 : Array of Double Pointers : Pass by Reference : Without typedef <array_of_ptr_char_dp_ex27>`
		* :ref:`Example 9 : Array of Double Pointers : Pass by Reference : With typedef <array_of_ptr_char_dp_ex28>`

.. _array_of_ptr_char_dp_ex25:

.. tab-set::

        .. tab-item:: Example 6 : Array of Double Pointers : Pass by Value : Without typedef

		* Step 1 : Define characters

		.. code-block:: c

			char c0 = 65, c1 = 66, c2 = 67; 

		* Step 2 : Define single pointers

		.. code-block:: c

			char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;

		* Step 3 : Define double pointers

		.. code-block:: c

			char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

		* Step 4 : Define Array of Double Pointers

		.. code-block:: c

			char **ptr[] = { dp0, dp1, dp2 };

		* Step 5 : Pass Array of Double Pointers by Value

		.. code-block:: c

			        fun_v(ptr);

		* Step 6 : Define function ``fun_v``

		.. code-block:: c

			void fun_v(char **ptr_v[])
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", **ptr_v[i]);
			        }
			}

		* See the full program below

		.. code-block:: c

			#include <stdio.h>

			void fun_v(char **ptr_v[])
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", **ptr_v[i]);
			        }
			}

			int main(void)
			{
			        char c0 = 65, c1 = 66, c2 = 67; 
			        char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;
			        char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

			        char **ptr[] = { dp0, dp1, dp2 };

			        fun_v(ptr);

			        return 0;
			}

.. _array_of_ptr_char_dp_ex26:

.. tab-set::

        .. tab-item:: Example 7 : Array of Double Pointers : Pass by Value : With typedef

		* Step 1 : Define characters

		.. code-block:: c

			char c0 = 65, c1 = 66, c2 = 67; 

		* Step 2 : Define single pointers

		.. code-block:: c

			char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;

		* Step 3 : Define double pointers

		.. code-block:: c

			char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

		* Step 4 : Define a new type using typedef

		.. code-block:: c

			typedef char **tptr[];

		* Step 5 : Define Array of Double Pointers

		.. code-block:: c

			tptr ptr = { dp0, dp1, dp2 };

		* Step 6 : Pass Array of Double Pointers by Value

		.. code-block:: c

			        fun_v(ptr);

		* Step 7 : Define function ``fun_v``

		.. code-block:: c

			void fun_v(tptr ptr_v)
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", **ptr_v[i]);
			        }
			}

		* See the full program below

		.. code-block:: c

			#include <stdio.h>

			typedef char **tptr[];

			void fun_v(tptr ptr_v)
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", **ptr_v[i]);
			        }
			}

			int main(void)
			{
			        char c0 = 65, c1 = 66, c2 = 67; 
			        char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;
			        char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

			        tptr ptr = { dp0, dp1, dp2 };

			        fun_v(ptr);

			        return 0;
			}

.. _array_of_ptr_char_dp_ex27:

.. tab-set::

        .. tab-item:: Example 8 : Array of Double Pointers : Pass by Reference : Without typedef

		* Step 1 : Define characters

		.. code-block:: c

			char c0 = 65, c1 = 66, c2 = 67; 

		* Step 2 : Define single pointers

		.. code-block:: c

			char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;

		* Step 3 : Define double pointers

		.. code-block:: c

			char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

		* Step 5 : Define Array of Double Pointers

		.. code-block:: c

		        char **ptr[] = { dp0, dp1, dp2 };

		* Step 6 : Pass Array of Double Pointers by Reference

		.. code-block:: c

		        fun_r(&ptr);

		* Step 7 : Define function ``fun_r``

		.. code-block:: c

			void fun_r(char ** (*ptr_r)[3])
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", (***ptr_r)[i]);
        			}
			}

		* See the full program below

		.. code-block:: c

			#include <stdio.h>

			void fun_r(char ** (*ptr_r)[3])
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", (***ptr_r)[i]);
        			}
			}

			int main(void)
			{
			        char c0 = 65, c1 = 66, c2 = 67; 
			        char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;
			        char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

			        char **ptr[] = { dp0, dp1, dp2 };

			        fun_r(&ptr);

			        return 0;
			}

.. _array_of_ptr_char_dp_ex28:

.. tab-set::

        .. tab-item:: Example 9 : Array of Double Pointers : Pass by Reference : With typedef

		* Step 1 : Define characters

		.. code-block:: c

			char c0 = 65, c1 = 66, c2 = 67; 

		* Step 2 : Define single pointers

		.. code-block:: c

			char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;

		* Step 3 : Define double pointers

		.. code-block:: c

			char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

		* Step 4 : Define a new type using typedef

		.. code-block:: c

			typedef char **tptr[];

		* Step 5 : Define Array of Double Pointers

		.. code-block:: c

			tptr ptr = { dp0, dp1, dp2 };

		* Step 6 : Pass Array of Double Pointers by Reference

		.. code-block:: c

		        fun_r(&ptr);

		* Step 7 : Define function ``fun_r``

		.. code-block:: c

			void fun_r(tptr *ptr_r)
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", (***ptr_r)[i]);
			        }
			}

		* See the full program below

		.. code-block:: c

			#include <stdio.h>

			typedef char **tptr[];

			void fun_r(tptr *ptr_r)
			{
			        for(int i = 0; i < 3; i++) {
			                printf("%d\n", (***ptr_r)[i]);
			        }
			}

			int main(void)
			{
			        char c0 = 65, c1 = 66, c2 = 67; 
			        char *sp0 = &c0, *sp1 = &c1, *sp2 = &c2;
			        char **dp0 = &sp0, **dp1 = &sp1, **dp2 = &sp2;

			        tptr ptr = { dp0, dp1, dp2 };

			        fun_r(&ptr);

			        return 0;
			}


.. card:: See Also

        * Current Module

                * :doc:`../array_of_ptr`

        * Previous Module

                * :doc:`../../void_ptr/void_ptr`

        * Next Module

                * :doc:`../../ptr_to_array/ptr_to_array`

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