Accesses a member of its operand.

[edit]Explanation

Built-insubscript operator provides access to an object pointed-to by thepointer orarray operand.

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

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

Member of object andpointer to member of object operators provide access to a data member or member function of the object operand.

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

[edit]Built-in subscript operator

The subscript operator expressions have the form

The built-in subscript expressionE1[E2] is exactly identical to the expression*(E1+ E2) except for its value category (see below) andevaluation 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 ofpointer arithmetic, and is then dereferenced.

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

When applied to a pointer, the subscript expression is always an lvalue.

The typeT is not allowed to be anincomplete type, even if the size or internal structure ofT is never used, as in&x[0].

Inoverload resolution against user-defined operators, for every object typeT (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

[edit]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 whichexpr points. Ifexpr does not actually points to an object or function, the behavior is undefined (except for the case specified bytypeid).

A pointer to (possiblycv-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.

Inoverload resolution against user-defined operators, for every typeT 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(){return42;} int main(){int n=1;int* pn=&n; int& r=*pn;// lvalue can be bound to a referenceint 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}

[edit]Built-in address-of operator

The address-of operator expressions have the form

Inoverload 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 overloadedoperator& that is aviable function.

void f(int){}void f(double){} struct A{int i;};struct B{void f();}; int main(){int n=1;int* pn=&n;// pointerint* pn2=&*pn;// pn2 == pn int A::* mp=&A::i;// pointer to data membervoid(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 typeauto pf2=static_cast<void(*)(int)>(&f);// overload resolution due to cast}

[edit]Built-in member access operators

The member access operator expressions have the form

id-expr is a name of (formally, anidentifier expression that names) a data member or member function ofT or of an unambiguous and accessible base classB ofT (e.g.E1.E2 orE1->E2), optionallyqualified (e.g.E1.B::E2 orE1->B::E2), optionally usingtemplate disambiguator (e.g.E1.template E2 orE1->template E2).

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

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

In the expressionE1.E2:

operator. cannot be overloaded, and foroperator->, inoverload resolution against user-defined operators, the built-in operator does not introduce any additional function signatures: built-inoperator-> does not apply if there exists an overloadedoperator-> that is aviable 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;staticint sn; int f(){return10+ n;}staticint sf(){return4;} class B{};enum E{RED=1, BLUE=2}; void g(){typedefint U; // keyword template needed for a dependent template memberint* 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

IfE2 is a non-static member and the result ofE1 is an object whose type is notsimilar to the type ofE1, 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 dreinterpret_cast<B&>(d).j;// undefined behavior}

[edit]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 orfunction) ofT or pointer to member of an unambiguous and accessible base classB ofT.

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

In the expressionE1.*E2:

Inoverload resolution against user-defined operators, for every combination of typesD,B,R, where class typeB is either the same class asD or an unambiguous and accessible base class ofD, andR 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){}    mutableint 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 mutablestd::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';}

714 15

[edit]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 overloadoperator&. The best known example of overloadedoperator& is the Microsoft COM classCComPtr, although it can also appear in EDSLs such asboost.spirit.

No standard library classes overloadoperator->*. It was suggested that it could be part ofsmart pointer interface, and in fact is used in that capacity by actors inboost.phoenix, but is more common in EDSLs such ascpp.react.

[edit]Notes

[edit]Defect reports

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

[edit]See also

Operator precedence

Operator overloading

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文