Member access operators

Accesses a member of its operand.

Explanation

Built-in subscript operator provides access to an object 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 data member or member function of the object operand.

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

Built-in subscript operator

The subscript operator expressions have the form

The built-in subscript expression E1 [ E2 ] is exactly identical to the expression * ( E1 + E2 ) except for its value category (see below) and evaluation order (since C++17) : 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 arithmetic , 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 ] .

In overload resolution against user-defined operators , for every object type T (possibly cv-qualified), the following function signature participates in overload resolution:

#include <iostream>
#include <map>
#include <string>
int main()
{
    int a[4] = {1, 2, 3, 4};
    int* p = &a[2];
    std::cout << p[1] << p[-1] << 1[p] << (-1)[p] << '\n';
    std::map<std::pair<int, int>, std::string> m;
    m[{1, 2}] = "abc"; // uses the [{...}] version
}

4242

Built-in indirection operator

The indirection operator expressions have the form

The operand of the built-in indirection operator must be pointer to object or a pointer to function, and the result is the lvalue referring to the object or function to which expr points. If expr does not actually points to an object or function, the behavior is undefined (except for the case specified by typeid ).

A pointer to (possibly cv -qualified) void cannot be dereferenced. Pointers to other incomplete types can be dereferenced, but the resulting lvalue can only be used in contexts that allow an lvalue of incomplete type, e.g. when initializing a reference.

In overload resolution against user-defined operators , 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:

#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
    [](...){}(r, m, fr); // removes possible "unused variable" warnings
}

Built-in address-of operator

The address-of operator expressions have the form

In overload resolution against user-defined operators , this operator does not introduce any additional function signatures: built-in address-of operator does not apply if there exists an overloaded operator & that is a viable function .

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &n;    // pointer
    int* pn2 = &*pn; // pn2 == pn
    int A::* mp = &A::i;      // pointer to data member
    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 member access operator expressions have the form

id-expr is a name of (formally, an identifier expression that names) a data member 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 called, operator - > is called again on the resulting value, 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 :

operator. cannot be overloaded, and for operator - > , in overload resolution against user-defined operators , the built-in operator does not introduce any additional function signatures: built-in operator - > does not apply if there exists an overloaded operator - > that is a viable function .

#include <cassert>
#include <iostream>
#include <memory>
struct P
{
    template<typename T>
    static T* ptr() { 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;
struct UPtrWrapper
{
    std::unique_ptr<std::string> uPtr;
    std::unique_ptr<std::string>& operator->() { return uPtr; }
};
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.f << ' '   // error: ill-formed if a.f is not the
                               // left-hand operand of operator()
//            << a.B << ' '    // error: nested type not allowed
              << a.RED << ' '; // enumerator
    UPtrWrapper uPtrWrap{std::make_unique<std::string>("wrapped")};
    assert(uPtrWrap->data() == uPtrWrap.operator->().operator->()->data());
}

1 2 11 4 1

If E2 is a non-static member and the result of E1 is an object whose type is not similar to the type of E1 , the behavior is undefined:

struct A { int i; };
struct B { int j; };
struct D : A, B {};
void f()
{
    D d;
    static_cast<B&>(d).j;      // OK, object expression designates the B subobject of d
    reinterpret_cast<B&>(d).j; // undefined behavior
}

Built-in pointer-to-member access operators

The member access operator expressions through pointers to members have the form

rhs must be an rvalue of type pointer to member ( data or function ) of T or pointer to member of an unambiguous and accessible base class B of T .

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 :

In overload resolution against user-defined operators , 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:

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.

#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 & . The best known example of overloaded operator & is the Microsoft COM class CComPtr , although it can also appear in EDSLs such as boost.spirit .

No standard library classes overload operator - > * . It was suggested that it could be part of smart pointer interface , and in fact is used in that capacity by actors in boost.phoenix , but is more common in EDSLs such as cpp.react .

Notes

Defect reports

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

See also

Operator precedence

Operator overloading