Thread: Help with incrementing pointers in while loop

p and q have been declared as int pointers, so when they are incremented or decremented, they move one int space forward or one int space backward. In an example:

Code:

int num[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
char word[6] = {'h', 'e', 'l', 'l', 'o'};
int *x = &num[3];
char *y = &word[3];

On my system, the size of an int is 4 bytes while the size of a char is 1 byte. This means that when we do ++x, x moves forward 4 bytes. When we do --x, x moves backward 4 bytes. When we do ++y, y moves forward 1 byte. When we do --y, y moves backward 1 byte. When you then try to dereference these variables, they will try to read the data that they are then assigned to.

Dereferencing though I think is part of your problem. When you initialize a pointer, you can do it in all of these ways:

Code:

int* q = &num[0];
int * q = &num[0];
int *q = &num[0];

These all mean the exact same things. They mean that q has been declared a pointer. However, when you want to read what q has stored at the location it is pointing to, you would use the expression *q. As I had shows in the incrementing examples, if you want to just acess the variable q, and not what it is pointing to, you would use q. When you use *q--, you are deincrementing the value that q is pointing to, and not q itself.

Using my above code with x and y:
x is a pointer that points to num[3].
x++ makes x point to num[4].
*x is NOT a pointer. It is the value 4.
*x++ makes num[3] equal to 5. x still points to num[3].

*x++ makes num[3] equal to 5. x still points to num[3].

It seems I was wrong about this. I had assumed that x would get dereferenced first, but it seems that C's order of operations work differently than I thought they did.

I believe that this is the same program you wrote, except when written this way it is easier to see what is happening (and with the added print):

Code:

#include <stdio.h>

int main(void) {

    int num[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *p = &num[0];
    int *q = &num[9];
    int temp;

    while (p < q) {
        temp = *p;
        *p = *q;
        p++;
        *p;
        *q = temp;
        q--;
        *q;
        printf("p = %p\nq = %p\ntemp = %d\n*p = %d\n*q = %d\n", p, q, temp, *p, *q);
        printf("%s", "num values: ");
        for (int i = 0; i < 10; ++i) {
            printf("%3d", num[i]);
        }
        puts("\n");
    }
}

To simplify it, you could just delete the dereferencing statements. It would make more sense then. C's order of operations basically makes them do nothing when combined with a post increment operator.

Originally Posted by jack jordan

It seems I was wrong about this. I had assumed that x would get dereferenced first, but it seems that C's order of operations work differently than I thought they did.

Yeah, *p++ is equivalent to *(p++) rather than (*p)++, hence if we want the latter parentheses should be used.

Originally Posted by jack jordan

I believe that this is the same program you wrote
(...)
To simplify it, you could just delete the dereferencing statements. It would make more sense then. C's order of operations basically makes them do nothing when combined with a post increment operator.

No, they are essential when combined with the post-increment; as standalone statements they have no net effect. Therefore, you are mistaken about including the "dereferencing statements" in the first place. This:

Code:

temp = *p;
*p++ = *q;
*q-- = temp;

is functionally equivalent to:

Code:

temp = *p;
*p = *q;
p++;
*q = temp;
q--;

not:

Code:

temp = *p;
*p = *q;
p++;
*p;
*q = temp;
q--;
*q;

because when we examine the original code, the dereference of p and dereference of q each only happen twice.