Functions and Character 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 calling conventions of character double dimension array ?

.. 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_char_ptr/char_dp`

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

	Topics in this section,

		* :ref:`Character Double Pointer : Syntax <funcs_n_ptrs_char_dp_ex_0_0>`
		* :ref:`Character Double Pointer : FAQs <funcs_n_ptrs_char_dp_ex_0_1>`

		* :ref:`Character Double Pointer : fun(expression) <funcs_n_ptrs_char_dp_ex_6>`

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

			* :ref:`Example : Call by Value : Pass Character : dp[1][1] <funcs_n_ptrs_char_dp_ex_9>`
			* :ref:`Example : Call by Value : Pass Character : **dp <funcs_n_ptrs_char_dp_ex_10>`

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

			* :ref:`Example : Call by Reference : &dp[1][1] <funcs_n_ptrs_char_dp_ex_12>`
			* :ref:`Example : Call by Reference : dp[1] <funcs_n_ptrs_char_dp_ex_13>`

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

        		* :ref:`Example 1 : Call by Value : Pass Character : dp[0][0], dp[1][0], dp[1][1] <funcs_n_ptrs_char_dp_ex_15>`
	        	* :ref:`Example 2 : Call by Value : Pass Character : **dp, *(*(dp + 1) + 0), *(*(dp + 1) + 1) <funcs_n_ptrs_char_dp_ex_16>`

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

		        * :ref:`Example 3 : Call by Reference : Pass Single dimension arrays which are part of a double dimension array to a function  <funcs_n_ptrs_char_dp_ex_17>`
	        	* :ref:`Example 4 : Call by Reference : Pass Address of Double Dimension array to a function <funcs_n_ptrs_char_dp_ex_19>`

.. _funcs_n_ptrs_char_dp_ex_0_0:

.. tab-set::

        .. tab-item:: Character Double Pointer : Syntax

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

                        char \*\*dp;

.. _funcs_n_ptrs_char_dp_ex_0_1:

.. tab-set::

        .. tab-item:: Character Double Pointer : FAQs

		Consider a character double dimension array

		.. code-block:: c

			char **dp;

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

			Let us answer few basic questions about character double pointer

.. _funcs_n_ptrs_char_dp_ex_6:

.. tab-set::

        .. tab-item:: Character Double 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(dp[0][0])		   void fun(char x) {}		   * Call by Value
		fun(dp[1][0])              void fun(char x) {}             * Call by Value
		fun(dp[2][0])              void fun(char x) {}             * Call by Value
		fun(&dp[0][0])             void fun(char \*p) { }          * Call by Reference
		fun(&dp[1][0])             void fun(char \*p) { }          * Call by Reference
		fun(&dp[2][0])             void fun(char \*p) { }          * Call by Reference
		fun(\*\*dp)                void fun(char x) {}             * Call by Value
		fun(\*(\*(dp + 1) + 0))    void fun(char x) {}             * Call by Value
		fun(\*(\*(dp + 2) + 0))    void fun(char x) {}             * Call by Value
		fun(dp[0])                 void fun(char \*p) { }          * Call by Reference
		fun(dp[1])                 void fun(char \*p) { }          * Call by Reference
		fun(dp[2])                 void fun(char \*p) { }          * Call by Reference
		fun(&dp[0])         	   void fun(char \*\*q) { }        * Call by Reference
		fun(\*dp)                  void fun(char \*p) { }          * Call by Reference
		fun(\*(dp + 1))            void fun(char \*p) { }          * Call by Reference
		fun(\*(dp + 2))            void fun(char \*p) { }          * Call by Reference
		fun(dp)                    void fun(char \*\*q) { }        * Call by Reference
		fun(&dp)                   void fun(char \*\*\*r) { }      * Call by Reference
		========================== =============================== ==========================================================================


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

			Let us understand the reason behind above prototypes !

.. _funcs_n_ptrs_char_dp_ex_8:

.. 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 two dereference operators, and
	
				* Expression has two dereference operators [] [], 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 two dereference operators, and
	
				* Expression has two dereference operators \* \*, 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 two dereference operators, and
	
				* Expression has two dereference operators \* [ ], and
	
				* Expression does not have ``&``
	
				* then it is call by value

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

			Let us look at examples 

.. _funcs_n_ptrs_char_dp_ex_9:

.. tab-set::

        .. tab-item:: Example : Call by Value : Pass Character : dp[1][1]

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

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

			Condition 1 : Declaration has TWO dereference operators \* and \*

		* Step 2 : Consider an expression ``dp[1][1]``

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

			Condition 2 : Expression has TWO dereference operators [ ] and [ ] 
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Note : ``[ ]`` and ``*`` are dereference operators

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

			Condition 3 : Expression DOES NOT have ``&`` operator

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

			Hence ``dp[1][1]`` is Call By Value

.. _funcs_n_ptrs_char_dp_ex_10:

.. tab-set::

        .. tab-item:: Example : Call by Value : Pass Character : \*\*dp

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

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

			Condition 1 : Declaration has TWO dereference operators [ ] and [ ] 

		* Step 2 : Consider an expression ``**dp``

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

			Condition 2 : Expression has TWO dereference operators \* and \*
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Note : ``[ ]`` and ``*`` are dereference operators

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

			Condition 3 : Expression DOES NOT have ``&`` operator

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

			Hence ``**dp`` is Call By Value

.. _funcs_n_ptrs_char_dp_ex_11:

.. 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 two dereference operators, and

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

				* Expression has &

				* then it is call by reference

				* Example : &dp[0][0]

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

			If Declaration has two dereference operators, and

				* Expression has one dereference operator [ ] or \*

				* then it is call by reference

				* Example : &dp[0], dp[0], \*dp

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

			If Declaration has two dereference operators, and

				* Expression has zero dereference operators, and

				* then it is call by reference

				* Example : dp, &dp

.. _funcs_n_ptrs_char_dp_ex_12:

.. tab-set::

        .. tab-item:: Example 1 : Call by Reference : &dp[1][1]

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

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

			Condition 1 : Declaration has TWO dereference operators [ ] and [ ] 

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

			Condition 2 : Expression has TWO dereference operators \* and \*
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Note : ``[ ]`` and ``*`` are dereference operators

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

			Condition 3 : Expression has ``&`` operator

		* Step 2 : Consider an expression ``&dp[1][1]``

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

			Hence ``&dp[1][1]`` is Call By Reference

.. _funcs_n_ptrs_char_dp_ex_13:

.. tab-set::

        .. tab-item:: Example 2 : Call by Reference : dp[1]

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

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

			Condition 1 : Declaration has TWO dereference operators [ ] and [ ]

		* Step 2 : Consider an expression ``dp[1]``

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

			Condition 2 : Expression has ONE dereference operators
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Note : ``[ ]`` and ``*`` are dereference operators

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

			Condition 3 : Expression DOES NOT have ``&`` operator

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

			Hence ``dp[1]`` is Call By Reference

.. _funcs_n_ptrs_char_td_array_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_char_dp_ex_15:

.. tab-set::

        .. tab-item:: Example 1 : Call by Value : Pass Character : dp[0][0], dp[1][0], dp[1][1]

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

		* Step 2 : Pass dp[0][0], dp[1][0], dp[1][1] to a function ``fun``

		.. code-block:: c

		        fun(dp[0][0]);

		        fun(dp[1][0]);
        
		        fun(dp[1][1]);

		* Step 3 : Define function ``fun``

		.. code-block:: c

			void fun(char c)
			{
			        printf("char is %c\n", c);

				c = 'k';
			}

		* Step 4 : Note that it is call by Value for below reason

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

			Condition 1 : Declaration has TWO dereference operators [ ] and [ ] 

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

			Condition 2 : Expression has TWO dereference operators [ ] and [ ]
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Condition 3 : Expression DOES NOT have ``&`` operator

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

			Means changing value of character inside function DOES NOT affect value of character in Caller !

		* Step 5 : Free memory after use

		.. code-block:: c

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

                        free(dp);

		* See full program below

		.. code-block:: c

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

			void fun(char c)
			{
			        printf("char is %c\n", c);
			}

			int main(void)
			{
                                char **dp;

                                dp = malloc(3 * sizeof(char *));

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

                                strcpy(dp[0], "lap");
                                strcpy(dp[1], "top");
                                strcpy(dp[2], "123");

			        fun(dp[0][0]);
			        fun(dp[1][0]);
			        fun(dp[1][1]);

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

                                free(dp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        char is l
                        char is t
                        char is o

.. _funcs_n_ptrs_char_dp_ex_16:

.. tab-set::

        .. tab-item:: Example 2 : Call by Value : Pass Character : \*\*dp, \*(\*(dp + 1) + 0), \*(\*(dp + 1) + 1)

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

		* Step 2 : Pass \*\*dp, \*(\*(dp + 1) + 0), \*(\*(dp + 1) + 1) to a function ``fun``

		.. code-block:: c

		        fun( **dp );

		        fun( *(*(dp + 1) + 0) );
        
		        fun( *(*(dp + 1) + 1) );

		* Step 3 : Define function ``fun``

		.. code-block:: c

			void fun(char c)
			{
			        printf("char is %c\n", c);

				c = 'k';
			}

		* Step 4 : Note that it is call by Value for below reason

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

			Condition 1 : Declaration has TWO dereference operators [ ] and [ ]

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

			Condition 2 : Expression has TWO dereference operators \* and \*
		
		.. panels::
			:container: container pb-4
			:column: col-lg-12 p-2
			:card: shadow

			Condition 3 : Expression DOES NOT have ``&`` operator

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

			Means changing value of character inside function DOES NOT affect value of character in Caller !

		* Step 5 : Free memory after use

		.. code-block:: c

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

                        free(dp);

		* See full program below

		.. code-block:: c

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

			void fun(char c)
			{
			        printf("char is %c\n", c);
			}

			int main(void)
			{
                                char **dp;

                                dp = malloc(3 * sizeof(char *));

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

                                strcpy(dp[0], "lap");
                                strcpy(dp[1], "top");
                                strcpy(dp[2], "123");

				fun( **dp );

				fun( *(*(dp + 1) + 0) );

				fun( *(*(dp + 1) + 1) );

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

                                free(dp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        char is l
                        char is t
                        char is o

.. _funcs_n_ptrs_char_td_array_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_char_dp_ex_17:

.. tab-set::

        .. tab-item:: Example 3 : Call by Reference : Pass Single dimension arrays which are part of a double dimension array to a function

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");


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

			There are 3 single dimension arrays

			* dp[0]

			* dp[1]

			* dp[2]

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

			dp[0] is also equal to \*dp

			dp[1] is also equal to \*(dp + 1)

			dp[2] is also equal to \*(dp + 2)

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

			dp[0] is also equal to &dp[0][0]

			dp[1] is also equal to &dp[1][0]

			dp[2] is also equal to &dp[2][0]

		* Step 2.1 : Method 1 : Pass &dp[0][0], &dp[1][0], &dp[2][0] to a function ``fun``

		.. code-block:: c

			fun( &dp[0][0] );

			fun( &dp[1][0] );

			fun( &dp[2][0] );

		* Step 2.2 : Method 2 : Pass dp[0], dp[1], dp[2] to a function ``fun``

		.. code-block:: c

			fun( dp[0] );

			fun( dp[1] );

			fun( dp[2] );

		* Step 2.3 : Method 3 : Pass \*dp, \*(dp + 1), \*(dp + 2) to a function ``fun``

		.. code-block:: c

			fun( *dp );

			fun( *(dp + 1) );

			fun( *(dp + 2) );

		* Step 3.1 : Define function ``fun``

		.. code-block:: c

			void fun(char *ptr)
			{
		        	printf("string is %s\n", ptr);
			}

		* Step 4 : Note that it is call by Reference. Means contents of single dimension array can be changed inside function ``fun``

		.. code-block:: c

			void fun(char *ptr)
			{
		        	strcpy(ptr, "123");
			}

		* Step 5 : Free memory after usage

		.. code-block:: c

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

                        free(dp);

		* See full program below

		.. code-block:: c

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

			void fun(char *ptr)
			{
		        	printf("string is %s\n", ptr);
			}

			int main(void)
			{
                                char **dp;

                                dp = malloc(3 * sizeof(char *));

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

                                strcpy(dp[0], "lap");
                                strcpy(dp[1], "top");
                                strcpy(dp[2], "123");

			        printf("Method 1 : Access Single dimension arrays\n");

			        fun( &dp[0][0] );

			        fun( &dp[1][0] );

			        fun( &dp[2][0] );

			        printf("Method 2 : Access Single dimension arrays\n");

			        fun( dp[0] );

			        fun( dp[1] );

			        fun( dp[2] );

			        printf("Method 3 : Access Single dimension arrays\n");

			        fun( *dp );

			        fun( *(dp + 1) );

			        fun( *(dp + 2) );

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

                                free(dp);

			        return 0;
			}


		* Output is as below

		.. code-block:: c

			Method 1 : Access Single dimension arrays
			string is lap
			string is top
			string is 123

			Method 2 : Access Single dimension arrays
			string is lap
			string is top
			string is 123

			Method 3 : Access Single dimension arrays
			string is lap
			string is top
			string is 123

.. _funcs_n_ptrs_char_dp_ex_19:

.. tab-set::

        .. tab-item:: Example 4 : Call by Reference : Pass Address of Double Dimension array to a function

		* Step 1 : Consider a double dimension array created using a character double pointer

		.. code-block:: c

                        char **dp;

                        dp = malloc(3 * sizeof(char *));

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

                        strcpy(dp[0], "lap");
                        strcpy(dp[1], "top");
                        strcpy(dp[2], "123");

		* Step 2 : Pass Address of Double Dimension array to a function

		.. code-block:: c

			fun(&dp);

		* Step 3.1 : Define function ``fun``

		.. code-block:: c

			void fun(char ***ptr )
			{

			}

		* Step 3.2 : Access and Print the strings inside function ``fun``

		.. code-block:: c

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

		* Step 3.3 : Access and Print individual characters inside function ``fun``

		.. code-block:: c

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

		* Step 3.4 : Access and change strings inside function ``fun``

		.. code-block:: c

		        for (int i = 0 ; i < 3; i++) {
		                strcpy( (*ptr)[i], "pgx" );
		        }

		* Step 3.5 : Access and change individual characters inside function ``fun``

		.. code-block:: c

		        for (int i = 0 ; i < 3; i++) {
		                for (int j = 0 ; j < 4; j++) {
		                        (*ptr)[i][j] = 'c';
		                }
		        }

		* Step 4 : Free memory after usage

		.. code-block:: c

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

                        free(dp);

		* See full program below

		.. code-block:: c

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

			void fun(char ***ptr)
			{
			        // Print Individual strings
			        for (int i = 0 ; i < 3; i++) {
			                printf("%s\n", (*ptr)[i]);
			        }

			        // Print Individual characters
			        for (int i = 0 ; i < 3; i++) {
			                for (int j = 0 ; j < 4; j++) {
                        			printf("%c\n", (*ptr)[i][j]);
			                }
			        }

			        // Change Individual strings
			        for (int i = 0 ; i < 3; i++) {
			                strcpy( (*ptr)[i], "pgx" );
			        }

			        // Change Individual characters
			        for (int i = 0 ; i < 3; i++) {
			                for (int j = 0 ; j < 4; j++) {
			                        (*ptr)[i][j] = 'c';
			                }
			        }

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

			int main(void)
			{
                                char **dp;

                                dp = malloc(3 * sizeof(char *));

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

                                strcpy(dp[0], "lap");
                                strcpy(dp[1], "top");
                                strcpy(dp[2], "123");

			        fun(&dp);

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

                                free(dp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

                        lap
                        top
                        123
                        l
                        a
                        p

                        t
                        o
                        p

                        1
                        2
                        3

                        cccc
                        cccc
                        cccc

.. card:: See Also

	* Other topics of character and functions

		* :doc:`./char`
		* :doc:`./char_sd_array`
		* :doc:`./char_dd_array`
		* :doc:`./char_td_array`
		* :doc:`./char_sp`
		* :doc:`./char_dp`
		* :doc:`./char_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`