Pointer to a Single Dimension Array of Characters
==================================================

In this section, you are going to learn

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

		How to define and use Pointer to Single Dimension Arrays ?

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

		Pointer to an Array

		* :ref:`Syntax of Pointer to an array <ptr_to_array_char_sp_ex_1>`
		* :ref:`Pointer to an array increments by size of the array <ptr_to_array_char_sp_ex_2>`
		* :ref:`Pointer to an array : Passed as function arguement : Call by Value <ptr_to_array_char_sp_ex_3>`
		* :ref:`Pointer to an array : Passed as function arguement : Call by Reference <ptr_to_array_char_sp_ex_8>`
		* :ref:`Method 1 : Pointer to an array : How to print contents of single dimension array ? <ptr_to_array_char_sp_ex_4>`
		* :ref:`Method 2 : Pointer to an array : How to print contents of single dimension array ? <ptr_to_array_char_sp_ex_5>`
        	* :ref:`Pointer to an array : Pointing to Single dimension array inside a Double dimension array <ptr_to_array_char_sp_ex_6>`
		* :ref:`Pointer to an array : Pointing to a block of memory in heap <ptr_to_array_char_sp_ex_7>`

.. _ptr_to_array_char_sp_ex_1:

.. tab-set::

        .. tab-item:: Syntax of Pointer to an array

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

			type ( \*ptr ) [ size_of_array ];

		An example is as below

		.. code-block:: c

		        char a[10] = "Laptop";

		        char (*ptr)[10];

		        ptr = &a;


.. _ptr_to_array_char_sp_ex_2:


.. tab-set::

        .. tab-item:: Pointer to an array increments by size of the array

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

			Pointer to an Array when incremented, increments by size of the array to which it is pointing to !

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

			Pointer to an Array when decremented, decrements by size of the array to which it is pointing to !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[10] = "Laptop";

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        char (*ptr)[10];

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

		.. code-block:: c

		        ptr = &a;

		* Step 4 : Check pointer arithmetic

		.. code-block:: c

		        printf("Before Increment : ptr = %lx\n", (unsigned long int) ptr);

		        ptr++;

		        printf("After Increment : ptr = %lx\n", (unsigned long int) ptr);

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
			        char a[10] = "Laptop";

			        char (*ptr)[10];

			        ptr = &a;

			        printf("Before Increment : ptr = %lx\n", (unsigned long int) ptr);

			        ptr++;

			        printf("After Increment : ptr = %lx\n", (unsigned long int) ptr);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			Before Increment : ptr = 7ffde08b01ee
			After Increment  : ptr = 7ffde08b01f8

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

			Observe that difference is 10 !

		
.. _ptr_to_array_char_sp_ex_3:


.. tab-set::

        .. tab-item:: Pointer to an array : Passed as function arguement : Call by Value

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

			When Pointer to an Array is passed as argument, Prototype of function should match the type properly !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        char (*ptr)[7];

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

		.. code-block:: c

		        ptr = &a;

		* Step 4 : Pass ``ptr`` as argument to function ``fun``

		.. code-block:: c

		        fun(ptr);

		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun( char (*p)[] )
			{
			}

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun( char (*p)[] )
			{
			}

			int main(void)
			{
			        char a[7] = "Laptop";

			        char (*ptr)[7];

			        ptr = &a;

			        fun(ptr);

			        return 0;
			}

.. _ptr_to_array_char_sp_ex_8:


.. tab-set::

        .. tab-item:: Pointer to an array : Passed as function arguement : Call by Reference

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

			When Pointer to an Array is passed as argument by call by reference, Prototype of function should match the type properly !

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

			Let us see how it is done. See below

		* Step 1 : Define a Double dimension array

		.. code-block:: c

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

		* Step 2 : Define a pointer to an array

		.. code-block:: c

			char (*ptr)[10];

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

		.. code-block:: c

		        ptr = &a[0];

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

		.. code-block:: c

		        fun(&ptr);

		* Step 5 : Define function ``fun``

		.. code-block:: c

			void fun(char (**p)[10])
			{
			        for (int i = 0; i < 3; i++) {
			                printf("%s\n", (*p)[i]);
			        }
			}

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

			This is easy to understand ! Let us derive the rules

			* Rule 1 : Base rule in ``main``

			.. code-block:: c

				ptr = &a[0];

			* Rule 2 : Base rule in ``fun``

			.. code-block:: c

				p = &ptr

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

			.. code-block:: c

				*p = ptr

			* Rule 3 : Replace ``ptr`` referring to Rule 1 

			.. code-block:: c

				*p = &a[0]

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

			.. code-block:: c

				**p = a[0]

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

			.. code-block:: c

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

			* Rule 6 : Extending Rule 5

			.. code-block:: c

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

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun(char (**p)[10])
			{       
			        for (int i = 0; i < 3; i++) {
			                printf("%s\n", (*p)[i]);
			        }
			}

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

			        char (*ptr)[10];

			        ptr = &a[0];

			        fun(&ptr);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			Laptop
			Keyboard
			Mouse

.. _ptr_to_array_char_sp_ex_4:


.. tab-set::

        .. tab-item:: Method 1 : Pointer to an array : How to print contents of single dimension array ? 

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

			We can use pointer to an array directly inorder to print the contents of array to which it is pointing to !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Define a pointer to an array

		.. code-block:: c

		        char (*ptr)[7];

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

		.. code-block:: c

		        ptr = &a;

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

			We can derive other rules from this base rule !

			* Rule 1 : Base rule
			
			.. code-block:: c
		        
				ptr = &a;

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

			.. code-block:: c

				*ptr = a

			* Rule 3 : ``a`` is also equals to ``&a[0]``

			.. code-block:: c

				*ptr = &a[0]

			* Rule 4 : ``*ptr`` is equal to ``ptr[0]``

			.. code-block:: c

				ptr[0] = &a[0]

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

			.. code-block:: c

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

			* Rule 6 : ``(*ptr)[0]`` is equal to ``ptr[0][0]``

			.. code-block:: c

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

			* Rule 7 : Extending Rule 5

			.. code-block:: c

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

		* Step 4 : Access individual characters using ``(*ptr)[i]``

		.. code-block:: c

		        for (int i = 0; i < 7; i++) {
		                printf("%c", (*ptr)[i]);
       			}

		* Step 5 : Access full string using ``*ptr`` to print using ``%s``

		.. code-block:: c

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

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			int main(void)
			{
			        char a[7] = "Laptop";

			        char (*ptr)[7];

			        ptr = &a;

			        // Print individual characters
			        for (int i = 0; i < 7; i++) {
			                printf("%c", (*ptr)[i]);
        			}

			        printf("\n");

			        // Print string at once
			        printf("str = %s\n", *ptr);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			Laptop
			str = Laptop

.. _ptr_to_array_char_sp_ex_5:

.. tab-set::

        .. tab-item:: Method 2 : Pointer to an array : How to print contents of single dimension array ? 

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

			We can use pointer to an array directly inorder to print the contents of array to which it is pointing to !

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

			Let us see how it is done. See below

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Pass address of array ``a`` as an argument to function ``fun``

		.. code-block:: c

		        fun(&a, sizeof(a));

		* Step 3 : Define function ``fun`` 

		.. code-block:: c

			void fun(char (*p)[], int size)
			{
			}

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

			Note the function definition !

			* Since first argument is passed as address of array ``a``, prototype must have pointer to an array in first parameter

		* Step 4 : Let us write the code to access individual characters of single dimension array inside function ``fun``

		.. code-block:: c

			void fun(char (*p)[7], int size)
			{
			        for (int i = 0; i < size; i++) {
			                printf("%c\n", (*p)[i]);
			        }

			        for (int i = 0; i < size; i++) {
			                printf("%c\n", p[0][i]);
			        }
			}

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

			This is easy to understand ! Let us derive the rules

			* Rule 1 : Base rule

			.. code-block:: c

				p = &a

			Where,

				* LHS ``p`` is a variable on stack of function fun ``fun``
				* RHS ``&a`` is actual argument passed to function ``fun``

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

			.. code-block:: c

				*p = a

			* Rule 3 : a is also equals to &a[0]

			.. code-block:: c

				*p = &a[0]

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

			.. code-block:: c

				**p = a[0]

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

			.. code-block:: c

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

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

			.. code-block:: c

				p[0][0] = a[0]

			* Rule 7 : Extending Rule 5

			.. code-block:: c

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

			* Rule 8 : Extending Rule 5

			.. code-block:: c

				p[0][i] = a[i]

		* Step 5 : Let us write the code to access full string at once inside function ``fun``

		.. code-block:: c

			void fun(char (*p)[], int size)
			{
			        char *sp;

			        sp = *p;

			        printf("sp = %s\n", sp);
			        printf("*p = %s\n", *p);
			}

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

			This is easy to understand ! Let us derive the rules

			* Rule 1 : Base rule

			.. code-block:: c

				p = &a

			Where,

				* LHS ``p`` is a variable on stack of function fun ``fun``
				* RHS ``&a`` is actual argument passed to function ``fun``

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

			.. code-block:: c

				*p = a

			* Rule 3 : a is also equals to &a[0]

			.. code-block:: c

				*p = &a[0]

			* Rule 4 : From Rule 3, it is clear that ``*p`` is a pointer to an integer. Hence we can assign ``*p`` to ``char *sp``

			.. code-block:: c

				sp = *p

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

			We can now use ``sp``, ``*p`` in printf with ``%s`` !

		* See full program below

		.. code-block:: c

			#include <stdio.h>

			void fun(char (*p)[], int size)
			{
			        char *sp;

			        sp = *p;

			        for (int i = 0; i < size; i++) {
			                printf("%c\n", sp[i]);
			        }

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

			        for (int i = 0; i < size; i++) {
			                printf("%c\n", p[0][i]);
			        }

			        printf("sp = %s\n", sp);
			        printf("*p = %s\n", *p);
			}

			int main(void)
			{
			        char a[7] = "Laptop";

			        fun(&a, sizeof(a));

			        return 0;
			}

.. _ptr_to_array_char_sp_ex_6:

.. tab-set::

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

		* Step 1 : Define a double dimension array of characters

		.. code-block:: c

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

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

		.. code-block:: c

			char (*ptr)[10];

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

		.. code-block:: c

			ptr = &a[0];

		* Step 4 : Print the strings using ``%s`` : Method 1

		.. code-block:: c

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

		* Step 5 : Print the strings using ``%s`` : Method 2

		.. code-block:: c

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

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

			This is easy to understand ! Let us derive the rules

			* Rule 1 : Base rule

			.. code-block:: c

				ptr = &a[0];

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

			.. code-block:: c

				*ptr = a[0];

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

			.. code-block:: c

				ptr[0] = a[0];

			* Rule 4 : Extending Rule 3

			.. code-block:: c

				ptr[i] = a[i];

		* See full program below

		.. code-block:: c

			#include <stdio.h>

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

			        char (*ptr)[10];

			        ptr = &a[0];

			        //Method 1 : print string
			        for (int i = 0; i < 3; i++) {
			                printf("%s\n", ptr[i]);
			        }

			        //Method 2 : print string
			        for (int i = 0; i < 3; i++) {
			                printf("%s\n", (char *)ptr);
			                ptr++;
			        }

			        return 0;
			}

.. _ptr_to_array_char_sp_ex_7:

.. tab-set::

        .. tab-item:: Pointer to an array : Pointing to a block of memory in heap

		* Step 1 : Allocate a block of memory in Heap

		.. code-block:: c

		        char *a;

		        a = malloc(30 * sizeof(char));

		* Step 2 : Assign User Data in Heap memory

		.. code-block:: c

		        memset(a, 0, 30);
		        memcpy(a, "Laptop", 10);
		        memcpy(a + 10, "Keyboard", 10);
		        memcpy(a + 20, "Mouse", 10);

		* Step 3 : Let ``ptr`` point to block of memory in Heap

		.. code-block:: c

		        char (*ptr)[10];

		        ptr = (char (*)[10]) a;

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

			Note that typecasting done !

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

			Key is to remember that, ``ptr`` should point to block of continuous memory for it to access User data properly !

		* Step 4 : Method 1 : Access the memory block in Heap using ``ptr``

		.. code-block:: c

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

		* Step 5 : Method 2 : Access the memory block in Heap using ``ptr``

		.. code-block:: c

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

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

			Remember after Step 5, ``ptr`` is NOT pointing to start of Heap !

		* Step 6 : Free Heap memory after use

		.. code-block:: c

		        free(a);

		* See full program below

		.. code-block:: c

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

			int main(void)
			{
			        char *a;

			        char (*ptr)[10];

			        a = malloc(30 * sizeof(char));

			        memset(a, 0, 30);
			        memcpy(a, "Laptop", 10);
			        memcpy(a + 10, "Keyboard", 10);
			        memcpy(a + 20, "Mouse", 10);

			        ptr = (char (*)[10])a;

			        //Method 1 : print string
			        for (int i = 0; i < 3; i++) {
			                printf("%s\n", ptr[i]);
			        }

			        //Method 2 : print string
			        for (int i = 0; i < 3; i++) {
			                printf("%s\n", (char *)ptr);
			                ptr++;
			        }

			        free(a);

			        return 0;
			}

.. card:: See Also

        * Current Module

                * :doc:`../ptr_to_array`

        * Previous Module

                * :doc:`../../array_of_ptr/array_of_ptr`

        * Next Module

                * :doc:`../../function_ptr/function_ptr`

        * Other Modules

                * :doc:`../../variable_and_ptr/variable_and_ptr`
                * :doc:`../../array_n_ptrs/array_n_ptrs`
                * :doc:`../../malloc_ptr/malloc_ptr`
                * :doc:`../../typecasting_n_ptr/typecasting_n_ptr`
                * :doc:`../../funcs_n_ptrs/funcs_n_ptrs`
                * :doc:`../../memcpy_ptr/memcpy_ptr`
                * :doc:`../../const_ptr/const_ptr`
                * :doc:`../../void_ptr/void_ptr`
                * :doc:`../../pre_incr_ptr/pre_incr_ptr`
                * :doc:`../../post_incr_ptr/post_incr_ptr`
                * :doc:`../../pre_decr_ptr/pre_decr_ptr`
                * :doc:`../../post_decr_ptr/post_decr_ptr`