Basics of Character Triple 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 Triple Pointers ?

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

                Basics of Triple Pointers

                * :ref:`1 Triple Pointer 1 Double Pointer, 1 Single Pointer : Simple variables <basic_ptr_char_tp_sp_ex1>`
                * :ref:`1 Triple Pointer, 1 Double Pointer, 1 Single Pointer : With Single pointer pointing to arrays <basic_ptr_char_tp_sp_ex2>`
                * :ref:`1 Triple Pointer, 1 Double Pointer, 1 Single Pointer : With Single pointer heap allocation <basic_ptr_char_tp_sp_ex3>`
                * :ref:`1 Triple Pointer, 1 Double Pointer : With two heap allocations : Create 1x1 array <basic_ptr_char_tp_sp_ex4>`
                * :ref:`1 Triple Pointer, 1 Double Pointer : With two heap allocations : Create 1x10 array <basic_ptr_char_tp_sp_ex5>`
                * :ref:`1 Triple Pointer, 1 Double Pointer : Double Pointer Pointing to array of single pointers : Static <basic_ptr_char_tp_sp_ex6>`
                * :ref:`1 Triple Pointer, 1 Double Pointer : Pointing to array of single pointers : Dynamic <basic_ptr_char_tp_sp_ex7>`

.. _basic_ptr_char_tp_sp_ex1:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer, 1 Single Pointer : Simple variables

                * Step 1 : Define a Character

                .. code-block:: c

                        char c = 65;

                * Step 2 : Define a Single pointer

                .. code-block:: c

                        char *sp = &c;

                OR

                .. code-block:: c

                        char *sp;

                        sp = &c;

                * Step 3 : Define a Double pointer

                .. code-block:: c

                        char **dp = &sp;

                OR

                .. code-block:: c

                        char **dp;

                        dp = &sp;

                * Step 4 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 5 : Access user data (in this case character) using single pointer

                .. code-block:: c

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

                * Step 6 : Access user data (in this case character) using double pointer

                .. code-block:: c

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

                * Step 7 : Access user data (in this case character) using triple pointer

                .. code-block:: c

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

                * Step 8 : Use \*\*tp to point to new user data (in this case variable d)

                .. code-block:: c

                        **tp = &d;

                * Step 9 : Now user data can be accessed using \*sp, \*\*dp, \*\*\*tp which prints value of character d

                .. code-block:: c

                        printf("d = %d\n", d);
                        printf("d = %d\n", *sp);
                        printf("d = %d\n", **dp);
                        printf("d = %d\n", ***tp);

                * See full program below

                .. code-block:: c

                        #include <stdio.h>

                        int main(void)
                        {
                                char c = 65;
                                char *sp = &c;
                                char **dp = &sp;
                                char ***tp = &dp;

                                printf("c = %d\n", c);
                                printf("*sp = %d\n", *sp);
                                printf("**dp = %d\n", **dp);
                                printf("***tp = %d\n", ***tp);

                                char d = 100;

                                **tp = &d;

                                printf("d = %d\n", d);
                                printf("*sp = %d\n", *sp);
                                printf("**dp = %d\n", **dp);
                                printf("***tp = %d\n", ***tp);

                                return 0;
                        }

                * Output is as below

                .. code-block:: c

                        c = 65
                        *sp = 65
                        **dp = 65
                        ***tp = 65

                        d = 100
                        *sp = 100
                        **dp = 100
                        ***tp = 100

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

                        Summary of Naming conventions

                        Consider

                        .. code-block:: c

                                char ***tp;

                        then

                        * tp is a triple pointer
                        * \*tp is a double pointer
                        * \*\*tp is a single pointer
                        * \*\*\*tp is user data

.. _basic_ptr_char_tp_sp_ex2:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer, 1 Single Pointer : With Single pointer pointing to arrays

                * Step 1 : Define a single dimension array of characters

                .. code-block:: c

                        char arr[] = "Laptop";

                * Step 2 : Define a single pointer

                .. code-block:: c

                        char *sp = arr;

                OR

                .. code-block:: c

                        char *sp;

                        sp = arr;

                OR

                .. code-block:: c

                        char *sp;

                        sp = &arr[0];

                * Step 3 : Define a double pointer

                .. code-block:: c

                        char **dp = &sp;

                OR

                .. code-block:: c

                        char **dp;

                        dp = &sp;

                * Step 4 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 5 : Access user data (in this case array of characters) using single pointer variable ``sp``

                .. code-block:: c

                        printf("arr = %s\n", sp);

                * Step 6 : Access user data (in this case array of characters) using double pointer variable ``dp``

                .. code-block:: c

                        printf("arr = %s\n", *dp);

                * Step 7 : Access user data (in this case array of characters) using triple pointer variable ``tp``

                .. code-block:: c

                        printf("arr = %s\n", **tp);

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

                        Note ``*dp`` should be called as single pointer because of below equations

                        * dp = &sp;
                        * \*dp = sp;

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

                        Note ``**tp`` should be called as single pointer because of below equations

                        * tp = &dp;
                        * \*tp = dp;
                        * \*tp = &sp;
                        * \*\*tp = sp;  

                * See full program below

                .. code-block:: c

                        #include <stdio.h>

                        int main(void)
                        {
                                char arr[] = "Laptop";
                                char *sp = arr;
                                char **dp = &sp;
                                char ***tp = &dp;

                                //Access full array
                                printf("arr = %s\n", arr);
                                printf("sp = %s\n", sp);
                                printf("*dp = %s\n", *dp);
                                printf("**tp = %s\n", **tp);

                                //Access individual character
                                printf("arr[3] = %c\n", arr[3]);
                                printf("sp[3] = %c\n", sp[3]);
                                printf("(*dp)[3] = %c\n", (*dp)[3]);
                                printf("(**tp)[3] = %c\n", (**tp)[3]);

                                return 0;
                        }

                * Output is as below

                .. code-block:: c

                        arr  = Laptop
                        sp   = Laptop
                        *dp  = Laptop
                        **tp = Laptop

                        arr[3]    = t
                        sp[3]     = t
                        (*dp)[3]  = t
                        (**tp)[3] = t

.. _basic_ptr_char_tp_sp_ex3:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer, 1 Single Pointer : With Single pointer heap allocation

                * Step 1 : Define a single pointer

                .. code-block:: c

                        char *sp;

                * Step 2 : Allocate heap memory to single pointer

                .. code-block:: c

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

                * Step 3 : Copy User data to heap memory

                .. code-block:: c

                        strcpy(sp, "Laptop");

                * Step 4 : Define a double pointer

                .. code-block:: c

                        char **dp;
                        dp = &sp;

                * Step 5 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 6 : Access User data using single pointer variable ``sp``

                .. code-block:: c

                        printf("sp = %s\n", sp);
                        printf("sp[3] = %c\n", sp[3]);

                * Step 7 : Access User data using double pointer variable ``dp``

                .. code-block:: c

                        printf("*dp = %s\n", *dp);
                        printf("(*dp)[3] = %c\n", (*dp)[3]);

                * Step 8 : Access User data using triple pointer variable ``tp``

                .. code-block:: c

                        printf("**tp = %s\n", **tp);
                        printf("(**tp)[3] = %c\n", (**tp)[3]);

                * Step 9 : Free memory after usage

                .. code-block:: c

                        free(sp);

                OR

                .. code-block:: c

                        free(*dp);

                OR

                .. code-block:: c

                        free(**tp);

                * See full program below

                .. code-block:: c

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

                        int main(void)
                        {
                                char *sp;

                                sp = malloc(10 * sizeof(char));
                                strcpy(sp, "Laptop");

                                char **dp;
                                dp = &sp;

                                char ***tp;
                                tp = &dp;

                                printf("sp = %s\n", sp);
                                printf("*dp = %s\n", *dp);
                                printf("**tp = %s\n", **tp);

                                //Access individual character
                                printf("sp[3] = %c\n", sp[3]);
                                printf("(*dp)[3] = %c\n", (*dp)[3]);
                                printf("(**tp)[3] = %c\n", (**tp)[3]);

                                free(sp);

                                return 0;
                        }

                * Output is as below

                .. code-block:: c
                        
                        sp   = Laptop
                        *dp  = Laptop
                        **tp = Laptop

                        sp[3]     = t
                        (*dp)[3]  = t
                        (**tp)[3] = t

.. _basic_ptr_char_tp_sp_ex4:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer : With two heap allocations : Create 1x1 array

                * Step 1 : Define a double pointer

                .. code-block:: c

                        char **dp;

                * Step 2 : Allocate memory to a double pointer

                .. code-block:: c

                        dp = malloc(sizeof(char *));

                * Step 3 : Allocate memory to a single pointer

                .. code-block:: c

                        *dp = malloc(sizeof(char));

                * Step 4 : Store user data

                .. code-block:: c

                        **dp = 65;

                * Step 5 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 6 : Read user data using ``dp``

                .. code-block:: c

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

                * Step 7 : Read user data using ``tp``

                .. code-block:: c

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

                * Step 8 : Free memory in opposite flow of allocation

                .. code-block:: c

                        free(*dp);

                        free(dp);

                OR

                .. code-block:: c

                        free(**tp);

                        free(*tp);

                * See full program below

                .. code-block:: c

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

                        int main(void)
                        {
                                char **dp;

                                dp = malloc(sizeof(char *));

                                *dp = malloc(sizeof(char));

                                **dp = 65;

                                char ***tp;
                                tp = &dp;

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

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

                                free(*dp); // or free(**tp);

                                free(dp);  // or free(*tp);

                                return 0;
                        }

                * Output is as below

                .. code-block:: c

                        **dp  = 65
                        ***tp = 65

.. _basic_ptr_char_tp_sp_ex5:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer : With two heap allocations : Create 1x10 array

                * Step 1 : Define a double pointer

                .. code-block:: c

                        char **dp;

                * Step 2 : Allocate memory to a double pointer

                .. code-block:: c

                        dp = malloc(sizeof(char *));

                * Step 3 : Allocate memory to a single pointer

                .. code-block:: c

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

                * Step 4 : Copy User data to heap

                .. code-block:: c

                        strcpy(*dp, "Laptop123");

                * Step 5 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 6 : Read user data from heap using ``dp``

                .. code-block:: c

                        printf("*dp = %s\n", *dp);

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

                * Step 7 : Read user data from heap using ``tp``

                .. code-block:: c

                        printf("**tp = %s\n", **tp);

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

                * Step 6 : Free memory in opposite flow of allocation

                .. code-block:: c

                        free(*dp);

                        free(dp);

                OR

                .. code-block:: c

                        free(**tp);

                        free(*tp);

                * See full program below

                .. code-block:: c
        
                        #include <stdio.h>
                        #include <string.h>
                        #include <stdlib.h>

                        int main(void)
                        {
                                char **dp;

                                dp = malloc(sizeof(char *));

                                *dp = malloc(10 * sizeof(char));
                                memset(*dp, 0, 10);

                                strcpy(*dp, "Laptop123");

                                char ***tp;
                                tp = &dp;

                                printf("*dp = %s\n", *dp);

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

                                printf("**tp = %s\n", **tp);

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

                                free(*dp); // or free(**tp);

                                free(dp);  // or free(*tp);

                                return 0;
                        }

                * Output is as below

                .. code-block:: c

                        *dp = Laptop123
                        (*dp)[0] = L
                        (*dp)[1] = a
                        (*dp)[2] = p
                        (*dp)[3] = t
                        (*dp)[4] = o
                        (*dp)[5] = p
                        (*dp)[6] = 1
                        (*dp)[7] = 2
                        (*dp)[8] = 3
                        (*dp)[9] =

                        **tp = Laptop123
                        (**tp)[0] = L
                        (**tp)[1] = a
                        (**tp)[2] = p
                        (**tp)[3] = t
                        (**tp)[4] = o
                        (**tp)[5] = p
                        (**tp)[6] = 1
                        (**tp)[7] = 2
                        (**tp)[8] = 3
                        (**tp)[9] =

.. _basic_ptr_char_tp_sp_ex6:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer : Double Pointer Pointing to array of single pointers : Static

                * Step 1 : Define 3 Single dimension character arrays

                .. code-block:: c

                        char arr0[32] = "Laptop";
                        char arr1[32] = "Mouse";
                        char arr2[32] = "Keyboard";

                * Step 2 : Define array of single pointers

                .. code-block:: c

                        char *sp_arr[] = {arr0, arr1, arr2};

                * Step 3 : Define a double pointer

                .. code-block:: c

                        char **dp;

                        dp = sp_arr;

                * Step 4 : Use ``dp`` to change contents of single dimension arrays

                .. code-block:: c

                        strcpy(dp[0], "New Laptop");
                        strcpy(dp[1], "New Mouse");
                        strcpy(dp[2], "New Keyboard");

                * Step 5 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 6 : Use ``sp_arr`` to access contents of single dimension arrays

                .. code-block:: c

                        printf("sp_arr = %s\n", sp_arr[0]);
                        printf("sp_arr = %s\n", sp_arr[1]);
                        printf("sp_arr = %s\n", sp_arr[2]);

                * Step 7 : Use ``dp`` to access contents of single dimension arrays

                .. code-block:: c

                        printf("dp[0] = %s\n", dp[0]);
                        printf("dp[1] = %s\n", dp[1]);
                        printf("dp[2] = %s\n", dp[2]);

                * Step 8 : Use ``tp`` to access contents of single dimension arrays

                .. code-block:: c

                        printf("(*tp)[0] = %s\n", (*tp)[0]);
                        printf("(*tp)[1] = %s\n", (*tp)[1]);
                        printf("(*tp)[2] = %s\n", (*tp)[2]);

                * See full program below

                .. code-block:: c

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

                        int main(void)
                        {
                                char arr0[32] = "Laptop";
                                char arr1[32] = "Mouse";
                                char arr2[32] = "Keyboard";

                                char *sp_arr[] = {arr0, arr1, arr2};

                                char **dp;

                                dp = sp_arr;

                                char ***tp;

                                tp = &dp;

                                strcpy(dp[0], "New Laptop");
                                strcpy(dp[1], "New Mouse");
                                strcpy(dp[2], "New Keyboard");

                                printf("sp_arr = %s\n", sp_arr[0]);
                                printf("sp_arr = %s\n", sp_arr[1]);
                                printf("sp_arr = %s\n", sp_arr[2]);

                                printf("dp[0] = %s\n", dp[0]);
                                printf("dp[1] = %s\n", dp[1]);
                                printf("dp[2] = %s\n", dp[2]);

                                printf("(*tp)[0] = %s\n", (*tp)[0]);
                                printf("(*tp)[1] = %s\n", (*tp)[1]);
                                printf("(*tp)[2] = %s\n", (*tp)[2]);

                                return 0;
                        }
                        
                * Output is as below

                .. code-block:: c

                        sp_arr = New Laptop
                        sp_arr = New Mouse
                        sp_arr = New Keyboard

                        dp[0] = New Laptop
                        dp[1] = New Mouse
                        dp[2] = New Keyboard

                        (*tp)[0] = New Laptop
                        (*tp)[1] = New Mouse
                        (*tp)[2] = New Keyboard

.. _basic_ptr_char_tp_sp_ex7:

.. tab-set::

        .. tab-item:: 1 Triple Pointer, 1 Double Pointer : Pointing to array of single pointers : Dynamic

                * Step 1 : Define a double pointer

                .. code-block:: c

                        char **dp;

                * Step 2 : Allocate heap memory : Create 3 single pointers ``dp[0]``, ``dp[1]``, ``dp[2]``

                .. code-block:: c

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

                * Step 3 : Allocate heap memory : Create 3 single dimension character arrays of size 32 characters each

                .. code-block:: c

                        dp[0] = malloc(32 * sizeof(char));
                        dp[1] = malloc(32 * sizeof(char));
                        dp[2] = malloc(32 * sizeof(char));

                * Step 4 : Store user data

                .. code-block:: c

                        strcpy(dp[0], "New Laptop");
                        strcpy(dp[1], "New Mouse");
                        strcpy(dp[2], "New Keyboard");

                * Step 5 : Define a Triple pointer

                .. code-block:: c

                        char ***tp = &dp;

                OR

                .. code-block:: c

                        char ***tp;

                        tp = &dp;

                * Step 6 : Access user data using ``dp``

                .. code-block:: c

                        printf("dp[0] = %s\n", dp[0]);
                        printf("dp[1] = %s\n", dp[1]);
                        printf("dp[2] = %s\n", dp[2]);

                * Step 7 : Access user data using ``tp``

                .. code-block:: c

                        printf("(*tp)[0] = %s\n", (*tp)[0]);
                        printf("(*tp)[1] = %s\n", (*tp)[1]);
                        printf("(*tp)[2] = %s\n", (*tp)[2]);

                * Step 6 : Free 3 character arrays

                .. code-block:: c

                        free(dp[0]);
                        free(dp[1]);
                        free(dp[2]);

                OR                        

                .. code-block:: c

                        free((*tp)[0]);
                        free((*tp)[1]);
                        free((*tp)[2]);

                * Step 7 : Free 3 single pointers

                .. code-block:: c

                        free(dp);

                * See full program below

                .. code-block:: c

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

                        int main(void)
                        {
                                char **dp;

                                dp = malloc(3 * sizeof(char *));
                                dp[0] = malloc(32 * sizeof(char));
                                dp[1] = malloc(32 * sizeof(char));
                                dp[2] = malloc(32 * sizeof(char));

                                strcpy(dp[0], "New Laptop");
                                strcpy(dp[1], "New Mouse");
                                strcpy(dp[2], "New Keyboard");

                                char ***tp;

                                tp = &dp;

                                printf("dp[0] = %s\n", dp[0]);
                                printf("dp[1] = %s\n", dp[1]);
                                printf("dp[2] = %s\n", dp[2]);

                                printf("(*tp)[0] = %s\n", (*tp)[0]);
                                printf("(*tp)[1] = %s\n", (*tp)[1]);
                                printf("(*tp)[2] = %s\n", (*tp)[2]);

                                free(dp[0]);
                                free(dp[1]);
                                free(dp[2]);

                                free(dp);

                                return 0;
                        }

                * Output as is below

                .. code-block:: c

                        dp[0] = New Laptop
                        dp[1] = New Mouse
                        dp[2] = New Keyboard

                        (*tp)[0] = New Laptop
                        (*tp)[1] = New Mouse
                        (*tp)[2] = New Keyboard

.. card:: See Also

        * Current Module

                * :doc:`../basic_ptr`

        * Previous Module

                * :doc:`../../variable_and_ptr/variable_and_ptr`

        * Next Module

                * :doc:`../../array_n_ptrs/array_n_ptrs`

        * Other Modules

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