When do I use a dot, arrow, or double colon to refer to members of a class in C++?

Question

Coming from other C-derived languages (like Java or C#) to C++, it is at first very confusing that C++ has three ways to refer to members of a class: a::b, a.b, and a->b. When do I use which one of these operators?

_{_(Note: This is meant to be an entry to [Stack Overflow's C++ FAQ](https://stackguides.com/questions/tagged/c++-faq). If you want to critique the idea of providing an FAQ in this form, then [the posting on meta that started all this](https://meta.stackexchange.com/questions/68647/setting-up-a-faq-for-the-c-tag) would be the place to do that. Answers to that question are monitored in the [C++ chatroom](https://chat.stackoverflow.com/rooms/10/c-lounge), where the FAQ idea started out in the first place, so your answer is very likely to get read by those who came up with the idea.)_}

Answer 1

The three distinct operators C++ uses to access the members of a class or class object, namely the double colon ::, the dot ., and the arrow ->, are used for three different scenarios that are always well-defined. Knowing this allows you to immediately know quite a lot about a and b just by looking at a::b, a.b, or a->b, respectively, in any code you look at.

1. a::b is only used if b is a member of the class (or namespace) a. That is, in this case a will always be the name of a class (or namespace).

2. a.b is only used if b is a member of the object (or reference to an object) a. So for a.b, a will always be an actual object (or a reference to an object) of a class.

3. a->b is, originally, a shorthand notation for (*a).b. However, -> is the only of the member access operators that can be overloaded, so if a is an object of a class that overloads operator-> (common such types are smart pointers and iterators), then the meaning is whatever the class designer implemented. To conclude: With a->b, if a is a pointer, b will be a member of the object the pointer a refers to. If, however, a is an object of a class that overloads this operator, then the overloaded operator function operator->() gets invoked.

---

The small print:

• ^{In C++, types declared as class, struct, or union are considered "of class type". So the above refers to all three of them.}
• ^{References are, semantically, aliases to objects, so I should have added "or reference to a pointer" to the #3 as well. However, I thought this would be more confusing than helpful, since references to pointers (T*&) are rarely ever used.}
• ^{The dot and arrow operators can be used to refer to static class members from an object, even though they are not members of the object. (Thanks to Oli for pointing this out!)}

Answer 2

_{Suggesting an alternative for sbi's point 3}

a->b is only used if a is a pointer. It is a shorthand for (*a).b, the b member of the object that a points to. C++ has two kinds of pointers, "regular" and smart pointers. For regular pointers such as A* a, the compiler implements ->. For smart pointers such as std::shared_ptr<A> a, -> is a member function of class shared_ptr.

Rationale: the target audience of this FAQ isn't writing smart pointers. They don't need to know -> is really called operator->(), or that it is the only member access method that can be overloaded.

Answer 3

Dot operator is used in direct member selection scenarios.

print(a.b)

Here, we are accessing b, which is a direct member of an object a. So, primarily, a is an object and b is a member (function/ variable etc) of a.

---

Arrow operator is used in indirect member selection scenarios.

print(a->b)

Here, we are accessing b which is a member of the object, that is pointed to by a. It is shorthand of (*a).b and so here, a is primarily a pointer to an object and b is a member of that object.

---

Double Colon (Scope) operator is used in namespace related direct member selection scenarios.

print(a::b)

Here, we are accessing b which is a member of the class/namespace a.So, primarily, a is a class/namespace and b is a member (function/ variable etc) of a.

Answer 4

#include <iostream>
#include <string>

using namespace std;

class Human {
private:
    int age;

public:
    string name;

    Human(int humanAge, string humanName) 
         : age(humanAge), name(std::move(humanName)) {}

    void DoSomething() {
        cout << age << endl;
    }

    static void DisplayAge(const Human& person) {
        cout << person.age << endl;
    }

    // ...
};

int main() {
    // Usage of Dot(.) 
    Human firstMan(13, "Jim"); // firstMan is an instance of class Human
    cout << firstMan.name << endl; // accessing member attributes
    firstMan.DoSomething(); // accessing member functions

    // Usage of Pointer Operator (->)
    Human* secondMan = new Human(24, "Tom");
    cout << secondMan->name << endl; // accessing member attributes
    secondMan->DoSomething(); // accessing member functions
    cout << (*secondMan).name << endl; // accessing member attributes
    (*secondMan).DoSomething(); // accessing member functions

    // Usage of Double Colon (::)
    Human::DisplayAge(firstMan);
    firstMan.DisplayAge(firstMan); // ok but not recommended
    secondMan->DisplayAge(firstMan); // ok but not recommended

    delete(secondMan);

    return 0;
}

From the coding example above, we see that:
* Accessing members(attributes and functions) from an instance(or object) using the dot operator (.)
* Accessing members(attributes and functions) from a pointer to an object(or created by new) using the pointer operator (->)
* Accessing static member functions from class itself without having an object as a handle using the double colon (::). [Note: you can also invoke the static member function from a instance with . or -> which is not recommended]