指针算术：char指针作为结构的成员

Question

I took an example structure from K&R (page: 133) and tried a few pointer arithmetic on a pointer to an array of structure .

#include <stdio.h>
// struct example from K&R
struct key {
    char *word;
    int count;
}keytab[] = {
    "auto",0,
    "break",0,
    "const",0,
    /*.....*/
    "case",0
};
int main () { 
    struct key *ptr1 = keytab;
    printf("%d\n",sizeof(struct key));

    //check1
    printf("%s\n",ptr1++->word); //1
    printf("%s\n",ptr1->word);   //2

    //check2
    printf("%s\n",++ptr1->word);  //3
    printf("%s\n",++ptr1->word);  //4

    //check3
    printf("%s\n",ptr1++->word);  //5
    printf("%s\n",ptr1->word);  //6 ??
}

output:

8
auto
break
reak
eak
eak
const

I could understand the output of 3rd and 4th printf with the help of operator precedence.

But when it comes to 5th and 6th printf , how ptr1 has incremented in here ? output of the program shows similar behaviour as with 1st & 2nd printf s. If ptr1 increments in step of one struct size (here 8 bytes) then how it aligns itself to the starting of a keytab[2] .

I might have understood wrong or this last query may be invalid, please explain !

Thanks for the help!

Answer 1

So, the 3 and 4 prints increment ptr1->word. After they are executed, ptr1->word points to "eak".

Print 5 prints that unmodified value first and then increments ptr1, which then points to the next word in the list, "const".

This all is about operator precedence, as you stated but also about the effect of prefix and postfix ++ operator. The side effect of those is the same, but the first returns the new value, while the second the old one.

Answer 2

This expression:

++ptr1->word

does not increment ptr1 pointer. Due to operator precedence it's grouped as ++(ptr1->word) , because -> operator binds more tightly than prefix ++ . What it means is that it increments the word member of currently pointed object of the struct.

Answer 3

If ptr1 increments in step of one struct size (here 8 bytes) then how it aligns itself to the starting of a keytab[2].

But ptr1 is always pointing to an element of keytab. It's not allowed to point part-way through an element, and that never happens.

The reason you see reak , and then eak , is that the keytab entry pointed to by ptr1 has been changed in-place.

That is, ++ptr1->word doesn't change ptr1 at all . You can check - just print its value before and after. That expression changes the value of word inside your keytab. After line #3, keytab[1].word has changed (been incremented) so it points to "reak" .

When you finally increment ptr1 again (just after #5 is printed), you're still incrementing it from &keytab[1] to &keytab[2] . The fact that you modified the inside of keytab[1] doesn't affect that at all.

I could understand the output of 3rd and 4th printf with the help of operator precedence

It seems you correctly realised most of this, but overlooked that changing ptr1->word doesn't affect the value of ptr1 itself.