Member access operators

访问其操作数的成员。

说明

内置的 下标 运算符提供对由 指针 或 数组 操作数所指向对象的访问。

内置的 间接寻址 运算符提供对指针操作数所指向对象或函数的访问。

内置的 取址 运算符创建一个指向对象或函数操作数的指针。

对象成员 和 对象成员指针 运算符提供对对象操作数的数据成员或成员函数的访问。

内置的 成员指针 和 指向成员指针的指针 运算符提供对指针操作数所指向类的数据成员或成员函数的访问。

内置下标运算符

下标运算符表达式的形式

内置的下标表达式 E1 [ E2 ] 与表达式 * ( E1 + E2 ) 完全等同，除了其值类别（见下文） 以及 求值顺序 (C++17 起) ：指针操作数（可能是数组到指针转换的结果，且必须指向某个数组的元素或尾后位置）会按照 指针算术 规则调整至指向同一数组的另一元素，随后进行解引用。

当应用于数组时，下标表达式是一个 左值 （若该数组为左值），否则为 亡值 (C++11 起) 。

当应用于指针时，下标表达式始终是左值。

类型 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

内置间接寻址运算符

间接运算符表达式的形式为

内置间接操作符的操作数必须是指向对象的指针或指向函数的指针，其结果是引用 expr 所指向对象或函数的左值。若 expr 并未实际指向对象或函数，则行为未定义（除 typeid 规定的特殊情况外）。

指向（可能为 cv限定 ） void 的指针不能被解引用。指向其他不完整类型的指针可以被解引用，但产生的左值只能用于允许不完整类型左值的语境中，例如初始化引用时。

在 针对用户定义运算符的重载决议 中，对于每个类型 T （可以是对象类型（可能带有cv限定符）或函数类型（非const或引用限定）），以下函数签名会参与重载决议：

#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
    int& r = *pn; // 左值可以绑定到引用
    int m = *pn;  // 间接寻址 + 左值到右值转换
    int (*fp)() = &f;
    int (&fr)() = *fp; // 函数左值可以绑定到引用
    [](...){}(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 的数据成员或成员函数的名称（例如 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;      // 正确：对象表达式指向 d 的 B 子对象
    reinterpret_cast<B&>(d).j; // 未定义行为
}

内建成员指针访问运算符

指向成员的成员访问运算符表达式具有以下形式

rhs 必须是类型为指向 T 成员（ 数据 或 函数 ）的指针的右值，或指向 T 的无歧义且可访问基类 B 的成员指针的右值。

表达式 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 & 示例是微软 COM 类 CComPtr ，不过它也可能出现在 EDSL 中，例如 boost.spirit 。

标准库类没有重载 operator - > * 。有建议认为它可以作为 智能指针接口 的组成部分，实际上在 boost.phoenix 中的执行器就采用了这种用法，但在诸如 cpp.react 这类 EDSL 中更为常见。

注释

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

参见

运算符优先级

运算符重载