post decrement char single pointer
====================================

In this section, you are going to learn

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

		How to iterate character strings using ptr-- ?

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

		What is the meaning of ``ptr--``, ``*ptr--``, ``*(ptr--)``, ``*(ptr)--``, ``(*ptr)--`` ?

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

		What is the meaning of ``c = ptr--``, ``c = *ptr--``, ``c = *(ptr--)``, ``c = *(ptr)--``, ``c = (*ptr)--`` ?

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

		What is the difference between ``ptr--``, ``*ptr--``, ``*(ptr--)``, ``*(ptr)--``, ``(*ptr)--`` ?

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

		What is the difference between ``c = ptr--``, ``c = *ptr--``, ``c = *(ptr--)``, ``c = *(ptr)--``, ``c = (*ptr)--`` ?

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

		Topics of Post Decrement

		* :ref:`Basics of Post Decrement <post_decr_char_sp_mt_1>`
		* :ref:`Meaning of expressions <post_decr_char_sp_mt_2>`
		* :ref:`Summary of expressions <post_decr_char_sp_mt_3>`
		* :ref:`Post Decrement : char pointer inside structure <post_decr_char_sp_mt_4>`
		* :ref:`Post Decrement : Function Call <post_decr_char_sp_mt_5>`

.. _post_decr_char_sp_mt_1:

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

		Basics of Post Decrement

		* :ref:`ptr - - Basic Usage <post_decr_char_sp_ex_1>`
		* :ref:`ptr - - : Iterate and print characters of a string : Method 1 <post_decr_char_sp_ex_2>`
		* :ref:`ptr - - : Iterate and print characters of a string : Method 2 <post_decr_char_sp_ex_3>`
		* :ref:`ptr - - : Iterate and print characters of a string : Method 3 <post_decr_char_sp_ex_4>`
		* :ref:`ptr - - : Iterate and print characters of a string : Method 4 <post_decr_char_sp_ex_5>`


.. _post_decr_char_sp_ex_1:

.. tab-set::

        .. tab-item:: Example 1 : ``ptr--`` : Basic Usage

		* Step 1 : Define a Single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Point ``ptr`` to Single dimension array at last printable character

		.. code-block:: c

		        char *ptr;

		        ptr = a + strlen(a) - 1;

		* Step 3 : Decrement ``ptr``

		.. code-block:: c

		        ptr--;

		* Step 4 : Print ``*ptr``

		.. code-block:: c

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

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        ptr--;

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

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			*ptr = o

.. _post_decr_char_sp_ex_2:

.. tab-set::

        .. tab-item:: Example 2 : ``ptr--`` : Iterate and print characters of a string : Method 1

		* Step 1 : Define a Single Dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Point ``ptr`` to Single dimension array

		.. code-block:: c

		        char *ptr;

		        ptr = a + strlen(a) - 1;

		* Step 3 : Print string by iterating through all characters using ``ptr--``

		.. code-block:: c

		        for (int i = 0; i < strlen(a); i++)
		        {
		                printf("*ptr = %c\n", *ptr);
		                ptr--;
		        }

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        for (int i = 0; i < strlen(a); i++)
			        {
			                printf("*ptr = %c\n", *ptr);
			                ptr--;
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			*ptr = p
			*ptr = o
			*ptr = t
			*ptr = p
			*ptr = a
			*ptr = L

.. _post_decr_char_sp_ex_3:

.. tab-set::

        .. tab-item:: Example 3 : ``ptr--`` : Iterate and print characters of a string : Method 2

		* Step 1 : Define a Single Dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Point ``ptr`` to Single dimension array

		.. code-block:: c

		        char *ptr;

		        ptr = a + strlen(a) - 1;

		* Step 3 : Print string by iterating through all characters using ``ptr--``

		.. code-block:: c

		        while (ptr >= a)
		        {
		                printf("*ptr = %c\n", *ptr);
		                ptr--;
		        }

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {
			                printf("*ptr = %c\n", *ptr);
			                ptr--;
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			*ptr = p
			*ptr = o
			*ptr = t
			*ptr = p
			*ptr = a
			*ptr = L

.. _post_decr_char_sp_ex_4:

.. tab-set::

        .. tab-item:: Example 4 : ``ptr--`` : Iterate and print characters of a string : Method 3

		* Step 1 : Define a Single Dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Point ``ptr`` to Single dimension array

		.. code-block:: c

		        char *ptr;

		        ptr = a + strlen(a) - 1;

		* Step 3 : Print string by iterating through all characters using ``ptr--``

		.. code-block:: c

		        while (ptr >= a)
		        {
		                char c;

		                c = *ptr--;

		                printf("*ptr = %c\n", c); 
		        }

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {
			                char c;

			                c = *ptr--;

			                printf("*ptr = %c\n", c); 
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			*ptr = p
			*ptr = o
			*ptr = t
			*ptr = p
			*ptr = a
			*ptr = L

.. _post_decr_char_sp_ex_5:

.. tab-set::

        .. tab-item:: Example 5 : ``ptr--`` : Iterate and print characters of a string : Method 4

		* Step 1 : Define a Single Dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Point ``ptr`` to Single dimension array

		.. code-block:: c

		        char *ptr;

		        ptr = a + strlen(a) - 1;

		* Step 3 : Print string by iterating through all characters using ``ptr--``

		.. code-block:: c

		        while (ptr >= a)
		        {
		                printf("*ptr = %c\n", *ptr--);
		        }

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {
			                printf("*ptr = %c\n", *ptr--);
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			*ptr = p
			*ptr = o
			*ptr = t
			*ptr = p
			*ptr = a
			*ptr = L

.. _post_decr_char_sp_mt_2:


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

		Meaning of expressions

		* :ref:`Meaning of ptr - - and c = ptr - - <post_decr_char_sp_ex_6>`
		* :ref:`Meaning of *(ptr - -) and c = *(ptr - -) <post_decr_char_sp_ex_7>`
		* :ref:`Meaning of *ptr - - and c = *ptr - - <post_decr_char_sp_ex_10>`
		* :ref:`Meaning of *(ptr) - - and c = *(ptr) - - <post_decr_char_sp_ex_8>`
		* :ref:`Meaning of (*ptr) - - and c = (*ptr) - - <post_decr_char_sp_ex_9>`


.. _post_decr_char_sp_ex_6:

.. tab-set::

        .. tab-item:: Meaning of ``ptr--`` and ``c = ptr--``

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

			* Consider statement 

			.. code-block:: c

				p = ptr--;

			* There are two steps in this statement

				* Current value of ``ptr`` is assigned to ``p``

				* ``ptr`` is decremented

			* We now derived a rule

				* First Assign, then decrement

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Define a single pointer and point to array

		.. code-block:: c

			char *ptr;

        		ptr = a + strlen(a) - 1;


		OR

		.. code-block:: c

			char *ptr;

        		ptr = &a[0] + strlen(a) - 1;

		* Step 3 : Iterate and print the string

		.. code-block:: c

		        while (ptr >= a)
		        {
		                char *p;

		                p = ptr--;
		                printf("*p = %c\n", *p);
		        }

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

			Can you guess what is happening ?


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

			* Let us Recall 

			.. code-block:: c

				p = ptr--;

			* There are two steps in this statement

				* Current value of ``ptr`` is assigned to ``p``

				* ``ptr`` is decremented

			* We now derived a rule

				* First Assign, then decrement

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {
			                char *p;

			                p = ptr--;
			                printf("*p = %c\n", *p);
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			*ptr = p
			*ptr = o
			*ptr = t
			*ptr = p
			*ptr = a
			*ptr = L

.. _post_decr_char_sp_ex_7:

.. tab-set::

        .. tab-item:: Meaning of ``*(ptr--)`` and ``c = *(ptr--)``

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

			* Consider statement 

			.. code-block:: c

				c = *(ptr--);

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is decremented

				* ``*ptr`` is NOT decremented

			* We now derived a rule

				* First Assign, then decrement

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Define a single pointer and point to array

		.. code-block:: c

			char *ptr;

			ptr = a + strlen(a) - 1;

		OR

		.. code-block:: c

			char *ptr;

			ptr = &a[0] + strlen(a) - 1;

		* Step 3 : Iterate and print the string

		.. code-block:: c

		        while (ptr >= a)
		        {   
		                char c;  

		                c = *(ptr--);
		                printf("c = %c\n", c); 
		        }   

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

			Can you guess what is happening ?


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

			* Let us Recall

			.. code-block:: c

				c = *(ptr--);

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is decremented

				* ``*ptr`` is NOT decremented

			* We now derived a rule

				* First Assign, then decrement

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {   
			                char c;  

			                c = *(ptr--);
			                printf("c = %c\n", c); 
			        }   

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_10:

.. tab-set::

        .. tab-item:: Meaning of ``*ptr--`` and c = ``*ptr--``

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

			* :ref:`Same as *(ptr - -) and c = *(ptr - -) <post_decr_char_sp_ex_7>`

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

			* Consider statement 

			.. code-block:: c

				c = *ptr--;

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is decremented

				* ``*ptr`` is NOT decremented

			* We now derived a rule

				* First Assign, then decrement

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Define a single pointer and point to array

		.. code-block:: c

			char *ptr;

			ptr = a + strlen(a) - 1;

		OR

		.. code-block:: c

			char *ptr;

			ptr = &a[0] + strlen(a) - 1;

		* Step 3 : Iterate and print the string

		.. code-block:: c

		        while (ptr >= a)
		        {   
		                char c;  

		                c = *ptr--;
		                printf("c = %c\n", c); 
		        } 

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

			Can you guess what is happening ?


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

			* Let us Recall

			.. code-block:: c

				c = *ptr--;

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is decremented

				* ``*ptr`` is NOT decremented

			* We now derived a rule

				* First Assign, then decrement

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {   
			                char c;  

			                c = *ptr--;
			                printf("c = %c\n", c); 
			        } 

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_8:

.. tab-set::

        .. tab-item:: Meaning of ``*(ptr)--`` and ``c = *(ptr)--``

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

			* :ref:`Same as *(ptr - -) and c = *(ptr - -) <post_decr_char_sp_ex_7>`

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

			* Consider statement 

			.. code-block:: c

				c = *(ptr)--;

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is decremented

				* ``*ptr`` is NOT decremented

			* We now derived a rule

				* First Assign, then decrement

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Define a single pointer and point to array

		.. code-block:: c

			char *ptr;

			ptr = a + strlen(a) - 1;

		OR

		.. code-block:: c

			char *ptr;

			ptr = &a[0] + strlen(a) - 1;

		* Step 3 : Iterate and print the string

		.. code-block:: c

		        while (ptr >= a)
		        {   
		                char c;  

		                c = *(ptr)--;
		                printf("c = %c\n", c); 
		        }   

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

			Can you guess what is happening ?


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

			* Let us Recall

			.. code-block:: c

				c = *(ptr)--;

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is decremented

				* ``*ptr`` is NOT decremented

			* We now derived a rule

				* First Assign, then decrement

		* See full program below

		.. code-block:: c

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

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

			        char *ptr;

			        ptr = a + strlen(a) - 1;

			        while (ptr >= a)
			        {   
			                char c;  

			                c = *(ptr)--;
			                printf("c = %c\n", c); 
			        }   

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_9:

.. tab-set::

        .. tab-item:: Meaning of ``(*ptr)--`` and ``c = (*ptr)--``

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

			* Consider statement 

			.. code-block:: c

				c = (*ptr)--;

			* There are two steps in this statement

				* Current value of ``*ptr`` is assigned to ``c``

				* ``ptr`` is NOT decremented

				* ``*ptr`` is decremented

			* We now derived a rule

				* First Assign, then decrement


.. _post_decr_char_sp_mt_3:


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

		Summary of expressions

		* :ref:`Summary of Post Decrement expressions <post_decr_char_sp_ex_summary>`


.. _post_decr_char_sp_ex_summary: 


.. tab-set::

        .. tab-item:: Summary of Post Decrement expressions

		===================================== =========================================================================
		Expression                            Explanation
		===================================== =========================================================================
		c = ptr--			      * Assign ``ptr`` to ``c``
						      * Decrement ``ptr``
		c = \*(ptr--)		              * Assign ``*ptr`` to ``c``
						      * Decrement ``ptr``
						      * DO NOT decrement ``*ptr``
		c = \*ptr--		              * Assign ``*ptr`` to ``c``
						      * Decrement ``ptr``
						      * DO NOT decrement ``*ptr``
		c = \*(ptr)--			      * Assign ``*ptr`` to ``c``
						      * Decrement ``ptr``
						      * DO NOT decrement ``*ptr``
		c = (\*ptr)--			      * Assign ``*ptr`` to ``c``
						      * DO NOT decrement ``ptr``
						      * Decrement ``*ptr``
		===================================== =========================================================================


.. _post_decr_char_sp_mt_4:

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

		Post Decrement : char pointer inside structure

		* :ref:`Char pointer accessed using Structure Object <post_decr_char_sp_ex_struct_ex_1>`
		* :ref:`Char pointer accessed using Structure Single Pointer <post_decr_char_sp_ex_struct_ex_2>`
		* :ref:`Char pointer accessed using Structure Double Pointer <post_decr_char_sp_ex_struct_ex_3>`
		* :ref:`Char pointer accessed using Structure Triple Pointer <post_decr_char_sp_ex_struct_ex_4>`
		* :ref:`Char pointer accessed using Nested Structure Object <post_decr_char_sp_ex_struct_ex_5>`
		* :ref:`Char pointer accessed using Nested Structure Single Pointer <post_decr_char_sp_ex_struct_ex_6>`
		* :ref:`Char pointer accessed using Nested Structure 2 level Pointers <post_decr_char_sp_ex_struct_ex_7>`


.. _post_decr_char_sp_ex_struct_ex_1:

.. tab-set::

        .. tab-item:: Char pointer accessed using Structure Object

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Create a structure object

		.. code-block:: c

			struct ABC abc;

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

		        abc.ptr =  a + strlen(a) - 1;;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while (abc.ptr >= a)
		        {
		                char c;

		                c = *abc.ptr--;
		                printf("c = %c\n", c);
		        }

		* See full program below

		.. code-block:: c

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

			struct ABC
			{
			        char *ptr;
			};

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

			        struct ABC abc;

			        abc.ptr =  a + strlen(a) - 1;;

			        while (abc.ptr >= a)
			        {
			                char c;

			                c = *abc.ptr--;
			                printf("c = %c\n", c);
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_struct_ex_2:

.. tab-set::

        .. tab-item:: Char pointer accessed using Structure Single Pointer

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Allocate memory for structure pointers

		.. code-block:: c

			struct ABC *sp;

			sp = malloc(sizeof(struct ABC));

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

		        sp->ptr =  a + strlen(a) - 1;;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while (sp->ptr >= a)
		        {
		                char c;

		                c = *sp->ptr--;
		                printf("c = %c\n", c);
		        }

		* Step 5 : Free memory after use

		.. code-block:: c

		        free(sp);

		* See full program below

		.. code-block:: c

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

			struct ABC
			{
			        char *ptr;
			};

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

			        struct ABC *sp;

			        sp = malloc(sizeof(struct ABC));

			        sp->ptr =  a + strlen(a) - 1;;

			        while (sp->ptr >= a)
			        {
			                char c;

			                c = *sp->ptr--;
			                printf("c = %c\n", c);
			        }

			        free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_struct_ex_3:

.. tab-set::

        .. tab-item:: Char pointer accessed using Structure Double Pointer

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Allocate memory for structure pointers

		.. code-block:: c

		        struct ABC **dp;

		        dp = malloc(sizeof(struct ABC *));
		        *dp = malloc(sizeof(struct ABC )); 

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

		        (*dp)->ptr =  a + strlen(a) - 1;;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while ((*dp)->ptr >= a)
		        {
		                char c;

		                c = *(*dp)->ptr--;
		                printf("c = %c\n", c);
		        }

		* Step 5 : Free memory after use

		.. code-block:: c

		        free(*dp);
		        free(dp);

		* See full program below

		.. code-block:: c

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

			struct ABC
			{
			        char *ptr;
			};

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

			        struct ABC **dp;

			        dp = malloc(sizeof(struct ABC *));
			        *dp = malloc(sizeof(struct ABC ));

			        (*dp)->ptr =  a + strlen(a) - 1;;

			        while ((*dp)->ptr >= a)
			        {
			                char c;

			                c = *(*dp)->ptr--;
			                printf("c = %c\n", c);
			        }

			        free(*dp);
			        free(dp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_struct_ex_4:

.. tab-set::

        .. tab-item:: Char pointer accessed using Structure Triple Pointer


		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Allocate memory for structure pointers

		.. code-block:: c

		        struct ABC ***dp;

		        dp = malloc(sizeof(struct ABC **));
		        *dp = malloc(sizeof(struct ABC *));
		        **dp = malloc(sizeof(struct ABC )); 

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

		        (**dp)->ptr =  a + strlen(a) - 1;;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while ((**dp)->ptr >= a)
		        {
		                char c;

		                c = *(**dp)->ptr--;
		                printf("c = %c\n", c);
		        }

		* Step 5 : Free memory after use

		.. code-block:: c

		        free(**dp);
		        free(*dp);
		        free(dp);

		* See full program below

		.. code-block:: c

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

			struct ABC
			{
			        char *ptr;
			};

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

			        struct ABC ***dp;

			        dp = malloc(sizeof(struct ABC **));
			        *dp = malloc(sizeof(struct ABC *));
			        **dp = malloc(sizeof(struct ABC ));

			        (**dp)->ptr =  a + strlen(a) - 1;

			        while ((**dp)->ptr >= a)
			        {
			                char c;

			                c = *(**dp)->ptr--;
			                printf("c = %c\n", c);
			        }

			        free(**dp);
			        free(*dp);
			        free(dp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_struct_ex_5:

.. tab-set::

        .. tab-item:: Char pointer accessed using Nested Structure Object


		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Create a structure object

		.. code-block:: c

		        struct ABC abc;

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

			abc.pqr.ptr =  a + strlen(a) - 1;;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while (abc.pqr.ptr >= a)
		        {
		                char c;

		                c = *abc.pqr.ptr--;
		                printf("c = %c\n", c);
       			}

		* See full program below

		.. code-block:: c

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

			struct PQR
			{
			        char *ptr;
			};

			struct ABC
			{
			        struct PQR pqr;
			};

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

			        struct ABC abc;

			        abc.pqr.ptr =  a + strlen(a) - 1;;

			        while (abc.pqr.ptr >= a)
			        {
			                char c;

			                c = *abc.pqr.ptr--;
			                printf("c = %c\n", c);
        			}

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_struct_ex_6:

.. tab-set::

        .. tab-item:: Char pointer accessed using Nested Structure Single Pointer

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Allocate memory for structure pointers

		.. code-block:: c

		        struct ABC *sp;

		        sp = malloc(sizeof(struct ABC));

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

		        sp->pqr.ptr =  a + strlen(a) - 1;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while (sp->pqr.ptr >= a)
		        {
		                char c;

		                c = *sp->pqr.ptr--;
		                printf("c = %c\n", c);
		        }

		* Step 5 : Free memory after use

		.. code-block:: c

		        free(sp);

		* See full program below

		.. code-block:: c

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

			struct PQR
			{
			        char *ptr;
			};

			struct ABC
			{
			        struct PQR pqr;
			};

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

			        struct ABC *sp;

			        sp = malloc(sizeof(struct ABC));

			        sp->pqr.ptr =  a + strlen(a) - 1;;

			        while (sp->pqr.ptr >= a)
			        {
			                char c;

			                c = *sp->pqr.ptr--;
			                printf("c = %c\n", c);
			        }

			        free(sp);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_ex_struct_ex_7:

.. tab-set::

        .. tab-item:: Char pointer accessed using Nested Structure 2 level Pointers 

		* Step 1 : Define a single dimension array

		.. code-block:: c

		        char a[7] = "Laptop";

		* Step 2 : Allocate memory for structure pointers

		.. code-block:: c

		        struct ABC *abc;

		        abc = malloc(sizeof(struct ABC));
		        abc->pqr = malloc(sizeof(struct PQR));

		* Step 3 : Point single character pointer to single dimension array

		.. code-block:: c

		        abc->pqr->ptr =  a + strlen(a) - 1;

		* Step 4 : Iterate through single dimension array using pointer

		.. code-block:: c

		        while (abc->pqr->ptr >= a)
		        {
		                char c;

		                c = *abc->pqr->ptr--;
		                printf("c = %c\n", c);
		        }

		* Step 5 : Free memory after use

		.. code-block:: c

		        free(abc->pqr);
		        free(abc);

		* See full program below

		.. code-block:: c

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

			struct PQR
			{
			        char *ptr;
			};

			struct ABC
			{
			        struct PQR *pqr;
			};

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

			        struct ABC *abc;

			        abc = malloc(sizeof(struct ABC));
			        abc->pqr = malloc(sizeof(struct PQR));

			        abc->pqr->ptr =  a + strlen(a) - 1;

			        while (abc->pqr->ptr >= a)
			        {
			                char c;

			                c = *abc->pqr->ptr--;
			                printf("c = %c\n", c);
			        }

			        free(abc->pqr);
			        free(abc);

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L

.. _post_decr_char_sp_mt_5:


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

		Post Decrement : Function Call

		* :ref:`*ptr - - : Function Call <post_decr_char_sp_call_by_value_ex_1>`
		* :ref:`ptr - - : Function Call <post_decr_char_sp_call_by_value_ex_2>`


.. _post_decr_char_sp_call_by_value_ex_1:

.. tab-set::

        .. tab-item:: \*ptr-- : Function Call

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Define a single pointer and point to array

		.. code-block:: c

			char *ptr;

			ptr =  a + strlen(a) - 1;

		* Step 3 : Iterate array using ptr-- and Pass by Value

		.. code-block:: c

		        while (ptr >= a)
		        {
		                fun(*ptr--);
		        }

		* Step 4 : Define a function ``fun`` which receives a character from caller

		.. code-block:: c

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

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

			Let us Recall,

			* In case of ``*ptr--``

				* Current value of ``*ptr`` is first assigned, then ``ptr`` decremented
			
			* Hence, in this case

				* Current value of ``*ptr`` is first passed to function ``fun``, then ``ptr`` decremented

		* See full program below

		.. code-block:: c

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

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

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

			        char *ptr;

			        ptr =  a + strlen(a) - 1;

			        while (ptr >= a)
			        {
			                fun(*ptr--);
			        }

			        return 0;
			}

		* Output is as below

		.. code-block:: c

			c = p
			c = o
			c = t
			c = p
			c = a
			c = L


.. _post_decr_char_sp_call_by_value_ex_2:

.. tab-set::

        .. tab-item:: ptr-- : Function Call

		* Step 1 : Define a single dimension array

		.. code-block:: c

			char a[7] = "Laptop";

		* Step 2 : Define a single pointer and point to array

		.. code-block:: c

			char *ptr;

			ptr =  a + strlen(a) - 1;

		* Step 3 : Iterate array using ptr-- and Pass by Value

		.. code-block:: c

		        while (ptr >=a)
		        {
		                fun(ptr--);
		        }

		* Step 4 : Define a function ``fun`` which receives a character pointer from caller

		.. code-block:: c

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

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

			Let us Recall,

			* In case of ``ptr--``

				* Current value of ``ptr`` is first assigned, then decremented
			
			* Hence, in this case

				* Current value of ``ptr`` is first passed to function ``fun``, then decremented

		* See full program below

		.. code-block:: c

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

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

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

			        char *ptr;

			        ptr =  a + strlen(a) - 1;

			        while (ptr >=a)
			        {
			                fun(ptr--);
			        }

			        return 0;
			}

.. card:: See Also

        * Current Module

                * :doc:`../post_decr_ptr`

        * Previous Module

                * :doc:`../../pre_decr_ptr/pre_decr_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:`../../array_of_ptr/array_of_ptr`
		* :doc:`../../function_ptr/function_ptr`
                * :doc:`../../ptr_to_array/ptr_to_array`
                * :doc:`../../pre_incr_ptr/pre_incr_ptr`
                * :doc:`../../post_incr_ptr/post_incr_ptr`