470,612 Members | 2,545 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 470,612 developers. It's quick & easy.

redirection casting?

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
Oct 9 '05 #1
2 1161
dave <sp*****@hotmail.com> wrote:
Why is this the same:
(*(*pCurrent).pData).name

as this:
pCurrent->pData->name
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.

--
Marcus Kwok
Oct 9 '05 #2
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

Oct 9 '05 #3

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

2 posts views Thread by Albert Ahtenberg | last post: by
52 posts views Thread by Gerard M Foley | last post: by
15 posts views Thread by Taki Jeden | last post: by
2 posts views Thread by Nadav | last post: by
reply views Thread by Dimitrios Mpougas | last post: by
8 posts views Thread by Luciano A. Ferrer | last post: by
13 posts views Thread by souissipro | last post: by
1 post views Thread by comp.lang.php | last post: by
4 posts views Thread by psual | last post: by
13 posts views Thread by Massimo Fabbri | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.