pre 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), --*ptr ?

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

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

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

Topics of Pre Decrement

Basics of Pre Decrement

Meaning of expressions

Summary of expressions

Pre Decrement : struct pointer inside structure

Pre Decrement : Function Call

Basics of Pre 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
- ptr is decremented
- Current value of ptr is assigned to p
We now derived a rule
- First Decrement, then Assign

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]);

OR

struct User_Data *ptr;

ptr = &arr[0] + sizeof(arr)/sizeof(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);
}

Can you guess what is happening ?

Let us Recall

p = --ptr;

There are two steps in this statement
- ptr is decremented
- Current value of ptr is assigned to p
We now derived a rule
- First Decrement, then Assign

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]);

        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
- ptr is decremented
- Current value of *ptr is assigned to c
- *ptr is NOT decremented
We now derived a rule
- First Decrement, then Assign

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]);

OR

struct User_Data *ptr;

ptr = &arr[0] + sizeof(arr)/sizeof(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
- ptr is decremented
- Current value of *ptr is assigned to c
- *ptr is NOT decremented
We now derived a rule
- First Decrement, then Assign

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]);

        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
- ptr is decremented
- Current value of *ptr is assigned to c
- *ptr is NOT decremented
We now derived a rule
- First Decrement, then Assign

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]);

OR

struct User_Data *ptr;

ptr = &arr[0] + sizeof(arr)/sizeof(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);
}

Can you guess what is happening ?

Let us Recall

c = *--ptr;

There are two steps in this statement
- ptr is decremented
- Current value of *ptr is assigned to c
- *ptr is NOT decremented
We now derived a rule
- First Decrement, then Assign

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]);

        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
- ptr is decremented
- Current value of *ptr is assigned to c
- *ptr is NOT decremented
We now derived a rule
- First Decrement, then Assign

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]);

OR

struct User_Data *ptr;

ptr = &arr[0] + sizeof(arr)/sizeof(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);
}

Can you guess what is happening ?

Let us Recall

c = *--(ptr);

There are two steps in this statement
- ptr is decremented
- Current value of *ptr is assigned to c
- *ptr is NOT decremented
We now derived a rule
- First Decrement, then Assign

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]);

        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 Pre Decrement expressions

Summary of Pre Decrement expressions

Expression	Explanation
c = –ptr	Decrement `ptr` Assign `ptr` to `c`
c = *–ptr	Decrement `ptr` Assign `ptr` to `c` DO NOT decrement `ptr`
c = *(–ptr)	Decrement `ptr` Assign `ptr` to `c` DO NOT decrement `ptr`
c = *–(ptr)	Decrement `ptr` Assign `ptr` to `c` DO NOT decrement `ptr`
c = –*ptr	INVALID for structure pointer
c = –*(ptr)	INVALID for structure pointer

Pre 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]);

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]);

        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]);

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]);

        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]);

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]);

        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]);

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]);

        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]);

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]);

        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]);

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]);

        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]);

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]);

        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

Pre 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]);

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
- ptr is decremented first, then current value of *ptr is assigned
Hence, in this case
- ptr is decremented first, then current value of *ptr is passed as arguement to function fun

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]);

        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]);

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
- ptr` is first decremented, then assigned
Hence, in this case
- ptr` is first decremented, then current value of ptr is assigned as argument to function fun

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]);

        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