Advertisements

The x->y notation is really shorthand for (*x).y; it was originally used
in C to access members of a struct through a pointer, since passing
structs by value can be expensive. Therefore,

(*pCurrent).pData == pCurrent->pData

Applying this again to pData, we have
(*(*pCurrent).pData).name == (pCurrent->pData)->name
== pCurrent->pData->name

> what is the benefit to the first? if any?
> why are the parenthesis important?

The parentheses are important because without them, it would be
interpreted as *(pCurrent.pData) which is an error, since pCurrent is a
pointer and pointers cannot have fields; however, (*pCurrent) is the
struct (or class) pointed to by pCurrent, so that is allowed to have a
field named pData.

Advertisements

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.

Share This Page

Welcome to The Coding Forums!

Welcome to the Coding Forums, the place to chat about anything related to programming and coding languages.

Please join our friendly community by clicking the button below - it only takes a few seconds and is totally free. You'll be able to ask questions about coding or chat with the community and help others.
Sign up now!