Pointer Member Access

The -> (arrow) token in C++ serves four distinct grammatical purposes: as a member access operator used to access members through a pointer, as a syntactic indicator for trailing return types in function declarations and lambda expressions, as a return-type-requirement specifier within C++20 compound requirements, and as the yield indicator in C++17 user-defined deduction guides.

1. Member Access Operator

As a member access operator, -> combines pointer dereferencing and member access into a single, left-to-right associative operation.

pointer->member_name

For raw pointers, the arrow operator is strictly equivalent to dereferencing the pointer with the * operator and then accessing the member using the . (dot) operator.

ptr->member;
// For raw pointers, this is exactly equivalent to:
(*ptr).member;

The -> operator exists primarily to circumvent operator precedence rules. Because the member access operator (.) has higher precedence than the dereference operator (*), the parentheses in (*ptr).member are strictly required. The -> operator eliminates this syntactic requirement.

Note that for user-defined types, operator-> and operator* are overloaded independently. While it is a standard convention to maintain semantic equivalence between them, the C++ language does not enforce it.

Mechanics and Resolution

The compiler resolves the -> operator differently depending on whether the left-hand operand is a raw pointer or a user-defined type.

Built-in Operator (Raw Pointers) When the left operand is a raw pointer, the built-in -> operator is invoked. The resolution depends on the nature of the member being accessed:

• Data Members and Non-Virtual Functions: For standard layout types and non-virtual inheritance, the compiler calculates the static memory offset of the specified member relative to the base address held by the pointer. For members of virtual base classes, the memory offset is dynamic and must be resolved at runtime (typically via a vtable or vbase pointer) because the offset depends on the most derived object’s layout.
• Virtual Member Functions: The compiler generates code to perform dynamic dispatch (typically via a vtable lookup at runtime) to resolve and invoke the correct function implementation based on the dynamic type of the object.
• Pseudo-Destructors: The left-hand operand can be a pointer to a scalar type when invoking a pseudo-destructor. This is a syntactic construct that allows scalar types to be treated uniformly with class types in generic code.

using T = int;
T* p = new T;
p->~T(); // Pseudo-destructor invocation

Overloaded Operator (User-Defined Types) When the left operand is an object of a class or struct, the -> operator can be overloaded. The overload must be implemented as a member function.

Historically, an overloaded operator-> had to be an implicit object member function taking no arguments. As of C++23’s “Deducing this” feature, it can also be implemented as an explicit object member function, which takes exactly one argument (the explicit object parameter).

struct Target { int data; };

// Pre-C++23 approach (Implicit object parameter)
class WrapperClassic {
    Target* raw_ptr;
public:
    Target* operator->() const { return raw_ptr; }
};

// C++23 approach (Explicit object parameter)
class WrapperCpp23 {
    Target* raw_ptr;
public:
    Target* operator->(this const WrapperCpp23& self) { return self.raw_ptr; }
};

Recursive Evaluation (Drill-down Behavior) Unlike most overloaded operators in C++, the overloaded -> operator exhibits unique recursive behavior. When the compiler encounters object->member, it evaluates it as (object.operator->())->member.

If the return type of operator->() is:

1. A raw pointer: The compiler applies the built-in -> operator to that raw pointer to access the member.
2. Another object (or reference to an object): The compiler recursively invokes operator->() on the returned entity. This chain continues indefinitely until a raw pointer is eventually returned, at which point the built-in member access is finalized.

Type Constraints

• The left-hand operand must be a pointer to a complete class/struct/union type, a pointer to a scalar type (for pseudo-destructors), or an object of a class type that overloads operator->.
• The right-hand operand must name a valid member of the type pointed to by the left-hand operand (or the type eventually yielded by the overload chain), or a valid pseudo-destructor.
• An overloaded operator-> must return a pointer, an object that itself overloads operator->, or a reference to such a pointer or object.

2. Trailing Return Type Indicator

Introduced in C++11, the -> token is used in function declarations and lambda expressions to specify a trailing return type. In this context, it is not an operator but a structural component of the declarator syntax.

// Standard function declaration
auto function_name(int arg1, double arg2) -> double;

// Lambda expression
auto lambda = [](int arg) -> double { return arg * 2.0; };

When used in a standard function declaration, the -> token follows the function’s parameter list and precedes the actual return type, and the declaration must utilize the auto placeholder type specifier. The declaration can begin with other specifiers such as static, virtual, inline, constexpr, or friend before the auto keyword appears.

Conversely, lambda expressions heavily use the -> token to specify trailing return types without requiring the auto keyword.

template <typename T, typename U>
static inline auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

3. Return-Type-Requirement (C++20)

Introduced in C++20, the -> token serves a grammatical purpose within requires expressions. It is used to specify a return-type-requirement in a compound requirement.

{ expression } -> concept_name;

In this context, the -> token separates an expression (enclosed in braces) from a concept constraint. It dictates that the expression must be syntactically valid, and the type yielded by evaluating that expression must satisfy the specified concept.

template <typename T>
concept StringLike = requires(T a) {
    // The result of a.c_str() must satisfy std::same_as<const char*>
    { a.c_str() } -> std::same_as<const char*>;
};

4. User-Defined Deduction Guides (C++17)

Introduced in C++17, the -> token is used to define user-defined deduction guides. These guides instruct the compiler on how to deduce template arguments for a class template based on the arguments passed to its constructor.

ExplicitSpecifier(optional) TemplateName(Parameters) -> TemplateName<Arguments>;

In this context, the -> token maps a specific constructor signature to a specific instantiation of the class template.

template <typename T>
struct Wrapper {
    Wrapper(T val) {}
};

// User-defined deduction guide
// Maps a const char* constructor argument to a Wrapper<std::string> instantiation
Wrapper(const char*) -> Wrapper<std::string>;

Master C++ with Deep Grasping Methodology!

Learn More