post increment 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 Increment
* :ref:`Basics of Post Increment <post_incr_char_sp_mt_1>`
* :ref:`Meaning of expressions <post_incr_char_sp_mt_2>`
* :ref:`Summary of expressions <post_incr_char_sp_mt_3>`
* :ref:`Post Increment : char pointer inside structure <post_incr_char_sp_mt_4>`
* :ref:`Post Increment : Function Call <post_incr_char_sp_mt_5>`
.. _post_incr_char_sp_mt_1:
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Basics of Post Increment
* :ref:`ptr++ Basic Usage <post_incr_char_sp_ex_1>`
* :ref:`ptr++ : Iterate and print characters of a string : Method 1 <post_incr_char_sp_ex_2>`
* :ref:`ptr++ : Iterate and print characters of a string : Method 2 <post_incr_char_sp_ex_3>`
* :ref:`ptr++ : Iterate and print characters of a string : Method 3 <post_incr_char_sp_ex_4>`
* :ref:`ptr++ : Iterate and print characters of a string : Method 4 <post_incr_char_sp_ex_5>`
.. _post_incr_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
.. code-block:: c
char *ptr;
ptr = a;
* Step 3 : Increment ``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>
int main(void)
{
char a[7] = "Laptop";
char *ptr;
ptr = a;
ptr++;
printf("*ptr = %c\n", *ptr);
return 0;
}
.. _post_incr_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;
* 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;
for (int i = 0; i < strlen(a); i++)
{
printf("*ptr = %c\n", *ptr);
ptr++;
}
return 0;
}
.. _post_incr_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;
* Step 3 : Print string by iterating through all characters using ``ptr++``
.. code-block:: c
while (*ptr)
{
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;
while (*ptr)
{
printf("*ptr = %c\n", *ptr);
ptr++;
}
return 0;
}
.. _post_incr_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;
* Step 3 : Print string by iterating through all characters using ``ptr++``
.. code-block:: c
while (*ptr)
{
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;
while (*ptr)
{
char c;
c = *ptr++;
printf("*ptr = %c\n", c);
}
return 0;
}
.. _post_incr_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;
* Step 3 : Print string by iterating through all characters using ``ptr++``
.. code-block:: c
while (*ptr)
{
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;
while (*ptr)
{
printf("*ptr = %c\n", *ptr++);
}
return 0;
}
.. _post_incr_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_incr_char_sp_ex_6>`
* :ref:`Meaning of *(ptr++) and c = *(ptr++) <post_incr_char_sp_ex_7>`
* :ref:`Meaning of *ptr++ and c = *ptr++ <post_incr_char_sp_ex_10>`
* :ref:`Meaning of *(ptr)++ and c = *(ptr)++ <post_incr_char_sp_ex_8>`
* :ref:`Meaning of (*ptr)++ and c = (*ptr)++ <post_incr_char_sp_ex_9>`
.. _post_incr_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 incremented
* We now derived a rule
* First Assign, then increment
* 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;
OR
.. code-block:: c
char *ptr;
ptr = &a[0];
* Step 3 : Iterate and print the string
.. code-block:: c
while (*ptr)
{
char *p;
p = ptr++;
printf("*ptr = %c\n", *ptr);
printf("*p = %c\n", *p);
}
Output is as below
.. code-block:: c
*ptr = a
*p = L
*ptr = p
*p = a
*ptr = t
*p = p
*ptr = o
*p = t
*ptr = p
*p = o
*ptr =
*p = 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 incremented
* We now derived a rule
* First Assign, then increment
* See full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
int main(void)
{
char a[7] = "Laptop";
char *ptr;
ptr = a;
while (*ptr)
{
char *p;
p = ptr++;
printf("*ptr = %c\n", *ptr);
printf("*p = %c\n", *p);
}
return 0;
}
.. _post_incr_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 incremented
* ``*ptr`` is NOT incremented
* We now derived a rule
* First Assign, then increment
* 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;
OR
.. code-block:: c
char *ptr;
ptr = &a[0];
* Step 3 : Iterate and print the string
.. code-block:: c
while (*ptr)
{
char c;
c = *(ptr++);
printf("*ptr = %c\n", *ptr);
printf("c = %c\n", c);
}
Output is as below
.. code-block:: c
*ptr = a
c = L
*ptr = p
c = a
*ptr = t
c = p
*ptr = o
c = t
*ptr = p
c = o
*ptr =
c = 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
c = *(ptr++);
* There are two steps in this statement
* Current value of ``*ptr`` is assigned to ``c``
* ``ptr`` is incremented
* ``*ptr`` is NOT incremented
* We now derived a rule
* First Assign, then increment
* See full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
int main(void)
{
char a[7] = "Laptop";
char *ptr;
ptr = a;
while (*ptr)
{
char c;
c = *(ptr++);
printf("*ptr = %c\n", *ptr);
printf("c = %c\n", c);
}
return 0;
}
.. _post_incr_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_incr_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 incremented
* ``*ptr`` is NOT incremented
* We now derived a rule
* First Assign, then increment
* 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;
OR
.. code-block:: c
char *ptr;
ptr = &a[0];
* Step 3 : Iterate and print the string
.. code-block:: c
while (*ptr)
{
char c;
c = *ptr++;
printf("*ptr = %c\n", *ptr);
printf("c = %c\n", c);
}
Output is as below
.. code-block:: c
*ptr = a
c = L
*ptr = p
c = a
*ptr = t
c = p
*ptr = o
c = t
*ptr = p
c = o
*ptr =
c = 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
c = *ptr++;
* There are two steps in this statement
* Current value of ``*ptr`` is assigned to ``c``
* ``ptr`` is incremented
* ``*ptr`` is NOT incremented
* We now derived a rule
* First Assign, then increment
* See full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
int main(void)
{
char a[7] = "Laptop";
char *ptr;
ptr = a;
while (*ptr)
{
char c;
c = *ptr++;
printf("*ptr = %c\n", *ptr);
printf("c = %c\n", c);
}
return 0;
}
.. _post_incr_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_incr_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 incremented
* ``*ptr`` is NOT incremented
* We now derived a rule
* First Assign, then increment
* 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;
OR
.. code-block:: c
char *ptr;
ptr = &a[0];
* Step 3 : Iterate and print the string
.. code-block:: c
while (*ptr)
{
char c;
c = *(ptr)++;
printf("*ptr = %c\n", *ptr);
printf("c = %c\n", c);
}
Output is as below
.. code-block:: c
*ptr = a
c = L
*ptr = p
c = a
*ptr = t
c = p
*ptr = o
c = t
*ptr = p
c = o
*ptr =
c = 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
c = *(ptr)++;
* There are two steps in this statement
* Current value of ``*ptr`` is assigned to ``c``
* ``ptr`` is incremented
* ``*ptr`` is NOT incremented
* We now derived a rule
* First Assign, then increment
* See full program below
.. code-block:: c
#include <stdio.h>
#include <string.h>
int main(void)
{
char a[7] = "Laptop";
char *ptr;
ptr = a;
while (*ptr)
{
char c;
c = *(ptr)++;
printf("*ptr = %c\n", *ptr);
printf("c = %c\n", c);
}
return 0;
}
.. _post_incr_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 incremented
* ``*ptr`` is incremented
* We now derived a rule
* First Assign, then increment
.. _post_incr_char_sp_mt_3:
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Summary of expressions
* :ref:`Summary of Post Increment expressions <post_incr_char_sp_ex_summary>`
.. _post_incr_char_sp_ex_summary:
.. tab-set::
.. tab-item:: Summary of Post Increment expressions
===================================== =========================================================================
Expression Explanation
===================================== =========================================================================
c = ptr++ * Assign ``ptr`` to ``c``
* Increment ``ptr``
c = \*(ptr++) * Assign ``*ptr`` to ``c``
* Increment ``ptr``
* DO NOT increment ``*ptr``
c = \*ptr++ * Assign ``*ptr`` to ``c``
* Increment ``ptr``
* DO NOT increment ``*ptr``
c = \*(ptr)++ * Assign ``*ptr`` to ``c``
* Increment ``ptr``
* DO NOT increment ``*ptr``
c = (\*ptr)++ * Assign ``*ptr`` to ``c``
* DO NOT increment ``ptr``
* Increment ``*ptr``
===================================== =========================================================================
.. _post_incr_char_sp_mt_4:
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Post Increment : char pointer inside structure
* :ref:`Char pointer accessed using Structure Object <post_incr_char_sp_ex_struct_ex_1>`
* :ref:`Char pointer accessed using Structure Single Pointer <post_incr_char_sp_ex_struct_ex_2>`
* :ref:`Char pointer accessed using Structure Double Pointer <post_incr_char_sp_ex_struct_ex_3>`
* :ref:`Char pointer accessed using Structure Triple Pointer <post_incr_char_sp_ex_struct_ex_4>`
* :ref:`Char pointer accessed using Nested Structure Object <post_incr_char_sp_ex_struct_ex_5>`
* :ref:`Char pointer accessed using Nested Structure Single Pointer <post_incr_char_sp_ex_struct_ex_6>`
* :ref:`Char pointer accessed using Nested Structure 2 level Pointers <post_incr_char_sp_ex_struct_ex_7>`
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*abc.ptr)
{
char c;
c = *abc.ptr++;
printf("*ptr = %c\n", *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;
while (*abc.ptr)
{
char c;
c = *abc.ptr++;
printf("*ptr = %c\n", *abc.ptr);
printf("c = %c\n", c);
}
return 0;
}
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*sp->ptr)
{
char c;
c = *sp->ptr++;
printf("*ptr = %c\n", *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>
struct ABC
{
char *ptr;
};
int main(void)
{
char a[7] = "Laptop";
struct ABC *sp;
sp = malloc(sizeof(struct ABC));
sp->ptr = a;
while (*sp->ptr)
{
char c;
c = *sp->ptr++;
printf("*ptr = %c\n", *sp->ptr);
printf("c = %c\n", c);
}
free(sp);
return 0;
}
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*(*dp)->ptr)
{
char c;
c = *(*dp)->ptr++;
printf("*ptr = %c\n", *(*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;
while (*(*dp)->ptr)
{
char c;
c = *(*dp)->ptr++;
printf("*ptr = %c\n", *(*dp)->ptr);
printf("c = %c\n", c);
}
free(*dp);
free(dp);
return 0;
}
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*(**dp)->ptr)
{
char c;
c = *(**dp)->ptr++;
printf("*ptr = %c\n", *(**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;
while (*(**dp)->ptr)
{
char c;
c = *(**dp)->ptr++;
printf("*ptr = %c\n", *(**dp)->ptr);
printf("c = %c\n", c);
}
free(**dp);
free(*dp);
free(dp);
return 0;
}
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*abc.pqr.ptr)
{
char c;
c = *abc.pqr.ptr++;
printf("*ptr = %c\n", *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;
while (*abc.pqr.ptr)
{
char c;
c = *abc.pqr.ptr++;
printf("*ptr = %c\n", *abc.pqr.ptr);
printf("c = %c\n", c);
}
return 0;
}
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*sp->pqr.ptr)
{
char c;
c = *sp->pqr.ptr++;
printf("*ptr = %c\n", *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;
while (*sp->pqr.ptr)
{
char c;
c = *sp->pqr.ptr++;
printf("*ptr = %c\n", *sp->pqr.ptr);
printf("c = %c\n", c);
}
free(sp);
return 0;
}
.. _post_incr_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;
* Step 4 : Iterate through single dimension array using pointer
.. code-block:: c
while (*abc->pqr->ptr)
{
char c;
c = *abc->pqr->ptr++;
printf("*ptr = %c\n", *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;
while (*abc->pqr->ptr)
{
char c;
c = *abc->pqr->ptr++;
printf("*ptr = %c\n", *abc->pqr->ptr);
printf("c = %c\n", c);
}
free(abc->pqr);
free(abc);
return 0;
}
.. _post_incr_char_sp_mt_5:
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Post Increment : Function Call
* :ref:`*ptr++ : Function Call <post_incr_char_sp_call_by_value_ex_1>`
* :ref:`ptr++ : Function Call <post_incr_char_sp_call_by_value_ex_2>`
.. _post_incr_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;
* Step 3 : Iterate array using ptr++ and Pass by Value
.. code-block:: c
while (*ptr)
{
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`` incremented
* Hence, in this case
* Current value of ``*ptr`` is first passed to function ``fun``, then ``ptr`` incremented
* 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;
while (*ptr)
{
fun(*ptr++);
}
return 0;
}
.. _post_incr_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;
* Step 3 : Iterate array using ptr++ and Pass by Value
.. code-block:: c
while (*ptr)
{
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 incremented
* Hence, in this case
* Current value of ``ptr`` is first passed to function ``fun``, then incremented
* 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;
while (*ptr)
{
fun(ptr++);
}
return 0;
}
.. card:: See Also
* Current Module
* :doc:`../post_incr_ptr`
* Previous Module
* :doc:`../../pre_incr_ptr/pre_incr_ptr`
* Next 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:`../../ptr_to_array/ptr_to_array`
* :doc:`../../post_decr_ptr/post_decr_ptr`