post decrement struct single pointer

In this section, you are going to learn

How to iterate structure array using ptr– ?

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

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

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

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

Topics of Post Decrement

• Basics of Post Decrement

• Meaning of expressions

• Summary of expressions

• Post Decrement : struct pointer inside structure

• Post Decrement : Function Call

Basics of Post Decrement

• ptr– Basic Usage

• ptr– : Iterate and print structures of an structure array

Example 1 : ptr-- : Basic Usage

• Step 1 : Define a Single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Point ptr to Single dimension array

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 3 : Decrement ptr

ptr--;

• Step 4 : Print *ptr

printf("ptr->a = %d\n", ptr->a);
printf("ptr->b = %d\n", ptr->b);

• See full program below

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        ptr--;

        printf("ptr->a = %d\n", ptr->a);
        printf("ptr->b = %d\n", ptr->b);

        return 0;
}

• Output is as below

ptr->a = 2
ptr->b = 3

Example 2 : ptr-- : Iterate and print structures of an structure array

• Step 1 : Define a Single Dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Point ptr to Single dimension array

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 3 : Print structure array by iterating through all structures using ptr--

for (int i = 0; i < 3; i++)
{
        printf("ptr->a = %d\n", ptr->a);
        printf("ptr->b = %d\n", ptr->b);
        ptr--;
}

• See full program below

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                printf("ptr->a = %d\n", ptr->a);
                printf("ptr->b = %d\n", ptr->b);
                ptr--;
        }

        return 0;
}

• Output is as below

ptr->a = 4
ptr->b = 5
ptr->a = 2
ptr->b = 3
ptr->a = 0
ptr->b = 1

Meaning of expressions

• Meaning of ptr– and c = ptr–

• Meaning of *(ptr–) and c = *(ptr–)

• Meaning of *ptr– and c = *ptr–

• Meaning of *(ptr)– and c = *(ptr)–

• Meaning of (*ptr)– and c = (*ptr)–

Meaning of ptr-- and c = ptr--

• Consider statement

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

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

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

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

OR

struct User_Data *ptr;

ptr = &arr[0];

• Step 3 : Iterate and print the structure array

for (int i = 0; i < 3; i++)
{
        struct User_Data *p;

        p = ptr--;

        printf("p->a = %d\n", p->a);
        printf("p->b = %d\n", p->b);
}

Output is as below

Can you guess what is happening ?

• Let us Recall

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

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data *p;

                p = ptr--;

                printf("p->a = %d\n", p->a);
                printf("p->b = %d\n", p->b);
        }

        return 0;
}

• Output is as below

p->a = 4
p->b = 5
p->a = 2
p->b = 3
p->a = 0
p->b = 1

Meaning of *(ptr--) and c = *(ptr--)

• Consider statement

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

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

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

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

OR

struct User_Data *ptr;

ptr = &arr[0];

• Step 3 : Iterate and print the structure array

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *(ptr--);

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

Output is as below

Can you guess what is happening ?

• Let us Recall

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

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *(ptr--);

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Meaning of *ptr-- and c = *ptr--

• Same as *(ptr–) and c = *(ptr–)

• Consider statement

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

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

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

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

OR

struct User_Data *ptr;

ptr = &arr[0];

• Step 3 : Iterate and print the structure array

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

Output is as below

Can you guess what is happening ?

• Let us Recall

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

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Meaning of *(ptr)-- and c = *(ptr)--

• Same as *(ptr–) and c = *(ptr–)

• Consider statement

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

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

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

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

OR

struct User_Data *ptr;

ptr = &arr[0];

• Step 3 : Iterate and print the structure array

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *(ptr)--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

Output is as below

Can you guess what is happening ?

• Let us Recall

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

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *(ptr)--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Meaning of (*ptr)-- and c = (*ptr)--

• Consider statement

c = (*ptr)--;

• This is invalid usage for a structure pointer !

Summary of expressions

• Summary of Post Decrement expressions

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)–	INVALID for structure pointer

Post Decrement : struct pointer inside structure

• Structure pointer accessed using Structure Object

• Structure pointer accessed using Structure Single Pointer

• Structure pointer accessed using Structure Double Pointer

• Structure pointer accessed using Structure Triple Pointer

• Structure pointer accessed using Nested Structure Object

• Structure pointer accessed using Nested Structure Single Pointer

• Structure pointer accessed using Nested Structure 2 level Pointers

Structure pointer accessed using Structure Object

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Create a structure object

struct ABC
{
        struct User_Data *ptr;
};

struct ABC abc;

• Step 3 : Point single structure pointer to single dimension array

abc.ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *abc.ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• See full program below

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

struct ABC
{
        struct User_Data *ptr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC abc;

        abc.ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *abc.ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Structure pointer accessed using Structure Single Pointer

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Allocate memory for structure pointers

struct ABC
{
        struct User_Data *ptr;
};

struct ABC *sp;

sp = malloc(sizeof(struct ABC));

• Step 3 : Point single structure pointer to single dimension array

sp->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *sp->ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• Step 5 : Free memory after use

free(sp);

• See full program below

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

struct User_Data {
        int a;
        int b;
};

struct ABC
{
        struct User_Data *ptr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC *sp;

        sp = malloc(sizeof(struct ABC));

        sp->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *sp->ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        free(sp);

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Structure pointer accessed using Structure Double Pointer

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Allocate memory for structure pointers

struct ABC
{
        struct User_Data *ptr;
};

struct ABC **dp;

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

• Step 3 : Point single structure pointer to single dimension array

(*dp)->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *(*dp)->ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• Step 5 : Free memory after use

free(*dp);
free(dp);

• See full program below

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

struct User_Data {
        int a;
        int b;
};

struct ABC
{
        struct User_Data *ptr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC **dp;

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

        (*dp)->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *(*dp)->ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        free(*dp);
        free(dp);

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Structure pointer accessed using Structure Triple Pointer

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Allocate memory for structure pointers

struct ABC
{
        struct User_Data *ptr;
};

struct ABC ***dp;

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

• Step 3 : Point single structure pointer to single dimension array

(**dp)->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *(**dp)->ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• Step 5 : Free memory after use

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

• See full program below

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

struct User_Data {
        int a;
        int b;
};

struct ABC
{
        struct User_Data *ptr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC ***dp;

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

        (**dp)->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *(**dp)->ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

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

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Structure pointer accessed using Nested Structure Object

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Create a structure object

struct PQR
{
        struct User_Data *ptr;
};

struct ABC
{
        struct PQR pqr;
};

struct ABC abc;

• Step 3 : Point single structure pointer to single dimension array

abc.pqr.ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *abc.pqr.ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• See full program below

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

struct PQR
{
        struct User_Data *ptr;
};

struct ABC
{
        struct PQR pqr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC abc;

        abc.pqr.ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *abc.pqr.ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Structure pointer accessed using Nested Structure Single Pointer

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Allocate memory for structure pointers

struct PQR
{
        struct User_Data *ptr;
};

struct ABC
{
        struct PQR pqr;
};

struct ABC *sp;

sp = malloc(sizeof(struct ABC));

• Step 3 : Point single structure pointer to single dimension array

sp->pqr.ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *sp->pqr.ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• Step 5 : Free memory after use

free(sp);

• See full program below

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

struct User_Data {
        int a;
        int b;
};

struct PQR
{
        struct User_Data *ptr;
};

struct ABC
{
        struct PQR pqr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC *sp;

        sp = malloc(sizeof(struct ABC));

        sp->pqr.ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *sp->pqr.ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

        free(sp);

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Structure pointer accessed using Nested Structure 2 level Pointers

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

• Step 2 : Allocate memory for structure pointers

struct PQR
{
        struct User_Data *ptr;
};

struct ABC
{
        struct PQR *pqr;
};

struct ABC *abc;

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

• Step 3 : Point single structure pointer to single dimension array

abc->pqr->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 4 : Iterate through single dimension array using pointer

for (int i = 0; i < 3; i++)
{
        struct User_Data c;

        c = *abc->pqr->ptr--;

        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

• Step 5 : Free memory after use

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

• See full program below

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

struct User_Data {
        int a;
        int b;
};

struct PQR
{
        struct User_Data *ptr;
};

struct ABC
{
        struct PQR *pqr;
};

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct ABC *abc;

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

        abc->pqr->ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                struct User_Data c;

                c = *abc->pqr->ptr--;

                printf("c.a = %d\n", c.a);
                printf("c.b = %d\n", c.b);
        }

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

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

Post Decrement : Function Call

• *ptr– : Function Call

• ptr– : Function Call

*ptr– : Function Call

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

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

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 3 : Iterate array using ptr– and Pass by Value

for (int i = 0; i < 3; i++)
{
        fun(*ptr--);
}

• Step 4 : Define a function fun which receives a structure from caller

void fun(struct User_Data c)
{
        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

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

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

void fun(struct User_Data c)
{
        printf("c.a = %d\n", c.a);
        printf("c.b = %d\n", c.b);
}

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                fun(*ptr--);
        }

        return 0;
}

• Output is as below

c.a = 4
c.b = 5
c.a = 2
c.b = 3
c.a = 0
c.b = 1

ptr– : Function Call

• Step 1 : Define a single dimension array

struct User_Data {
        int a;
        int b;
};

struct User_Data arr[3] = {
        { .a = 0, .b = 1 },
        { .a = 2, .b = 3 },
        { .a = 4, .b = 5 },
};

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

struct User_Data *ptr;

ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

• Step 3 : Iterate array using ptr– and Pass by Value

for (int i = 0; i < 3; i++)
{
        fun(ptr--);
}

• Step 4 : Define a function fun which receives a structure pointer from caller

void fun(struct User_Data *c)
{
        printf("c->a = %d\n", c->a);
        printf("c->b = %d\n", c->b);
}

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

#include <stdio.h>

struct User_Data {
        int a;
        int b;
};

void fun(struct User_Data *c)
{
        printf("c->a = %d\n", c->a);
        printf("c->b = %d\n", c->b);
}

int main(void)
{
        struct User_Data arr[3] = {
                { .a = 0, .b = 1 },
                { .a = 2, .b = 3 },
                { .a = 4, .b = 5 },
        };

        struct User_Data *ptr;

        ptr = arr + sizeof(arr)/sizeof(arr[0]) - 1;

        for (int i = 0; i < 3; i++)
        {
                fun(ptr--);
        }

        return 0;
}

• Output is as below

c->a = 4
c->b = 5
c->a = 2
c->b = 3
c->a = 0
c->b = 1

See Also

• Current Module

  • Post Decrement with Pointers

• Previous Module

  • Pre decrement with Pointers

• Other Modules

  • Basic Equations

  • Basic Arrays

  • Malloc and Pointers

  • Type-Casting and Pointers

  • Functions and Pointers

  • Memcpy and Pointers

  • Const Pointers

  • void Pointers

  • Array of Pointers

  • Function Pointers

  • Pointer to an Array

  • Pre Increment with Pointers

  • Post Increment with Pointers