Member access operators

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

Объяснение

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

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

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

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

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

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

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

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

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

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

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

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

#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"; // использует версию [{...}]
}

4242

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

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

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

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

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

#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
    int& r = *pn; // lvalue может быть связано со ссылкой
    int m = *pn;  // косвенное обращение + преобразование lvalue-to-rvalue
    int (*fp)() = &f;
    int (&fr)() = *fp; // function lvalue может быть связано со ссылкой
    [](...){}(r, m, fr); // убирает возможные предупреждения "неиспользуемая переменная"
}

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

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

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

void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &n;    // указатель
    int* pn2 = &*pn; // pn2 == pn
    int A::* mp = &A::i;      // указатель на член данных
    void (B::*mpf)() = &B::f; // указатель на член-функцию
    void (*pf)(int) = &f; // разрешение перегрузки из-за контекста инициализации
//  auto pf2 = &f; // ошибка: неоднозначный перегруженный тип функции
    auto pf2 = static_cast<void (*)(int)>(&f); // разрешение перегрузки из-за приведения типа
}

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

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

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 :

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;
        // ключевое слово template необходимо для зависимого шаблонного члена
        int* p = T().template ptr<U>();
        p->~U(); // U - это int, вызывает псевдодеструктор int
        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 также работает
              << a.f() << ' ' 
              << a.sf() << ' ' // A::sf() также работает
//            << &a.f << ' '   // ошибка: некорректно, если a.f не является
                               // левым операндом operator()
//            << a.B << ' '    // ошибка: вложенный тип не разрешен
              << a.RED << ' '; // перечислитель
    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, выражение объекта обозначает B подобъект d
    reinterpret_cast<B&>(d).j; // неопределённое поведение
}

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

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

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

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

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

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

где оба операнда могут быть 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); // базовые указатели работают с производными объектами
    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++.

Смотрите также

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

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