What is the difference between the dot (.) operator and -> in C++?

Question

SwDevMan81 · Answer 1 · 2018-08-06T13:35:50.647

346

foo->bar() is the same as (*foo).bar().

The parenthesizes above are necessary because of the binding strength of the * and . operators.

*foo.bar() wouldn't work because Dot (.) operator is evaluated first (see operator precedence)

The Dot (.) operator can't be overloaded, arrow (->) operator can be overloaded.

The Dot (.) operator can't be applied to pointers.

Also see: What is the arrow operator (->) synonym for in C++?

edited Aug 06 '18 at 13:35

answered Aug 06 '09 at 12:45

SwDevMan81

45,922
20
140
177

4

Note that this is only for raw pointers. For class types that overload the operator, it has some other interesting properties... – David Rodríguez - dribeas Jul 17 '12 at 18:19
doesn't it bother that -> is a drill down operator, and thus if overloaded it is not equivalent to member of the derefenced object (*boo).foo ? as if boo->foo may be overloaded to return an intermediate proxy object which has a foo member different from that in the originating class. Wouldn't that assert( (*boo).foo == boo->foo ) fail. It is true that one should be cautious as the c++ elves may be lurking in the dark. – g24l Jan 19 '15 at 18:17

score 73 · Answer 2 · edited Dec 07 '12 at 20:40

For a pointer, we could just use

*pointervariable.foo

But the . operator has greater precedence than the * operator, so . is evaluated first. So we need to force this with parenthesis:

(*pointervariable).foo

But typing the ()'s all the time is hard, so they developed -> as a shortcut to say the same thing. If you are accessing a property of an object or object reference, use . If you are accessing a property of an object through a pointer, use ->

score 61 · Answer 3 · edited Oct 08 '19 at 08:54

61

Dot operator can't be overloaded, arrow operator can be overloaded. Arrow operator is generally meant to be applied to pointers (or objects that behave like pointers, like smart pointers). Dot operator can't be applied to pointers.

EDIT When applied to pointer arrow operator is equivalent to applying dot operator to pointee e.g. ptr->field is equivalent to (*ptr).field.

edited Oct 08 '19 at 08:54

n1k31t4

2,090
1
19
32

answered Aug 06 '09 at 12:44

Tadeusz Kopec

11,984
6
51
79

1

Though the indirection operator (`*foo`) can be overloaded – user Feb 23 '14 at 23:52

score 31 · Answer 4 · answered Aug 06 '09 at 12:43

31

The arrow operator is like dot, except it dereferences a pointer first. foo.bar() calls method bar() on object foo, foo->bar calls method bar on the object pointed to by pointer foo.

answered Aug 06 '09 at 12:43

Meredith L. Patterson

4,513
25
29

1

And what if the thing isn't a pointer? – juanchopanza Aug 11 '15 at 09:24
@juanchopanza If `foo` is not a pointer and it is of type `MyType`, you will get a compilation exception: `base operand of '->' has non-pointer type 'MyType'`. – horcrux Aug 31 '18 at 09:43
@horcrux C++ allows to overload `operator->`. – juanchopanza Sep 01 '18 at 10:54
@juanchopanza But this is a generic question about how "the dot (.) operator and -> in C++" work, not about operators overloading. – horcrux Sep 01 '18 at 11:17
@horcrux How those operators work in C++ has to take into account operator overloading. Without that, the picture is quite incomplete. – juanchopanza Sep 01 '18 at 15:35

score 19 · Answer 5 · edited Apr 19 '17 at 04:00

19

The . operator is for direct member access.

object.Field

The arrow dereferences a pointer so you can access the object/memory it is pointing to

pClass->Field

edited Apr 19 '17 at 04:00

buræquete

12,943
4
34
69

answered Aug 06 '09 at 12:42

Johannes Rudolph

34,073
12
105
164

score 13 · Answer 6 · edited Jun 22 '11 at 20:02

13

pSomething->someMember

is equivalent to

(*pSomething).someMember

edited Jun 22 '11 at 20:02

SwDevMan81

45,922
20
140
177

answered Aug 06 '09 at 12:45

Tamás Szelei

21,352
16
94
169

score 11 · Answer 7 · answered Aug 06 '09 at 12:44

11

The target. dot works on objects; arrow works on pointers to objects.

std::string str("foo");
std::string * pstr = new std::string("foo");

str.size ();
pstr->size ();

answered Aug 06 '09 at 12:44

ezpz

10,955
6
35
36

Am1rr3zA · Answer 8 · 2019-07-11T18:55:57.933

10

Use -> when you have a pointer. Use . when you have structure (class).

When you want to point attribute that belongs to structure use .:

structure.attribute

When you want to point to an attribute that has reference to memory by pointer use -> :

pointer->method;

or same as:

(*pointer).method

edited Jul 11 '19 at 18:55

answered Aug 06 '09 at 12:44

Am1rr3zA

5,777
15
66
112

score 4 · Answer 9 · answered Aug 06 '09 at 12:58

4

Note that the -> operator cannot be used for certain things, for instance, accessing operator[].

#include <vector>

int main()
{
   std::vector<int> iVec;
   iVec.push_back(42);
   std::vector<int>* iVecPtr = &iVec;

   //int i = iVecPtr->[0]; // Does not compile
   int i = (*iVecPtr)[0]; // Compiles.
}

answered Aug 06 '09 at 12:58

gparent

869
7
12

6

Clearly not. Because "foo->" does not mean "(*foo)". It means "(*foo).". It also can't be used for addition, subtraction... ;) – jmtd Aug 06 '09 at 13:21
I don't see how that's relevant. member[0] also doesn't mean anything, however syntactic sugar transforms it into member.operator[](0) if applicable. It's noteworthy that -> will not allow you to do what most people generally expect to be able to. – gparent Aug 06 '09 at 13:56
in regards to that operator, I mean. – gparent Aug 06 '09 at 13:57
1

I would imagine iVecPtr->operator[](0) would work, though. The point being that the syntactic sugar that you site turns [0] into .operator[](0); it does not turn .[0] into .operator[](0). – Domenic Aug 07 '09 at 01:18

score 2 · Answer 10 · answered Aug 06 '09 at 12:48

2

It's simple, whenever you see

 x->y

know it is the same as

 (*x).y

answered Aug 06 '09 at 12:48

Logan Capaldo

37,749
5
60
76

3

Except when it isn't, such as when -> is overloaded. – jmtd Aug 06 '09 at 13:20
3

When you overload -> you should also overload * such that this relationship holds. To do otherwise will introduce all sorts of confusion anyway. – Logan Capaldo Aug 06 '09 at 13:39

score 2 · Answer 11 · answered Aug 06 '09 at 13:19

The -> is simply syntactic sugar for a pointer dereference,

As others have said:

pointer->method();

is a simple method of saying:

(*pointer).method();

For more pointer fun, check out Binky, and his magic wand of dereferencing:

http://www.youtube.com/watch?v=UvoHwFvAvQE

score 2 · Answer 12 · answered Feb 14 '16 at 02:16

The simplest difference between the two is that "->" dereferences a pointer before it goes to look at that objects fields, function etc. whereas "." doesn't dereference first. Use "->" when you have a pointer to an object, and use "." when you're working with the actual instance of an object.

Another equivalent way of wrinting this might be to use the dereferencing "*" on the pointer first and then just use the ".". We skip middleman by using "->".

There are other differences, but the other answers have covered this extensively.

If you have a background in Java this might confuse you, since, in Java, everything is pointers. This means that there's no reason to have symbol that doesn't dereference your pointer first. In c++ however you gotta be a little more careful with remembering what is and what isn't a pointer, and it might be a good idea to label them with the prefix "p_" or simply "p".

score 1 · Answer 13 · answered Aug 06 '09 at 12:51

The . (dot) operator is usually used to get a field / call a method from an instance of class (or a static field / method of a class).

p.myField, p.myMethod() - p instance of a class

The -> (arrow) operator is used to get a field / call a method from the content pointed by the class.

p->myField, p->myMethod() - p points to a class

score 1 · Answer 14 · answered Feb 26 '16 at 06:54

The -> operator is used when we are working with a pointer and the dot is used otherwise. So if we have a struct class like:

struct class{ int num_students; int yr_grad; };

and we have an instance of a class* curr_class (class pointer), then to get access to number of students we would do

cout << curr_class->num_students << endl;

In case we had a simple class object , say class_2016, we would do

cout << class_2016.num_students << endl;

For the pointer to class the -> operator is equivalent to

(*obj).mem_var

Note: For a class, the way to access member functions of the class will also be the same way

What is the difference between the dot (.) operator and -> in C++?

14 Answers14

Linked

Related