Functions and Character Triple 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 triple pointer ?
.. 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_tp`
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Topics in this section,
* :ref:`Character Triple Pointer : Syntax <funcs_n_ptrs_char_tp_ex_0>`
* :ref:`Character Triple Pointer : FAQs <funcs_n_ptrs_char_tp_ex_0_1>`
* :ref:`Character Triple Pointer : fun(expression) <funcs_n_ptrs_char_tp_ex_6>`
* :ref:`Rules for Call By Value <funcs_n_ptrs_char_tp_ex_8>`
* :ref:`Example : Call by Value : Pass Character : tp[1][1][1] <funcs_n_ptrs_char_tp_ex_9>`
* :ref:`Example : Call by Value : Pass Character : ***tp <funcs_n_ptrs_char_tp_ex_10>`
* :ref:`Rules for Call By Reference <funcs_n_ptrs_char_tp_ex_11>`
* :ref:`Example : Call by Reference : &tp[1][1] <funcs_n_ptrs_char_tp_ex_12>`
* :ref:`Example : Call by Reference : tp[1] <funcs_n_ptrs_char_tp_ex_13>`
* :ref:`Examples of Call by Value <funcs_n_ptrs_char_tp_examples_call_by_value>`
* :ref:`Example 1 : Call by Value : Pass Character : tp[0][0][0], tp[1][0][0], tp[2][0][0] <funcs_n_ptrs_char_tp_ex_15>`
* :ref:`Example 2 : Call by Value : Pass Character : \*\*\*tp, \*(\*(\*(tp + 1) + 0) + 0), \*(\*(\*(tp + 2) + 0) + 0) <funcs_n_ptrs_char_tp_ex_16>`
* :ref:`Examples of Call by Reference <funcs_n_ptrs_char_tp_examples_call_by_reference>`
* :ref:`Example 3 : Call by Reference : Pass Single dimension arrays which are part of a triple pointer to a function <funcs_n_ptrs_char_tp_ex_17>`
* :ref:`Example 4 : Call by Reference : Pass Address of Single dimension arrays which are part of a triple pointer to a function <funcs_n_ptrs_char_tp_ex_18>`
* :ref:`Example 5 : Call by Reference : Pass Double dimension arrays which are part of a Triple dimension array to a function <funcs_n_ptrs_char_tp_ex_19>`
* :ref:`Example 6 : Call by Reference : Pass Address of Double dimension arrays which are part of a Triple dimension array to a function <funcs_n_ptrs_char_tp_ex_20>`
* :ref:`Example 7 : Call by Reference : Pass Address of Triple Dimension array to a function <funcs_n_ptrs_char_tp_ex_21>`
.. _funcs_n_ptrs_char_tp_ex_0:
.. tab-set::
.. tab-item:: Character Triple Pointer : Syntax
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
char \*\*\*tp;
.. _funcs_n_ptrs_char_tp_ex_0_1:
.. tab-set::
.. tab-item:: Character Triple Pointer : FAQs
Consider a character triple pointer
.. code-block:: c
char ***tp;
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Let us answer few basic questions about character triple pointer
.. _funcs_n_ptrs_char_tp_ex_6:
.. tab-set::
.. tab-item:: Character Triple 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(tp[0][0][0]) void fun(char x) {} * Call by Value
fun(tp[1][0][0]) void fun(char x) {} * Call by Value
fun(tp[2][0][0]) void fun(char x) {} * Call by Value
fun(&tp[0][0][0]) void fun(char \*p) {} * Call by Reference
fun(&tp[1][0][0]) void fun(char \*p) {} * Call by Reference
fun(&tp[2][0][0]) void fun(char \*p) {} * Call by Reference
fun(tp[0][0]) void fun(char \*p) {} * Call by Reference
fun(tp[1][0]) void fun(char \*p) {} * Call by Reference
fun(tp[2][0]) void fun(char \*p) {} * Call by Reference
fun(&tp[0][0]) void fun(char \*\*p) {} * Call by Reference
fun(&tp[1][0]) void fun(char \*\*p) {} * Call by Reference
fun(&tp[2][0]) void fun(char \*\*p) {} * Call by Reference
fun(\*\*tp) void fun(char \*p) {} * Call by Reference
fun(\*(\*(tp + 1) + 0)) void fun(char \*p) {} * Call by Reference
fun(\*(\*(tp + 2) + 0)) void fun(char \*p) {} * Call by Reference
fun(tp[0]) void fun(char \*\*p) {} * Call by Reference
fun(tp[1]) void fun(char \*\*p) {} * Call by Reference
fun(tp[2]) void fun(char \*\*p) {} * Call by Reference
fun(&tp[0]) void fun(char \*\*\*p) {} * Call by Reference
fun(\*tp) void fun(char \*\*p) {} * Call by Reference
fun(\*(tp + 1)) void fun(char \*\*p) {} * Call by Reference
fun(\*(tp + 2)) void fun(char \*\*p) {} * Call by Reference
fun(tp) void fun(char \*\*\*p) {} * Call by Reference
fun(&tp) void fun(char \*\*\*\*p) {} * 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_tp_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 THREE dereference operators, and
* Expression has THREE 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 THREE dereference operators, and
* Expression has THREE 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 THREE dereference operators, and
* Expression has THREE 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 THREE dereference operators, and
* Expression has THREE 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_tp_ex_9:
.. tab-set::
.. tab-item:: Example 1 : Call by Value : Pass Character : tp[1][1][1]
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 1 : Declaration has THREE dereference operators [ ], [ ] and [ ]
* Step 2 : Consider an expression ``tp[1][1][1]``
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 2 : Expression has THREE 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 ``tp[1][1][1]`` is Call By Value
.. _funcs_n_ptrs_char_tp_ex_10:
.. tab-set::
.. tab-item:: Example 2 : Call by Value : Pass Character : \*\*\*tp
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 1 : Declaration has THREE dereference operators [ ], [ ] and [ ]
* Step 2 : Consider an expression ``***tp``
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 2 : Expression has THREE 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 ``***tp`` is Call By Value
.. _funcs_n_ptrs_char_tp_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 THREE dereference operators, and
* Expression has THREE dereference operators \* \* \* OR \* \* [] OR \* [] [] OR [] [] [] and
* Expression has &
* then it is call by reference
* Example : &tp[0][0][0], &tp[1][2][3]
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
If Declaration has THREE dereference operators, and
* Expression has TWO dereference operator \* \* OR [] [] OR \* []
* then it is call by reference
* Example : tp[0][0]
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
If Declaration has THREE dereference operators, and
* Expression has ONE dereference operators, \* OR [ ]
* then it is call by reference
* Example : tp[0]
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
If Declaration has THREE dereference operators, and
* Expression has ZERO dereference operators
* then it is call by reference
* Example : tp
.. _funcs_n_ptrs_char_tp_ex_12:
.. tab-set::
.. tab-item:: Example 1 : Call by Reference : &tp[1][1][1]
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 1 : Declaration has THREE dereference operators [ ] [ ] and [ ]
* Step 2 : Consider an expression ``&tp[1][1][1]``
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 2 : Expression has THREE 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
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Hence ``&tp[1][1][1]`` is Call By Reference
.. _funcs_n_ptrs_char_tp_ex_13:
.. tab-set::
.. tab-item:: Example 2 : Call by Reference : tp[1]
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 1 : Declaration has THREE dereference operators [ ] [ ] and [ ]
* Step 2 : Consider an expression ``tp[1]``
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 2 : Expression has ONE dereference operator
.. 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 ``tp[1]`` is Call By Reference
.. _funcs_n_ptrs_char_tp_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_tp_ex_15:
.. tab-set::
.. tab-item:: Example 1 : Call by Value : Pass Character : tp[0][0][0], tp[1][0][0], tp[2][0][0]
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
* Step 2 : Pass tp[0][0][0], tp[1][0][0], tp[2][0][0] to a function ``fun``
.. code-block:: c
fun(tp[0][0][0]);
fun(tp[1][0][0]);
fun(tp[2][0][0]);
* 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 THREE dereference operators [ ] [ ] and [ ]
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 2 : Expression has THREE 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++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* 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);
c = 'k';
}
int main(void)
{
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
fun(tp[0][0][0]);
fun(tp[1][0][0]);
fun(tp[2][0][0]);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
return 0;
}
* Output is as below
.. code-block:: c
char is l
char is g
char is s
.. _funcs_n_ptrs_char_tp_ex_16:
.. tab-set::
.. tab-item:: Example 2 : Call by Value : Pass Character : \*\*\*tp, \*(\*(\*(tp + 1) + 0) + 0), \*(\*(\*(tp + 2) + 0) + 0)
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
* Step 2 : Pass \*\*\*tp, \*(\*(\*(tp + 1) + 0) + 0), \*(\*(\*(tp + 2) + 0) + 0) to a function ``fun``
.. code-block:: c
fun( ***tp );
fun( *(*(*(tp + 1) + 0) + 0) );
fun( *(*(*(tp + 2) + 0) + 0) );
* 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 THREE dereference operators [ ] [ ] and [ ]
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Condition 2 : Expression has THREE 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++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* 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 ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
fun( ***tp );
fun( *(*(*(tp + 1) + 0) + 0) );
fun( *(*(*(tp + 2) + 0) + 0) );
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
return 0;
}
* Output is as below
.. code-block:: c
char is l
char is g
char is s
.. _funcs_n_ptrs_char_tp_examples_call_by_reference:
.. 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 Reference
.. _funcs_n_ptrs_char_tp_ex_17:
.. tab-set::
.. tab-item:: Example 3 : Call by Reference : Pass Single dimension arrays which are part of a triple pointer to a function
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
There are 12 single dimension arrays in ``char \*\*\*tp`` with respect to above allocation
tp[0][0]
tp[0][1]
tp[0][2]
tp[0][3]
tp[1][0]
tp[1][1]
tp[1][2]
tp[1][3]
tp[2][0]
tp[2][1]
tp[2][2]
tp[2][3]
* Step 2.1 : Method 1 : Pass tp[0][0], tp[1][0], tp[2][0] to a function ``fun``
.. code-block:: c
fun( tp[0][0] );
fun( tp[1][0] );
fun( tp[2][0] );
* Step 2.2 : Method 2 : Pass &tp[0][0][0], &tp[1][0][0], &tp[2][0][0] to a function ``fun``
.. code-block:: c
fun( &tp[0][0][0] );
fun( &tp[1][0][0] );
fun( &tp[2][0][0] );
* Step 2.3 : Method 3 : Pass \*\*tp, \*(\*(tp + 1) + 0), \*(\*(tp + 2) + 0) to a function ``fun``
.. code-block:: c
fun( **tp );
fun( *(*(tp + 1) + 0) );
fun( *(*(tp + 2) + 0) );
* 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 use
.. code-block:: c
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* 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 ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
printf("Method 1 : Access Single dimension arrays\n");
fun( tp[0][0] );
fun( tp[1][0] );
fun( tp[2][0] );
printf("Method 2 : Access Single dimension arrays\n");
fun( &tp[0][0][0] );
fun( &tp[1][0][0] );
fun( &tp[2][0][0] );
printf("Method 3 : Access Single dimension arrays\n");
fun( **tp );
fun( *(*(tp + 1) + 0) );
fun( *(*(tp + 2) + 0) );
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
return 0;
}
* Output is as below
.. code-block:: c
Method 1 : Access Single dimension arrays
string is lap0
string is gap0
string is sap0
Method 2 : Access Single dimension arrays
string is lap0
string is gap0
string is sap0
Method 3 : Access Single dimension arrays
string is lap0
string is gap0
string is sap0
.. _funcs_n_ptrs_char_tp_ex_18:
.. tab-set::
.. tab-item:: Example 4 : Call by Reference : Pass Address of Single dimension arrays which are part of a triple pointer to a function
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
There are 12 single dimension arrays in
tp[0][0]
tp[0][1]
tp[0][2]
tp[0][3]
tp[1][0]
tp[1][1]
tp[1][2]
tp[1][3]
tp[2][0]
tp[2][1]
tp[2][2]
tp[2][3]
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Address of single dimension arrays is simply
&tp[0][0]
&tp[0][1]
&tp[0][2]
&tp[0][3]
&tp[1][0]
&tp[1][1]
&tp[1][2]
&tp[1][3]
&tp[2][0]
&tp[2][1]
&tp[2][2]
&tp[2][3]
* Step 2.1 : Method 1 : Pass address of single dimension arrays to a function ``fun``
.. code-block:: c
fun( &tp[0][0] );
fun( &tp[1][0] );
fun( &tp[2][0] );
* Step 2.2 : Method 2 : Pass address of single dimension arrays to a function ``fun``
.. code-block:: c
fun( tp[0] );
fun( tp[1] );
fun( tp[2] );
* Step 2.3 : Method 2 : Pass address of single dimension arrays to a function ``fun``
.. code-block:: c
fun( *tp );
fun( *(tp + 1) );
fun( *(tp + 2) );
* Step 3.1 : Define the function ``fun``
.. code-block:: c
void fun(char **ptr )
{
printf("string is %s\n", *ptr);
}
* Step 3.2 : Define the function ``fun`` to change the contents of single dimension array
.. code-block:: c
void fun(char **ptr )
{
printf("string is %s\n", *ptr);
strcpy((char *)*ptr, "Gap");
}
* Step 3.3 : Define the function ``fun`` to change the contents of single dimension array character by character
.. code-block:: c
void fun(char **ptr)
{
strcpy((char *)*ptr, "Gap");
(*ptr)[0] = 'p';
(*ptr)[1] = 'g';
(*ptr)[2] = 'x';
(*ptr)[3] = 'y';
(*ptr)[4] = '\0';
printf("string is %s\n", *ptr);
}
* Step 4 : Free memory after use
.. code-block:: c
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* See full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void fun(char **ptr )
{
strcpy((char *)*ptr, "Gap");
(*ptr)[0] = 'p';
(*ptr)[1] = 'g';
(*ptr)[2] = 'x';
(*ptr)[3] = 'y';
(*ptr)[4] = '\0';
printf("string is %s\n", *ptr);
}
int main(void)
{
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
printf("Method 1 : Access Single dimension arrays\n");
fun( &tp[0][0] );
fun( &tp[1][0] );
fun( &tp[2][0] );
printf("Method 2 : Access Single dimension arrays\n");
fun( tp[0] );
fun( tp[1] );
fun( tp[2] );
printf("Method 3 : Access Single dimension arrays\n");
fun( *tp );
fun( *(tp + 1) );
fun( *(tp + 2) );
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
return 0;
}
* Output is as below
.. code-block:: c
Method 1 : Access Single dimension arrays
string is pgxy
string is pgxy
string is pgxy
Method 2 : Access Single dimension arrays
string is pgxy
string is pgxy
string is pgxy
Method 3 : Access Single dimension arrays
string is pgxy
string is pgxy
string is pgxy
.. _funcs_n_ptrs_char_tp_ex_19:
.. tab-set::
.. tab-item:: Example 5 : Call by Reference : Pass Double dimension arrays which are part of a Triple dimension array to a function
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
* Step 2 : Pass Double dimension array to function ``fun``
.. code-block:: c
fun(tp[1]);
* Step 3.1 : Define function ``fun``
.. code-block:: c
void fun(char **ptr)
{
}
* Step 3.2 : Access and Print strings inside function ``fun``
.. code-block:: c
void fun(char **ptr)
{
for(int i = 0; i < 4; i++)
{
printf("%s", ptr[i]);
printf("\n");
}
}
* Step 3.3 : Access and Print characters inside function ``fun``
.. code-block:: c
void fun(char **ptr)
{
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%c", ptr[i][j]);
}
printf("\n");
}
}
* Step 3.4 : Access and Change strings inside function ``fun``
.. code-block:: c
void fun(char **ptr)
{
for(int i = 0; i < 4; i++)
{
strncpy(ptr[i], "gggg", 5);
}
}
* Step 3.5 : Access and Change characters inside function ``fun``
.. code-block:: c
void fun(char **ptr)
{
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5 - 1; j++)
{
ptr[i][j] = 'c';
}
}
}
* Step 4 : Free memory after use
.. code-block:: c
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* Step 5 : See the full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void fun(char **ptr)
{
// Access Strings and Print
printf("fun() : Access Strings and Print\n");
for(int i = 0; i < 4; i++)
{
printf("%s", ptr[i]);
printf("\n");
}
// Access Characters and Print
printf("fun() : Access Characters and Print\n");
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%c", ptr[i][j]);
}
printf("\n");
}
//Access Strings and Change
for(int i = 0; i < 4; i++)
{
strncpy(ptr[i], "gggg", 5);
}
printf("fun() : Access Strings and Print\n");
for(int i = 0; i < 4; i++)
{
printf("%s", ptr[i]);
printf("\n");
}
// Access Characters and Change
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5 - 1; j++)
{
ptr[i][j] = 'c';
}
}
printf("fun() : Access Strings and Print\n");
for(int i = 0; i < 4; i++)
{
printf("%s", ptr[i]);
printf("\n");
}
}
int main(void)
{
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
fun(tp[1]);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
return 0;
}
* Step 5 : Output is as below
.. code-block:: c
fun() : Access Strings and Print
gap0
pop0
yyy0
4560
fun() : Access Characters and Print
gap0
pop0
yyy0
4560
fun() : Access Strings and Print
gggg
gggg
gggg
gggg
fun() : Access Strings and Print
cccc
cccc
cccc
cccc
.. _funcs_n_ptrs_char_tp_ex_20:
.. tab-set::
.. tab-item:: Example 6 : Call by Reference : Pass address of Double dimension arrays which are part of a Triple dimension array to a function
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
* Step 2 : Pass Address of Double dimension array to function ``fun``
.. code-block:: c
fun(&tp[1]);
* Step 3.1 : Define function ``fun``
.. code-block:: c
void fun(char ***ptr)
{
}
* Step 3.2 : Access and Print strings inside function ``fun``
.. code-block:: c
void fun(char ***ptr)
{
for(int i = 0; i < 4; i++)
{
printf("%s", (*ptr)[i]);
printf("\n");
}
}
* Step 3.3 : Access and Print characters inside function ``fun``
.. code-block:: c
void fun(char ***ptr)
{
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%c", (*ptr)[i][j]);
}
printf("\n");
}
}
* Step 3.4 : Access and Change strings inside function ``fun``
.. code-block:: c
void fun(char ***ptr)
{
for(int i = 0; i < 4; i++)
{
strncpy( (*ptr)[i], "gggg", 5);
}
}
* Step 3.5 : Access and Change characters inside function ``fun``
.. code-block:: c
void fun(char ***ptr)
{
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5 - 1; j++)
{
(*ptr)[i][j] = 'c';
}
}
}
* Step 4 : Free memory after use
.. code-block:: c
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* Step 5 : See the full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void fun(char ***ptr)
{
// Access Strings and Print
printf("fun() : Access Strings and Print\n");
for(int i = 0; i < 4; i++)
{
printf("%s", (*ptr)[i]);
printf("\n");
}
// Access Characters and Print
printf("fun() : Access Characters and Print\n");
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%c", (*ptr)[i][j]);
}
printf("\n");
}
//Access Strings and Change
for(int i = 0; i < 4; i++)
{
strncpy((*ptr)[i], "gggg", 5);
}
printf("fun() : Access Strings and Print\n");
for(int i = 0; i < 4; i++)
{
printf("%s", (*ptr)[i]);
printf("\n");
}
// Access Characters and Change
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5 - 1; j++)
{
(*ptr)[i][j] = 'c';
}
}
printf("fun() : Access Strings and Print\n");
for(int i = 0; i < 4; i++)
{
printf("%s", (*ptr)[i]);
printf("\n");
}
}
int main(void)
{
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
fun(&tp[1]);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
return 0;
}
* Step 5 : Output is as below
.. code-block:: c
fun() : Access Strings and Print
gap0
pop0
yyy0
4560
fun() : Access Characters and Print
gap0
pop0
yyy0
4560
fun() : Access Strings and Print
gggg
gggg
gggg
gggg
fun() : Access Strings and Print
cccc
cccc
cccc
cccc
.. _funcs_n_ptrs_char_tp_ex_21:
.. tab-set::
.. tab-item:: Example 7 : Call by Reference : Pass Address of Triple Dimension array to a function
* Step 1 : Consider a triple dimension array created using a character triple pointer
.. code-block:: c
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
* Step 2 : Pass Address of Triple Dimension array to a function
.. code-block:: c
fun(&tp);
* 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++)
{
for(int j = 0; j < 4; j++)
{
printf("(*ptr)[%d][%d] = %s\n", i, j, (*ptr)[i][j]);
}
}
* 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++)
{
for(int k = 0; k < 4; k++)
{
printf("(*ptr)[%d][%d][%d] = %c\n", i, j, k, (*ptr)[i][j][k]);
}
}
}
* Step 3.4 : Access and change strings inside function ``fun``
.. code-block:: c
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
strcpy( (*ptr)[i][j], "ccc");
}
}
* 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++)
{
for(int k = 0; k < 5; k++)
{
(*ptr)[i][j][k] = 'c';
}
}
}
* Step 4 : Free memory after use
.. code-block:: c
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
* See full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void fun(char ****ptr)
{
//Access and print individual strings
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
printf("(*ptr)[%d][%d] = %s\n", i, j, (*ptr)[i][j]);
}
}
//Access and print individual characters
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
for(int k = 0; k < 4; k++)
{
printf("(*ptr)[%d][%d][%d] = %c\n", i, j, k, (*ptr)[i][j][k]);
}
}
}
//Access and change individual strings
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
strcpy( (*ptr)[i][j], "ccc");
}
}
//Access and change individual characters
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
for(int k = 0; k < 5; k++)
{
(*ptr)[i][j][k] = 'c';
}
}
}
}
int main(void)
{
char ***tp;
tp = malloc( 3 * sizeof(char **) );
for (int i = 0; i < 3; i++)
{
tp[i] = malloc( 4 * sizeof(sizeof(char *)) );
for (int j = 0; j < 4; j++)
{
tp[i][j] = malloc( 5 * sizeof(char) );
}
}
strcpy(tp[0][0], "lap0");
strcpy(tp[0][1], "top0");
strcpy(tp[0][2], "xxx0");
strcpy(tp[0][3], "1230");
strcpy(tp[1][0], "gap0");
strcpy(tp[1][1], "pop0");
strcpy(tp[1][2], "yyy0");
strcpy(tp[1][3], "4560");
strcpy(tp[2][0], "sap0");
strcpy(tp[2][1], "gop0");
strcpy(tp[2][2], "zzz0");
strcpy(tp[2][3], "7890");
fun(&tp);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
free( tp[i][j] );
}
free( tp[i] );
}
free(tp);
return 0;
}
* Output is as below
.. code-block:: c
(*ptr)[0][0] = lap0
(*ptr)[0][1] = top0
(*ptr)[0][2] = xxx0
(*ptr)[0][3] = 1230
(*ptr)[1][0] = gap0
(*ptr)[1][1] = pop0
(*ptr)[1][2] = yyy0
(*ptr)[1][3] = 4560
(*ptr)[2][0] = sap0
(*ptr)[2][1] = gop0
(*ptr)[2][2] = zzz0
(*ptr)[2][3] = 7890
(*ptr)[0][0][0] = l
(*ptr)[0][0][1] = a
(*ptr)[0][0][2] = p
(*ptr)[0][0][3] = 0
(*ptr)[0][1][0] = t
(*ptr)[0][1][1] = o
(*ptr)[0][1][2] = p
(*ptr)[0][1][3] = 0
(*ptr)[0][2][0] = x
(*ptr)[0][2][1] = x
(*ptr)[0][2][2] = x
(*ptr)[0][2][3] = 0
(*ptr)[0][3][0] = 1
(*ptr)[0][3][1] = 2
(*ptr)[0][3][2] = 3
(*ptr)[0][3][3] = 0
(*ptr)[1][0][0] = g
(*ptr)[1][0][1] = a
(*ptr)[1][0][2] = p
(*ptr)[1][0][3] = 0
(*ptr)[1][1][0] = p
(*ptr)[1][1][1] = o
(*ptr)[1][1][2] = p
(*ptr)[1][1][3] = 0
(*ptr)[1][2][0] = y
(*ptr)[1][2][1] = y
(*ptr)[1][2][2] = y
(*ptr)[1][2][3] = 0
(*ptr)[1][3][0] = 4
(*ptr)[1][3][1] = 5
(*ptr)[1][3][2] = 6
(*ptr)[1][3][3] = 0
(*ptr)[2][0][0] = s
(*ptr)[2][0][1] = a
(*ptr)[2][0][2] = p
(*ptr)[2][0][3] = 0
(*ptr)[2][1][0] = g
(*ptr)[2][1][1] = o
(*ptr)[2][1][2] = p
(*ptr)[2][1][3] = 0
(*ptr)[2][2][0] = z
(*ptr)[2][2][1] = z
(*ptr)[2][2][2] = z
(*ptr)[2][2][3] = 0
(*ptr)[2][3][0] = 7
(*ptr)[2][3][1] = 8
(*ptr)[2][3][2] = 9
(*ptr)[2][3][3] = 0
.. 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`