# pointers – Arrow operator (->) usage in C

## The Question :

272 people think this question is useful

I am reading a book called “Teach Yourself C in 21 Days” (I have already learned Java and C# so I am moving at a much faster pace). I was reading the chapter on pointers and the -> (arrow) operator came up without explanation. I think that it is used to call members and functions (like the equivalent of the . (dot) operator, but for pointers instead of members). But I am not entirely sure.

Could I please get an explanation and a code sample?

The Question Comments :
• Get a better book. norvig.com/21-days.html
• qrdl is correct — the “Learn X in Y days” books are generally garbage. In addition to K&R, I would also recommend Prata’s “C Primer Plus”, which goes into more depth than K&R.
• @Steve That question deals with C++. Calling it a caused some confusion for me when I started reading about operator overloading in that other answer, which is not relevant in C.
• @Belton The hard way series are bad, the guy says stuff that wasn’t even relevant when he wrote the book and he doesn’t care about good practices.
• The Peter Norvig link to “Teach Yourself Programming in Ten Years” is great, one of my favorites. Here’s the comic version which explains how to do this in 21 days, which I unfortunately remembered as an XKCD but I was wrong: abstrusegoose.com/249

## The Answer 1

485 people think this answer is useful

foo->bar is equivalent to (*foo).bar, i.e. it gets the member called bar from the struct that foo points to.

## The Answer 2

134 people think this answer is useful

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(pvar));

var.x = 5;
(&amp;var)->y = 14.3;
pvar->y = 22.4;
(*pvar).x = 6;



That’s it!

## The Answer 3

33 people think this answer is useful

a->b is just short for (*a).b in every way (same for functions: a->b() is short for (*a).b()).

## The Answer 4

32 people think this answer is useful

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.

## The Answer 5

19 people think this answer is useful

foo->bar is only shorthand for (*foo).bar. That’s all there is to it.

## The Answer 6

10 people think this answer is useful
struct Node {
int i;
int j;
};
struct Node a, *p = &amp;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”.

## The Answer 7

5 people think this answer is useful

Well I have to add something as well. Structure is a bit different than array because array is a pointer and structure is not. So be careful!

Lets say I write this useless piece of code:

#include <stdio.h>

typedef struct{
int km;
int kph;
int kg;
} car;

int main(void){

car audi = {12000, 230, 760};
car *ptr = &amp;audi;

}



Here pointer ptr points to the address (!) of the structure variable audi but beside address structure also has a chunk of data (!)! The first member of the chunk of data has the same address than structure itself and you can get it’s data by only dereferencing a pointer like this *ptr (no braces).

But If you want to acess any other member than the first one, you have to add a designator like .km, .kph, .kg which are nothing more than offsets to the base address of the chunk of data

But because of the preceedence you can’t write *ptr.kg as access operator . is evaluated before dereference operator * and you would get *(ptr.kg) which is not possible as pointer has no members! And compiler knows this and will therefore issue an error e.g.:

error: ‘ptr’ is a pointer; did you mean to use ‘->’?
printf("%d\n", *ptr.km);



Instead you use this (*ptr).kg and you force compiler to 1st dereference the pointer and enable acess to the chunk of data and 2nd you add an offset (designator) to choose the member.

Check this image I made:

But if you would have nested members this syntax would become unreadable and therefore -> was introduced. I think readability is the only justifiable reason for using it as this ptr->kg is much easier to write than (*ptr).kg.

Now let us write this differently so that you see the connection more clearly. (*ptr).kg(*&audi).kgaudi.kg. Here I first used the fact that ptr is an “address of audi i.e. &audi and fact that “reference” & and “dereference” * operators cancel eachother out.

## The Answer 8

1 people think this answer is useful

I had to make a small change to Jack’s program to get it to run. After declaring the struct pointer pvar, point it to the address of var. I found this solution on page 242 of Stephen Kochan’s Programming in C.

#include <stdio.h>

int main()
{
struct foo
{
int x;
float y;
};

struct foo var;
struct foo* pvar;
pvar = &amp;var;

var.x = 5;
(&amp;var)->y = 14.3;
printf("%i - %.02f\n", var.x, (&amp;var)->y);
pvar->x = 6;
pvar->y = 22.4;
printf("%i - %.02f\n", pvar->x, pvar->y);
return 0;
}



Run this in vim with the following command:

:!gcc -o var var.c &amp;&amp; ./var



Will output:

5 - 14.30
6 - 22.40



## The Answer 9

1 people think this answer is useful
#include<stdio.h>

int main()
{
struct foo
{
int x;
float y;
} var1;
struct foo var;
struct foo* pvar;

pvar = &amp;var1;
/* if pvar = &amp;var; it directly
takes values stored in var, and if give
new > values like pvar->x = 6; pvar->y = 22.4;
it modifies the values of var
object..so better to give new reference. */
var.x = 5;
(&amp;var)->y = 14.3;
printf("%i - %.02f\n", var.x, (&amp;var)->y);

pvar->x = 6;
pvar->y = 22.4;
printf("%i - %.02f\n", pvar->x, pvar->y);

return 0;
}



## The Answer 10

1 people think this answer is useful

The -> operator makes the code more readable than the * operator in some situations.

Such as: (quoted from the EDK II project)

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_READ)(
IN EFI_BLOCK_IO_PROTOCOL          *This,
IN UINT32                         MediaId,
IN EFI_LBA                        Lba,
IN UINTN                          BufferSize,
OUT VOID                          *Buffer
);

struct _EFI_BLOCK_IO_PROTOCOL {
///
/// The revision to which the block IO interface adheres. All future
/// revisions must be backwards compatible. If a future version is not
/// back wards compatible, it is not the same GUID.
///
UINT64              Revision;
///
/// Pointer to the EFI_BLOCK_IO_MEDIA data for this device.
///
EFI_BLOCK_IO_MEDIA  *Media;

EFI_BLOCK_RESET     Reset;
EFI_BLOCK_READ      ReadBlocks;
EFI_BLOCK_WRITE     WriteBlocks;
EFI_BLOCK_FLUSH     FlushBlocks;

};



The _EFI_BLOCK_IO_PROTOCOL struct contains 4 function pointer members.

Suppose you have a variable struct _EFI_BLOCK_IO_PROTOCOL * pStruct, and you want to use the good old * operator to call it’s member function pointer. You will end up with code like this:

(*pStruct).ReadBlocks(...arguments...)

But with the -> operator, you can write like this:

pStruct->ReadBlocks(...arguments...).

Which looks better?

## The Answer 11

1 people think this answer is useful
#include<stdio.h>
struct examp{
int number;
};
struct examp a,*b=&amp;a;enter code here
main()
{
a.number=5;
/* a.number,b->number,(*b).number produces same output. b->number is mostly used in linked list*/
printf("%d \n %d \n %d",a.number,b->number,(*b).number);
}



output is 5 5 5

## The Answer 12

0 people think this answer is useful

Dot is a dereference operator and used to connect the structure variable for a particular record of structure. Eg :

struct student
{
int s.no;
Char name [];
int age;
} s1,s2;

main()
{
s1.name;
s2.name;
}



In such way we can use a dot operator to access the structure variable