Proper way to interpret this dereference operation?

Question

I've seen this example in a text book and am a little confused how to interpret the operator precedence rules. Given this struct:

   typedef struct {
   char *data;
   size_t start, end;
   } str_wends;

Let B be declared as a pointer to this struct,that is.

   str_wends *B = malloc(sizeof(str_wends));

and assume B->start != 0,

then this should be a legal construct:

   &B->data[B->start]

which will return a reference to the string offset by B->start. The question is how to interpret the precedence rules. Since we know that -> and [] have the same precedence and bind left to right, why is B->Start evaluated before B->data[].

Answer 1

Concerning this:

&B->data[B->start]

you assert in comments that:

If I read the tokens from left to right, the operators are ->, [], ->

But those are not the operators reading left to right: you're including the closing ] with the opening [, even though the -> comes between them. That doesn't make any sense. When you see [expression], the inner expression doesn't have a precedence with respect to [] at all - it's an argument to it.

The code tokenizes as:

& B -> data [ B -> start ]

and the grammar rule for [] is approximately:

lvalue [ rvalue ]

This must reduce to lvalue:(B->data) [ rvalue:(B->start) ]. It cannot reduce to something like B -> (data [ B) -> (start ]), it simply isn't well-formed. This is an issue of grammar, not precedence.

Answer 2

Actually, it doesn't matter whether B->start or B->data is "evaluated" first. The result of interest is address of the referenced element, which is the sum of the base address and the product of the index and the size of the element. The two addends are independent, meaning that the order of their evaluation is irrelevant.

The result of the addition is an lvalue. Evaluated on the right-hand side of an assignment expression, it generates a FETCH. Evaluated on the left-hand side, it generates a STORE.

Answer 3

Since we know that -> and [] have the same precedence and bind left to right, why is B->Start evaluated before B->data[].

This is a common misconception that just won't die.

Precedence and evaluation order are unrelated.

Precedence rules tell us what your statement means; which tokens form operands to which operators. It tells us that your code is equivalent to &(B->data[B->start]), not (&B->data)[B->start].

The order in which those operands are evaluated with respect to one another is guided by completely separate rules; in this case, it's obvious that B->Start must be evaluated before the surrounding B->data[].

University professors really need to stop saying that a higher precedence leads to something being "executed" "before" some other thing; it absolutely does not.