Member access operators

Accesses a member of its operand.

Explanation

Built-in subscript operator provides access to an object of function pointed-to by the pointer or array operand.

Built-in indirection operator provides access to an object or function pointed-to by the pointer operand.

Built-in address-of operator creates a pointer pointing to the object or function operand.

Member of object and pointer to member of object operators provide access to a member object or member function of the class operand.

Built-in member of pointer and pointer to member of pointer operators provide access to a member object or member function of the class pointed-to by the pointer operand.

Built-in subscript operator

For every object type T (possibly cv-qualified), the following function signature participates in overload resolution:

T& operator[](T*, std::ptrdiff_t);

T& operator[](std::ptrdiff_t, T*);

The non-pointer operand may be any expression of integral or unscoped enumeration type, it is implicitly converted to std::ptrdiff_t. The expression E1[E2] is exactly identical to the expression *(E1 + E2), that is, the pointer operand (which may be a result of array-to-pointer conversion, and which must point to an element of some array or one past the end) is adjusted to point to another element of the same array, following the rules of pointer arithmetics, and is then dereferenced.

When applied to an array, the subscript expression is an lvalue if the array is an lvalue, and an xvalue if it isn't (since C++11). When applied to a pointer, the subscript expression is always an lvalue.

The type T is not allowed to be an incomplete type, even if the size or internal structure of T is never used, as in &x[0].

#include <iostream>
 
int main()
{
    int a[4] = {1, 2, 3, 4};
    int* p = &a[2];
    std::cout << p[1] << p[-1] << 1[p] << (-1)[p] << '\n';
}

4242

Built-in indirection operator

For every type T that is either object type (possibly cv-qualified) or function type (not const- or ref-qualified), the following function signature participates in overload resolution:

T& operator*(T*);

The operand of the built-in indirection operator is a pointer to object or function, and the result is the lvalue that the pointer is pointing to. Note that a pointer to incomplete type can be dereferenced, e.g. when initializing a reference.

#include <iostream>
 
int f() { return 42; }
 
int main()
{
    int n = 1;
    int* pn = &n;
 
    int& r = *pn;  // lvalue can be bound to a reference
    int m = *pn;   // indirection + lvalue-to-rvalue conversion
 
    int (*fp)() = &f;
    int (&fr)() = *fp; // function lvalue can be bound to a reference 
}

Built-in address-of operator

The operand of the built-in operator& is either an lvalue expression of any type or the qualified name of a non-static member object or member function in some class. This operator does not participate in overload resolution. If there are no viable functions, special rules are used:

• If the operand is an lvalue expression of some type T, operator& creates and returns a prvalue of type T*, with the same cv qualification, that is pointing to the object designated by the operand. If the operand has incomplete type, the pointer can be formed, but if that incomplete type happens to be a class that defines its own operator&, the behavior is undefined (until C++14) it is unspecified whether the built-in or the overload is used (since C++14). For the operands of type with user-defined operator&, std::addressof may be used to obtain the true pointer.
• If the operand is the name of an overloaded function, the address may be taken only if the overload can be resolved due to context. See Address of an overloaded function for details.
• If the operand is a qualified name of a non-static member, e.g. &C::member, the result is a prvalue pointer to member function or pointer to member object of type T in class C. Note that neither &member nor C::member nor even &(C::member) may be used to initialize a pointer to member.

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
 
int main()
{
    int n = 1;
    int* pn = &n; // pointer
    int A::* mp = &A::i; // pointer to member object
    void (B::*mpf)() = &B::f; // pointer to member function
 
    void (*pf)(int) = &f; // overload resolution due to initialization context
//  auto pf2 = &f; // error: ambiguous overloaded function type
    auto pf2 = static_cast<void (*)(int)>(&f); // overload resolution due to cast
}

Built-in member access operators

The first operand of the operator. is an expression of complete class type T. The first operand of the built-in operator-> is an expression of pointer to complete class type T*. The first operand of both operators is evaluated even if it is not necessary (e.g. when the second operand names a static member).

The second operand of both operators is a name of (formally, an id-expression that names) a member object or member function of T or of an unambiguous and accessible base class B of T (e.g. E1.E2 or E1->E2), optionally qualified (e.g. E1.B::E2 or E1->B::E2), optionally using template disambiguator (e.g. E1.template E2 or E1->template E2).

If a user-defined operator-> is provided, the operator-> is called again on the value that it returns, recursively, until an operator-> is reached that returns a plain pointer. After that, built-in semantics are applied to that pointer.

The expression E1->E2 is exactly equivalent to (*E1).E2 for built-in types; that is why the following rules address only E1.E2.

In the expression E1.E2:

1) if E2 is a static data member:

• if E2 is of reference type T& or T&&, the result is an lvalue of type T designating the object or function to which E2 refers,
• otherwise, the result is an lvalue designating that static data member.

Essentially, E1 is evaluated and discarded in both cases; 2) if E2 is a non-static data member:

• if E2 is of reference type T& or T&&, the result is an lvalue of type T designating the object or function to which E2 refers,
• otherwise, if E1 is an lvalue, the result is an lvalue designating that non-static data member of E1,
• otherwise (if E1 is an rvalue), the result is an rvalue (until C++11)xvalue (since C++11) designating that non-static data member of E1.

If E2 is not a mutable member, the cv-qualification of the result is the union of the cv-qualifications of E1 and E2, otherwise (if E2 is a mutable member), it is the union of the volatile-qualifications of E1 and E2;

#include <iostream>
 
struct P
{
    template<typename T>
    static T* ptr() noexcept { return new T; }
};
 
template<typename T>
struct A
{
    A(int n): n(n) {}
    int n;
    static int sn;
    int f() { return 10 + n; }
    static int sf() { return 4; }
    class B {};
    enum E {RED = 1, BLUE = 2};
 
    void g()
    {
        typedef int U;
        // keyword template needed for a dependent template member
        int* p = T().template ptr<U>();
        p->~U(); // U is int, calls int's pseudo destructor
        delete p;
    }
};
template<> int A<P>::sn = 2;
 
int main()
{
    A<P> a(1);
    std::cout << a.n << ' '
              << a.sn << ' '   // A::sn also works
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf() also works
//            << a.B << ' '    // error: nested type not allowed
              << a.RED << ' '; // enumerator
}

1 2 11 4 1

Built-in pointer-to-member access operators

The first operand of the operator.* is an expression of class type T. The first operand of the operator->* is an expression of type pointer to class type T*.

The second operand of both operators is an expression of type pointer to member of T or pointer to member of an unambiguous and accessible base class B of T.

For every combination of types D, B, R, where class type B is either the same class as D or an unambiguous and accessible base class of D, and R is either an object or function type, the following function signature participates in overload resolution:

R& operator->*(D*, R B::*);

where both operands may be cv-qualified, in which case the return type's cv-qualification is the union of the cv-qualification of the operands.

The expression E1->*E2 is exactly equivalent to (*E1).*E2 for built-in types; that is why the following rules address only E1.*E2.

In the expression E1.*E2:

1) if E2 is a pointer to data member,

• if E1 is an lvalue, the result is an lvalue designating that data member,
• otherwise (if E1 is an rvalue), the result is an rvalue (until C++11)xvalue (since C++11) designating that data member;

#include <iostream>
 
struct S
{
    S(int n): mi(n) {}
    mutable int mi;
    int f(int n) { return mi + n; }
};
 
struct D: public S
{
    D(int n): S(n) {}
};
 
int main()
{
    int S::* pmi = &S::mi;
    int (S::* pf)(int) = &S::f;
 
    const S s(7);
//  s.*pmi = 10; // error: cannot modify through mutable
    std::cout << s.*pmi << '\n';
 
    D d(7); // base pointers work with derived object
    D* pd = &d;
    std::cout << (d.*pf)(7) << ' '
              << (pd->*pf)(8) << '\n';
}

7
14 15

Standard library

Subscript operator is overloaded by many standard container classes.

The indirection and member operators are overloaded by many iterators and smart pointer classes.

No standard library classes overload operator& or operator->*. The best known example of overloaded operator& is the Microsoft COM class CComPtr. operator->* is sometimes overloaded by third-party custom smart pointers.

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also

Operator precedence.

Operator overloading.