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

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

Объяснение

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

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

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

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

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

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

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

Встроенное выражение индексации 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.

Указатель на (возможно, с квалификаторами 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
}

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

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

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

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
}

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

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

expr оценивается даже если это не обязательно (например, когда второй операнд обозначает статический член).

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

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

Выражение 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 (который может быть материализован из prvalue)(с C++17)), результат — rvalue(до C++11)xvalue(с C++11) обозначающий этот нестатический член данных E1.

оператор. не может быть перегружен, и для 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.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 является нестатическим членом, а результат 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 должно быть значением правого типа указатель на член (данных или функций) T или указателем на член явного и доступного базового класса B объекта T.

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

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

• если E1 является значением lvalue, результат — значение lvalue, обозначающее этот член данных,
• в противном случае (если E1 является правым значением(до C++17)xvalue (которое может быть овеществлено из prvalue)(с C++17)), результат — правое значение(до 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

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

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

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

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

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

Примечания

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

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

См. также

Порядок действий операторов

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