pre decrement char single pointer

In this section, you are going to learn

How to iterate character strings 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 : char pointer inside structure

• Pre Decrement : Function Call

Basics of Pre Decrement

• - -ptr Basic Usage

• - -ptr : Iterate and print characters of a string : Method 1

• - -ptr : Iterate and print characters of a string : Method 2

• - -ptr : Iterate and print characters of a string : Method 3

• - -ptr : Iterate and print characters of a string : Method 4

Example 1 : --ptr : Basic Usage

• Step 1 : Define a Single dimension array

char a[7] = "Laptop";

• Step 2 : Point ptr to Single dimension array

char *ptr;

ptr = a + strlen(a) - 1;

• Step 3 : Decrement ptr

--ptr;

• Step 4 : Print *ptr

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

• See full program below

#include <stdio.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

*ptr = o

Example 2 : --ptr : Iterate and print characters of a string : Method 1

• Step 1 : Define a Single Dimension array

char a[7] = "Laptop";

• Step 2 : Point ptr to Single dimension array

char *ptr;

ptr = a + strlen(a) - 1;

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

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

• See full program below

#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

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

Example 3 : --ptr : Iterate and print characters of a string : Method 2

• Step 1 : Define a Single Dimension array

char a[7] = "Laptop";

• Step 2 : Point ptr to Single dimension array

char *ptr;

ptr = a + strlen(a) - 1;

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

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

• See full program below

#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

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

Example 4 : --ptr : Iterate and print characters of a string : Method 3

• Step 1 : Define a Single Dimension array

char a[7] = "Laptop";

• Step 2 : Point ptr to Single dimension array

char *ptr;

ptr = a + strlen(a);

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

while (ptr > a)
{
        char c;

        c = *--ptr;

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

• See full program below

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

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

        char *ptr;

        ptr = a + strlen(a);

        while (ptr > a)
        {
                char c;

                c = *--ptr;

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

        return 0;
}

• Output is as below

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

Guess what is going on ?

• Statement c = *--ptr can be understood in two steps

  • Step 1 : Decrement ptr

  • Step 2 : Assign *ptr to c

Example 5 : --ptr : Iterate and print characters of a string : Method 4

• Step 1 : Define a Single Dimension array

char a[7] = "Laptop";

• Step 2 : Point ptr to Single dimension array

char *ptr;

ptr = a + strlen(a);

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

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

• See full program below

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

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

        char *ptr;

        ptr = a + strlen(a);

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

        return 0;
}

• Output is as below

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

Guess what is going on ?

• Statement printf("*ptr = %c\n", *--ptr); can be understood in two steps

  • Step 1 : Decrement ptr

  • Step 2 : Pass *ptr as arguement to printf

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)

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

char a[7] = "Laptop";

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

char *ptr;

ptr = a + strlen(a);

OR

char *ptr;

ptr = &a[0];

• Step 3 : Iterate and print the string

while (ptr > a)
{
        char *p;

        p = --ptr;

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

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>
#include <string.h>

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

        char *ptr;

        ptr = a + strlen(a);

        while (ptr > a)
        {
                char *p;

                p = --ptr;

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

        return 0;
}

Output is as below

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

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

char a[7] = "Laptop";

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

char *ptr;

ptr = a + strlen(a);

OR

char *ptr;

ptr = &a[0];

• Step 3 : Iterate and print the string

while (ptr > a)
{
        char c;

        c = *(--ptr);

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

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>
#include <string.h>

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

        char *ptr;

        ptr = a + strlen(a);

        while (ptr > a)
        {
                char c;

                c = *(--ptr);

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

        return 0;
}

Output is as below

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

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

char a[7] = "Laptop";

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

char *ptr;

ptr = a + strlen(a);

OR

char *ptr;

ptr = &a[0];

• Step 3 : Iterate and print the string

while (ptr > a)
{
        char c;

        c = *--ptr;

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

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>
#include <string.h>

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

        char *ptr;

        ptr = a + strlen(a);

        while (ptr > a)
        {
                char c;

                c = *--ptr;

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

        return 0;
}

Output is as below

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

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

char a[7] = "Laptop";

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

char *ptr;

ptr = a + strlen(a);

OR

char *ptr;

ptr = &a[0];

• Step 3 : Iterate and print the string

while (ptr > a)
{
        char c;

        c = *--(ptr);

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

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>
#include <string.h>

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

        char *ptr;

        ptr = a + strlen(a);

        while (ptr > a)
        {
                char c;

                c = *--(ptr);

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

        return 0;
}

Output is as below

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

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

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

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	Decrement *ptr Assign *ptr to c DO NOT decrement ptr
c = –*(ptr)	Decrement *ptr Assign *ptr to c DO NOT decrement ptr

Pre Decrement : char pointer inside structure

• Char pointer accessed using Structure Object

• Char pointer accessed using Structure Single Pointer

• Char pointer accessed using Structure Double Pointer

• Char pointer accessed using Structure Triple Pointer

• Char pointer accessed using Nested Structure Object

• Char pointer accessed using Nested Structure Single Pointer

• Char pointer accessed using Nested Structure 2 level Pointers

Char pointer accessed using Structure Object

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Create a structure object

struct ABC abc;

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

abc.ptr = a + strlen(a);

• Step 4 : Iterate through single dimension array using pointer

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

        c = *--abc.ptr;

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

• See full program below

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

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

                c = *--abc.ptr;

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

        return 0;
}

Output is as below

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

Char pointer accessed using Structure Single Pointer

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Allocate memory for structure pointers

struct ABC *sp;

sp = malloc(sizeof(struct ABC));

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

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

• Step 4 : Iterate through single dimension array using pointer

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

        c = *--sp->ptr;

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

• Step 5 : Free memory after use

free(sp);

• See full program below

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

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

                c = *--sp->ptr;

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

        free(sp);

        return 0;
}

Output is as below

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

Char pointer accessed using Structure Double Pointer

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Allocate memory for structure pointers

struct ABC **dp;

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

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

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

• Step 4 : Iterate through single dimension array using pointer

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

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

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

• Step 5 : Free memory after use

free(*dp);
free(dp);

• See full program below

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

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

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

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

        free(*dp);
        free(dp);

        return 0;
}

Output is as below

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

Char pointer accessed using Structure Triple Pointer

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Allocate memory for structure pointers

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

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

• Step 4 : Iterate through single dimension array using pointer

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

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

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

• Step 5 : Free memory after use

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

• See full program below

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

        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

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

Char pointer accessed using Nested Structure Object

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Create a structure object

struct ABC abc;

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

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

• Step 4 : Iterate through single dimension array using pointer

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

        c = *--abc.pqr.ptr;

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

• See full program below

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

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

                c = *--abc.pqr.ptr;

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

        return 0;
}

Output is as below

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

Char pointer accessed using Nested Structure Single Pointer

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Allocate memory for structure pointers

struct ABC *sp;

sp = malloc(sizeof(struct ABC));

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

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

• Step 4 : Iterate through single dimension array using pointer

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

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

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

• Step 5 : Free memory after use

free(sp);

• See full program below

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

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

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

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

        free(sp);

        return 0;
}

Output is as below

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

Char pointer accessed using Nested Structure 2 level Pointers

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

• Step 2 : Allocate memory for structure pointers

struct ABC *abc;

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

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

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

• Step 4 : Iterate through single dimension array using pointer

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

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

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

• Step 5 : Free memory after use

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

• See full program below

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

        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

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

Pre Decrement : Function Call

• *–ptr : Function Call

• –ptr : Function Call

*–ptr : Function Call

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

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

char *ptr;

ptr = a + strlen(a);

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

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

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

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

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 to function fun

• See full program below

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

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

        return 0;
}

Output is as below

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

–ptr : Function Call

• Step 1 : Define a single dimension array

char a[7] = "Laptop";

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

char *ptr;

ptr = a + strlen(a);

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

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

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

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

Let us Recall,

• In case of --ptr

  • ptr is decremented first, then decremented

• Hence, in this case

  • ptr is decremented first, then passed to function fun

• See full program below

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

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

        return 0;
}

Output is as below

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

See Also

• Current Module

  • Pre decrement with Pointers

• Previous Module

  • Post Increment with Pointers

• Next Module

  • Post 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

  • Pointer to an Array

  • Pre Increment with Pointers