foo->bar
is equivalent to (*foo).bar
, i.e. it gets the member called bar
from the struct that foo
points to.
Yes, that's it.
It's just the dot version when you want to access elements of a struct/class that is a pointer instead of a reference.
struct foo
{
int x;
float y;
};
struct foo var;
struct foo* pvar;
pvar = malloc(sizeof(struct foo));
var.x = 5;
(&var)->y = 14.3;
pvar->y = 22.4;
(*pvar).x = 6;
That's it!
I'd just add to the answers the "why?".
.
is standard member access operator that has a higher precedence than *
pointer operator.
When you are trying to access a struct's internals and you wrote it as *foo.bar
then the compiler would think to want a 'bar' element of 'foo' (which is an address in memory) and obviously that mere address does not have any members.
Thus you need to ask the compiler to first dereference whith (*foo)
and then access the member element: (*foo).bar
, which is a bit clumsy to write so the good folks have come up with a shorthand version: foo->bar
which is sort of member access by pointer operator.
a->b
is just short for (*a).b
in every way (same for functions: a->b()
is short for (*a).b()
).
foo->bar
is only shorthand for (*foo).bar
. That's all there is to it.
struct Node {
int i;
int j;
};
struct Node a, *p = &a;
Here the to access the values of i
and j
we can use the variable a
and the pointer p
as follows: a.i
, (*p).i
and p->i
are all the same.
Here .
is a "Direct Selector" and ->
is an "Indirect Selector".
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With