Операторы доступа к членам

Обеспечивает доступ к члену своего операнда.

Пояснение

Встроенный оператор индексации обеспечивает доступ к объекту, на который указывает операнд-указатель или операнд-массив.

Встроенный оператор разыменования обеспечивает доступ к объекту или функции, на которые указывает операнд-указатель.

Встроенный оператор взятия адреса создаёт указатель, указывающий на объект или функцию-операнд.

Операторы члена объекта и указателя на член объекта обеспечивают доступ к члену данных или функции-члену операнда-объекта.

Встроенные операторы члена указателя и указателя на член указателя обеспечивают доступ к члену данных или функции-члену класса, на который указывает операнд-указатель.

Встроенный оператор индексации

Выражения с оператором индексации имеют вид

Встроенное выражение индексации E1[E2] в точности тождественно выражению *(E1 + E2), за исключением категории значения (см. ниже) и порядка вычисления(начиная с C++17): операнд-указатель (который может быть результатом преобразования массива в указатель и должен указывать на элемент массива или на позицию сразу за его последним элементом) корректируется так, чтобы указывать на другой элемент того же массива согласно правилам арифметики указателей, после чего выполняется разыменование.

При применении к массиву выражение индексации является lvalue, если массив является lvalue, и xvalue, если это не так(начиная с C++11).

При применении к указателю выражение индексации всегда является lvalue.

Тип T не может быть неполным типом, даже если размер или внутренняя структура T никогда не используются, как в &x[0].

При разрешении перегрузки для пользовательских операторов для каждого типа объекта T (возможно, с квалификаторами cv) в разрешении перегрузки участвует следующая сигнатура функции:

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

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

#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

Встроенный оператор разыменования

Выражения с оператором разыменования имеют вид

Операндом встроенного оператора разыменования должен быть указатель на объект или указатель на функцию; результатом является lvalue, ссылающееся на объект или функцию, на которые указывает expr. Если expr в действительности не указывает на объект или функцию, поведение не определено (кроме случая, указанного для typeid).

Указатель на (возможно, cv-квалифицированный) void разыменовать нельзя. Указатели на другие неполные типы разыменовывать можно, однако результирующее lvalue может использоваться только в контекстах, допускающих lvalue неполного типа, например при инициализации ссылки.

При разрешении перегрузки для пользовательских операторов для каждого типа T, который является типом объекта (возможно, с квалификаторами cv) или типом функции (без квалификаторов const или ref), в разрешении перегрузки участвует следующая сигнатура функции:

T& operator*(T*);

#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
}

Встроенный оператор взятия адреса

Выражения с оператором взятия адреса имеют вид

Если операнд обозначает перегруженную функцию или шаблон функции, адрес можно получить только в том случае, если перегрузку можно разрешить исходя из контекста. Подробности см. в разделе Адрес перегруженной функции.

При разрешении перегрузки для пользовательских операторов этот оператор не добавляет никаких дополнительных сигнатур функций: встроенный оператор взятия адреса не применяется, если существует перегруженный operator&, являющийся подходящей функцией.

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
}

Встроенные операторы доступа к членам

Выражения с оператором доступа к члену имеют вид

id-expr — это имя (формально — выражение-идентификатор, обозначающее) члена T или однозначного и доступного базового класса B типа T (например, E1.E2 или E1->E2), возможно, квалифицированное (например, E1.B::E2 или E1->B::E2), а также, возможно, содержащее дизамбигуатор template (например, E1.template E2 или E1->template E2).

Если вызывается пользовательский operator->, к полученному значению рекурсивно снова применяется operator->, пока не будет достигнут operator->, возвращающий обычный указатель. После этого к этому указателю применяются встроенные правила.

Для встроенных типов выражение E1->E2 в точности эквивалентно (*E1).E2; поэтому следующие правила относятся только к E1.E2.

В выражении E1.E2:

• Если E2 имеет ссылочный тип T& или T&&(начиная с C++11), результатом является lvalue типа T, обозначающее объект или функцию, на которые привязана ссылка.
• В противном случае, если тип E2 обозначить как T, результатом является lvalue типа T, обозначающее этот статический член данных.

• Если E2 имеет ссылочный тип T& или T&&(начиная с C++11), результатом является lvalue типа T, обозначающее объект или функцию, на которые привязан соответствующий ссылочный член E1.
• В противном случае, если E1 является lvalue, результатом является lvalue, обозначающее этот нестатический член данных E1.
• В противном случае (если E1 является rvalue(до C++17 включительно)xvalue (которое может быть материализовано из пр-значения)(начиная с C++17)), результатом является rvalue(до C++11 включительно)xvalue(начиная с C++11), обозначающее этот нестатический член данных E1.

• Если E2 является статической функцией-членом, результатом является lvalue, обозначающее эту статическую функцию-член. В этом случае E1 вычисляется, а результат отбрасывается.
• В противном случае (E2 является нестатической функцией-членом) результатом является пр-значение, обозначающее эту нестатическую функцию-член E1.

struct B { int b; };
struct C : B { int get() const { return b; } };
struct D : B, C {};
constexpr int f() {
    D d = {1, {}};

    constexpr auto ctx = std::meta::access_context::current();

    // b unambiguously refers to the direct base class of type B,
    // not the indirect base class of type B
    B& b = d.[: std::meta::bases_of(^^D, ctx)[0] :];
    b.b += 10;
    return 10 * b.b + d.get();
}

static_assert(f() == 110);

operator. нельзя перегружать, а для operator-> при разрешении перегрузки для пользовательских операторов встроенный оператор не добавляет никаких дополнительных сигнатур функций: встроенный operator-> не применяется, если существует перегруженный operator->, являющийся подходящей функцией.

#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

Если E2 является нестатическим членом или отношением прямого базового класса(начиная с C++26), а результат E1 — это объект, тип которого не подобен типу E1, поведение не определено:

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
}

Встроенные операторы доступа через указатель на член

Выражения доступа к члену через указатели на члены имеют вид

rhs должно быть rvalue типа «указатель на член» (данных или функцию) типа T либо указателем на член однозначного и доступного базового класса B типа T.

Для встроенных типов выражение E1->*E2 в точности эквивалентно (*E1).*E2; поэтому следующие правила относятся только к E1.*E2.

В выражении E1.*E2:

• если E1 является lvalue, результатом является lvalue, обозначающее этот член данных;
• в противном случае (если E1 является rvalue(до C++17 включительно)xvalue (которое может быть материализовано из пр-значения)(начиная с C++17)), результатом является rvalue(до C++11 включительно)xvalue(начиная с C++11), обозначающее этот член данных;

При разрешении перегрузки для определённых пользователем операторов для каждой комбинации типов D, B, R, где тип класса B является либо тем же классом, что и D, либо однозначным и доступным базовым классом D, а R является типом объекта или функции, в разрешении перегрузки участвует следующая сигнатура функции:

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

Оба операнда могут иметь cv-квалификаторы; в этом случае cv-квалификация возвращаемого типа представляет собой объединение cv-квалификаций операндов.

#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

Стандартная библиотека

Оператор индексирования перегружен во многих классах стандартных контейнеров:

Операторы разыменования и доступа к членам перегружены во многих классах итераторов и умных указателей:

Ни один класс стандартной библиотеки не перегружает operator&. Наиболее известный пример перегруженного operator& — класс Microsoft COM CComPtr, хотя этот оператор также встречается в EDSL, таких как boost.spirit.

Ни один класс стандартной библиотеки не перегружает operator->*. Предлагалось использовать его как часть интерфейса умного указателя; и действительно, эту роль он выполняет у акторов в boost.phoenix, однако чаще он встречается в EDSL, таких как cpp.react.

Примечания

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

См. также

Приоритет операторов

Перегрузка операторов

a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b

a[...]
*a
&a
a->b
a.b
a->*b
a.*b