dave wrote:
Why is this the same:
(*(*pCurrent).pData).name
as this:
pCurrent->pData->name
what is the benefit to the first? if any?
why are the parenthesis important?
thanks
The "arrow" operator provides access to the members and methods of a
class or struct, given a pointer to the struct or class instance. The
"." operator provides the same access, given a direct instance of a
struct or class object. Lastly, the dereference operator, *, obtains a
the instance of a struct or class object given a pointer to it.
When these three operators are considered together, it becomes clear
that dereferencing and then applying the period operator to a pointer
is equivalent to applying the arrow operator to that pointer. In other
words:
pCurrent->pData->name
should be equivalent to this:
**pCurrent.pData.name
But it is not. The catch is that the order in which the * and the .
operators are applied to this expression affects the outcome. In fact
the compiler follows a strict "order of precedence" when deciding
whether to apply the * or the . operator first. When evaluating the
above expression the compiler appies the operators in this order:
**pCurrent.pData.name
43 1 2 // <- order of operator evaluation
The problem is that trying to apply the operators in this order, fails.
Instead, the compiler has to alternate between the two . and *
operators in order for this expression to make sense. Since parentheses
have a very high precedence, using them forces the compiler to apply
the operators in the desired order: first the *, then a ., then the
other *, and finally the last . before "name" like so
(*(*pCurrent).pData).name
3 1 2 4
Whether to use the -> or *. operator is largely a matter of preference
in this case. Neither is more efficient or better than the other it
terms of the compiled code.
Greg
