redirection casting?

[dave]

Why is this the same:
(*(*pCurrent).p Data).name

as this:
pCurrent->pData->name

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

thanks

[Marcus Kwok]

Re: redirection casting?

dave <spammer@hotmai l.com> wrote:[color=blue]
> Why is this the same:
> (*(*pCurrent).p Data).name
>
> as this:
> pCurrent->pData->name[/color]

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).pDa ta == pCurrent->pData

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

[color=blue]
> what is the benefit to the first? if any?
> why are the parenthesis important?[/color]

The parentheses are important because without them, it would be
interpreted as *(pCurrent.pDat a) 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.

--
Marcus Kwok

[Greg]

Re: redirection casting?

dave wrote:[color=blue]
> Why is this the same:
> (*(*pCurrent).p Data).name
>
> as this:
> pCurrent->pData->name
>
> what is the benefit to the first? if any?
> why are the parenthesis important?
>
> thanks[/color]

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.pDat a.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.pDat a.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).p Data).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