CODEWITHSUNDEEP
cpointersstructure
objectivesea
objectivesea

Reputation: 597

Difference between pointers to variables, and pointers to structures in C

In learning C, I've just begun studying pointers to structures and have some questions.

Suppose I were to create a structure named myStructure, and then create a pointer myStructurePointer, pointing to myStructure. Is *myStructurePointer, and myStructure two ways of referencing the same thing? If so, why is it necessary to have the -> operator? It seems simpler to use *myStructurePointer.variable_name than myStructurePointer->variable_name.

Upvotes: 6

Views: 2116

Answers (5)

Michael Mullany
Michael Mullany

Reputation: 31715

To generalize, learn your C operator precedence:

Here the "." operator is processed before the "*" -> hence the need for parentheses

Upvotes: 4

DigitalRoss
DigitalRoss

Reputation: 146053

Dennis Ritchie did note once that deref should probably have been a postfix operator1

Right, the following are equivalent:

pointer->field
(*pointer).field
pointer[0].field

If the indirection operator had postfix syntax C would have looked rather different but in that case it would not have needed -> at all.

It's interesting to think about how the common C idioms would look in that alternate universe...

do s1++* = c = s2++*;
   while(c);

while(n-- > 0)
    s++* = '\0';

p*.x = 1;
p*.y = 2;
. . .
. . .
. . .

1. See The Development of the C Language., Dennis M. Ritchie

Upvotes: 1

Carl Norum
Carl Norum

Reputation: 224904

You're right,

(*structurePointer).field

is exactly the same as

structurePointer->field

What you have, however, is :

*structurePointer.field

Which really tries to use the . operator on the pointer variable, then dereference the result of that - it won't even compile. You need the parentheses as I have them in the first example above if you want the expressions to be equivalent. The arrow saves at least a couple of keystrokes in this simple case.

The use of -> might make more sense if you think about the case where the structure field has pointer type, maybe to another structure:

structurePointer->field->field2

vs.

(*(*structurePointer).field).field2

Upvotes: 8

David Kanarek
David Kanarek

Reputation: 12613

Using the * dereferences the pointer, so you can use dot syntax to access the fields. If you don't dereference the pointer, then you use -> to access the fields. You can use whichever you prefer.

Upvotes: 0

sth
sth

Reputation: 229593

The problem with *myStructurePointer.variable_name is that * binds less tight than ., so it would be interpreted as *(myStructurePointer.variable_name). The equivalent of myStructurePointer->variable_name would be (*myStructurePointer).variable_name, where the parenthesis are required.

There is not difference between a->b and (*a).b, but -> is easier to use, especially if there are nested structures. (*(*(*a).b).c).d is much less readable than ´a->b->c->d`.

Upvotes: 5

Related Questions