成员访问运算符

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

命名需求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

C++ 语言

通用主题
预处理器 注释	关键字 转义序列
流程控制
条件执行语句
if	switch
迭代语句（循环）
for 范围 for (C++11)	while do-while
跳转语句
continue - break	goto - return
函数
函数声明
Lambda 函数表达式
内联 说明符
动态异常规范 (直到 C++17*)
noexcept 说明符 (C++11)
异常
throw 表达式 try 块	处理程序
命名空间
命名空间声明	命名空间别名
类型
基本类型 枚举类型 函数类型	类/结构体类型 联合类型
说明符
const/volatile decltype (C++11) auto (C++11)	constexpr (C++11) consteval (C++20) constinit (C++20)
存储期说明符
初始化
默认初始化 值初始化 零初始化 复制初始化 直接初始化	聚合初始化 列表初始化 (C++11)   常量初始化 引用初始化

表达式
值类别 求值顺序	运算符 运算符优先级
替代表示形式
字面量
布尔值 - 整数 - 浮点数
字符 - 字符串 - nullptr (C++11)
用户定义 (C++11)
实用程序
属性 (C++11)
类型
typedef 声明
类型别名声明 (C++11)
强制转换
隐式转换 static_cast const_cast	显式转换 dynamic_cast reinterpret_cast
内存分配
new 表达式	delete 表达式
类
类声明 构造函数 this 指针	访问说明符 friend 说明符
类特定函数属性
虚函数 override 说明符 (C++11)   final 说明符 (C++11)	explicit (C++11) 静态
特殊成员函数
默认构造函数 复制构造函数 移动构造函数 (C++11)	复制赋值 移动赋值 (C++11) 析构函数
模板
类模板 函数模板	模板特化 参数包 (C++11)
其他
内联汇编	C++ 历史

 

表达式

通用
值类别 求值顺序 常量表达式 主表达式	Lambda 表达式 (C++11) requires 表达式 (C++20) 包索引表达式 (C++26) 可能求值的表达式
字面量
整数字面量 浮点数字面量 布尔字面量 字符字面量	转义序列 字符串字面量 空指针字面量 (C++11) 用户定义字面量 (C++11)
运算符
赋值运算符 递增和递减 算术运算符 逻辑运算符 比较运算符 成员访问运算符 其他运算符 new 表达式 delete 表达式 throw 表达式	alignof sizeof sizeof... (C++11) typeid noexcept (C++11) 折叠表达式 (C++17) 运算符的替代表示 优先级和结合性 运算符重载 默认比较 (C++20)
转换
隐式转换 显式转换 算术转换     用户自定义转换	const_cast static_cast dynamic_cast reinterpret_cast

 

访问其操作数的成员。

运算符名称	语法	可重载	原型示例（对于 类 T）
			在类定义内	在类定义外
下标	a[b]	是	R& T::operator[](S b);	不适用
	a[...] (自 C++23 起)		R& T::operator[](...);
间接寻址	*a	是	R& T::operator*();	R& operator*(T a);
取地址	&a	是	R* T::operator&();	R* operator&(T a);
对象的成员	a.b	否	不适用	不适用
指针的成员	a->b	是	R* T::operator->();	不适用
指向对象成员的指针	a.*b	否	不适用	不适用
指向指针成员的指针	a->*b	是	R& T::operator->*(S b);	R& operator->*(T a, S b);
注意 与大多数用户定义的重载一样，返回类型应与内置运算符提供的返回类型匹配，以便 用户定义的运算符 可以像内置运算符一样使用。但是，在用户定义的运算符重载中，任何类型都可以用作返回类型（包括 void）。一个例外是 operator->，它必须返回一个指针或另一个重载了 operator-> 的类，以便实际可用。

说明

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

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

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

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

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

内置下标运算符

下标运算符表达式的形式为

expr1 [expr2 ]	(1)
expr1 [{expr , ...}]	(2)	（自 C++11 起）
expr1 [expr2 , expr , ...]	(3)	（自 C++23 起）

1) 对于内置运算符，其中一个表达式（expr1 或 expr2）必须是“T 数组”类型的左值或“指向 T 的指针”类型的纯右值，而另一个表达式（分别为 expr2 或 expr1）必须是无作用域枚举或整型的纯右值。此表达式的结果类型为 T。 expr2 不能是非括号括起来的 逗号表达式。(自 C++23 起)

2) 方括号内带有花括号括起来的列表的形式仅用于调用重载的 operator[]。

3) 方括号内带有逗号分隔的表达式列表的形式仅用于调用重载的 operator[]。

内置下标表达式 E1[E2] 与表达式 *(E1 + E2) 完全相同，除了其值类别（见下文） 和 求值顺序(自 C++17 起)：指针操作数（可能是数组到指针转换的结果，并且必须指向某个数组的元素或末尾之后的一个位置）被调整为指向同一数组的另一个元素，遵循 指针算术 的规则，然后被解引用。

当应用于数组时，如果数组是左值，则下标表达式是 左值；如果不是，则是 临终值(自 C++11 起)。

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

类型 T 不允许是不完整类型，即使 T 的大小或内部结构从未使用过，如 &x[0]。

不推荐使用没有括号的 逗号表达式 作为下标运算符的第二个（右侧）参数。 例如，不推荐使用 a[b, c]，而推荐使用 a[(b, c)]。	（自 C++20 起） （至 C++23）
没有括号的 逗号表达式 不能作为下标运算符的第二个（右侧）参数。例如，a[b, c] 要么是错误的，要么等效于 a.operator[](b, c)。 如果要将逗号表达式用作下标，则需要使用括号，例如 a[(b, c)]。	（自 C++23 起）

在针对用户定义运算符的 重载决议 中，对于每个对象类型 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

内置间接寻址运算符

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

*expr

内置间接寻址运算符的操作数必须是指向对象的指针或指向函数的指针，结果是引用 expr 所指向的对象或函数的左值。如果 expr 实际上没有指向对象或函数，则行为未定义（typeid 指定的情况除外）。

不能解引用指向（可能具有 cv 限定符的）void 的指针。可以解引用指向其他不完整类型的指针，但结果左值只能在允许使用不完整类型左值的上下文中使用，例如初始化引用时。

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

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
}

内置取地址运算符

取地址运算符表达式的形式为

&expr	(1)
&class ::member	(2)

1) 如果操作数是某个对象或函数类型 T 的左值表达式，则 operator& 会创建一个类型为 T* 的右值，并返回该右值，该右值具有相同的 cv 限定符，并指向操作数指定的对象或函数。如果操作数具有不完整类型，则可以形成指针，但如果该不完整类型恰好是定义了自己的 operator& 的类，则使用内置运算符还是重载运算符是未指定的。对于具有用户定义的 operator& 的类型的操作数，可以使用 std::addressof 来获取真正的指针。请注意，与 C99 及更高版本的 C 不同，对于应用于一元 operator* 结果的一元 operator&，没有特殊情况。

如果操作数是重载函数的名称，则只有在可以根据上下文解析重载的情况下才能获取地址。有关详细信息，请参阅重载函数的地址。

如果 expr 命名了一个 显式对象成员函数，则 expr 必须是一个 限定标识符。将 & 应用于命名显式对象成员函数的非限定标识符是非法的。

（自 C++23 起）

2) 如果操作数是非静态或 变体 成员（ 显式对象成员函数 除外（自 C++23 起））的限定名称，例如 &C::member，则结果是一个类型为 T 的右值 指向成员函数的指针 或 指向数据成员的指针，该指针位于类 C 中。请注意，&member、C::member 甚至 &(C::member) 都不能用于初始化指向成员的指针。

在针对用户定义运算符的 重载决议 中，此运算符不会引入任何其他函数签名：如果存在 可行函数 的重载 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
}

内置成员访问运算符

成员访问运算符表达式的形式为

expr .template（可选） id-expr	(1)
expr ->template（可选） id-expr	(2)
expr .pseudo-destructor	(3)
expr ->pseudo-destructor	(4)

1) expr 必须是 完整 类类型 T 的表达式。

如果 id-expr 命名了一个 静态成员 或 枚举器，则 expr 是一个 被丢弃值表达式。

2) expr 必须是指向完整类类型 T* 的指针表达式。

3,4) expr 必须是标量类型的表达式（见下文）。

id-expr 是数据成员或成员函数的名称（形式上，是命名数据成员或成员函数的标识符表达式） T 或 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 中

1) 如果 E2 是静态数据成员

• 如果 E2 的类型为引用类型 T& 或 T&&(C++11 起)，则结果是类型为 T 的左值，表示引用所绑定的对象或函数。
• 否则，给定 E2 的类型为 T，则结果是类型为 T 的左值，表示该静态数据成员。

本质上，在这两种情况下，E1 都会被求值并被丢弃。

2) 如果 E2 是非静态数据成员

• 如果 E2 的类型为引用类型 T& 或 T&&(C++11 起)，则结果是类型为 T 的左值，表示 E1 的相应引用成员所绑定的对象或函数。
• 否则，如果 E1 是左值，则结果是表示 E1 的该非静态数据成员的左值。
• 否则（如果 E1 是右值(截至 C++17)xvalue（可以从 prvalue物化）(C++17 起)），则结果是右值(截至 C++11)xvalue(C++11 起)，表示 E1 的该非静态数据成员。

如果 E2 不是可变成员，则结果的cv 限定是 E1 和 E2 的 cv 限定的并集，否则（如果 E2 是可变成员），则它是 E1 和 E2 的 volatile 限定的并集。

3) 如果 E2 是一个重载集（包含一个或多个静态成员函数和非静态成员函数），则 E1.E2 必须是成员函数调用运算符的（可能带括号的）左操作数，并且使用函数重载决议来选择 E2 引用的函数，之后

• 如果 E2 是静态成员函数，则结果是一个左值，表示该静态成员函数。本质上，在这种情况下，E1 会被求值并被丢弃。
• 否则（E2 是非静态成员函数），则结果是一个右值，表示 E1 的该非静态成员函数。

4) 如果 E2 是成员枚举器，给定 E2 的类型为 T，则结果是右值(截至 C++11)纯右值(C++11 起)，类型为 T，其值为枚举器的值。

5) 如果 E2 是嵌套类型，则程序格式错误。

6) 如果 E1 具有ScalarType 并且 E2 是 ~ 后跟类型名称或decltype 说明符，表示相同的类型（减去 cv 限定），可以选择限定，则结果是一种特殊的纯右值，只能用作函数调用运算符的左操作数，而不能用于其他目的

生成的函数调用表达式称为*伪析构函数调用*。它不带参数，返回 void，计算 E1，并结束其结果对象的生存期。这是 operator. 的左操作数具有非类类型的唯一情况。允许伪析构函数调用使得编写代码时无需知道给定类型是否存在析构函数成为可能。

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 是非静态成员，并且 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
}

内置指向成员的访问运算符

通过指向成员的指针进行成员访问的运算符表达式具有以下形式

lhs .*rhs	(1)
lhs ->*rhs	(2)

1) lhs 必须是类类型 T 的表达式。

2) lhs 必须是指向类类型 T* 的指针类型的表达式。

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

表达式 E1->*E2 与 (*E1).*E2 对于内置类型完全等效；这就是为什么以下规则仅针对 E1.*E2 的原因。

在表达式 E1.*E2 中

1) 如果 E2 是指向数据成员的指针，

• 如果 E1 是左值，则结果是一个左值，表示该数据成员，
• 否则（如果 E1 是右值（直到 C++17）临终值（可能由纯右值物化而来）（自 C++17 起）），则结果是右值（直到 C++11）临终值（自 C++11 起），表示该数据成员；

2) 如果 E2 是指向成员函数的指针，则结果是一种特殊的纯右值，表示该成员函数，它只能用作成员函数调用运算符的左操作数，而不能用于其他任何目的；

3) cv 限定规则与对象成员运算符相同，但有一条附加规则：引用可变成员的成员指针不能用于修改 const 对象中的该成员；

4) 如果 E2 是空指向成员的值，则行为未定义；

5) 如果结果 E1 是一个对象，其类型与 E1 的类型不相似，或者其最派生对象不包含 E2 引用的成员，则行为未定义；

6) 如果 E1 是右值，并且 E2 指向具有引用限定符 & 的成员函数，则程序格式错误，除非该成员函数具有 cv 限定符 const 但没有 volatile（自 C++20 起）；

7) 如果 E1 是左值，并且 E2 指向具有引用限定符 && 的成员函数，则程序格式错误。

（自 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[]	访问特定位 （std::bitset<N> 的公共成员函数）
operator[]	提供对托管数组的索引访问 （std::unique_ptr<T,Deleter> 的公共成员函数）
operator[]	访问指定的字符 （std::basic_string<CharT,Traits,Allocator> 的公共成员函数）
operator[]	访问指定元素 （std::array<T,N> 的公共成员函数）
operator[]	访问指定元素 （std::deque<T,Allocator> 的公共成员函数）
operator[]	访问指定元素 （std::vector<T,Allocator> 的公共成员函数）
operator[]	访问或插入指定元素 （`std::map<Key,T,Compare,Allocator>` 的公共成员函数）
operator[]	访问或插入指定元素 （`std::unordered_map<Key,T,Hash,KeyEqual,Allocator>` 的公共成员函数）
operator[]	通过索引访问元素 （`std::reverse_iterator<Iter>` 的公共成员函数）
operator[] （C++11）	通过索引访问元素 （`std::move_iterator<Iter>` 的公共成员函数）
operator[]	获取/设置 valarray 元素、切片或掩码 （`std::valarray<T>` 的公共成员函数）
operator[]	返回指定的子匹配 （`std::match_results<BidirIt,Alloc>` 的公共成员函数）

间接和成员运算符被许多迭代器和智能指针类重载

operator*operator->	解引用指向托管对象的指针 （`std::unique_ptr<T,Deleter>` 的公共成员函数）
operator*operator->	解引用存储的指针 （`std::shared_ptr<T>` 的公共成员函数）
operator*operator->	访问托管对象 （`std::auto_ptr<T>` 的公共成员函数）
operator*	解引用迭代器 （`std::raw_storage_iterator<OutputIt,T>` 的公共成员函数）
operator*operator->	解引用递减后的底层迭代器 （`std::reverse_iterator<Iter>` 的公共成员函数）
operator*	空操作 （`std::back_insert_iterator<Container>` 的公共成员函数）
operator*	空操作 （`std::front_insert_iterator<Container>` 的公共成员函数）
operator*	空操作 （`std::insert_iterator<Container>` 的公共成员函数）
operator*operator-> （C++11 起）（C++11 起）（C++20 起弃用）	访问指向的元素 （`std::move_iterator<Iter>` 的公共成员函数）
operator*operator->	返回当前元素 （`std::istream_iterator<T,CharT,Traits,Distance>` 的公共成员函数）
operator*	空操作 （`std::ostream_iterator<T,CharT,Traits>` 的公共成员函数）
operator*	获取当前字符的副本 （`std::istreambuf_iterator<CharT,Traits>` 的公共成员函数）
operator*	空操作 （`std::ostreambuf_iterator<CharT,Traits>` 的公共成员函数）
operator*operator->	访问当前匹配 （`std::regex_iterator<BidirIt,CharT,Traits>` 的公共成员函数）
operator*operator->	访问当前子匹配 （`std::regex_token_iterator<BidirIt,CharT,Traits>` 的公共成员函数）

没有标准库类重载 operator&。最著名的重载 operator& 的例子是微软 COM 类 CComPtr，尽管它也可能出现在 EDSLs 中，例如 boost.spirit。

没有标准库类重载 operator->*。有人建议它可以作为 智能指针接口 的一部分，并且实际上在 boost.phoenix 中的 actors 中以这种身份使用，但在 EDSLs 中更常见，例如 cpp.react。

注释

特性测试宏	值	标准	特性
__cpp_multidimensional_subscript	202110L	（C++23）	多维下标运算符

缺陷报告

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

缺陷报告	应用于	发布时的行为	正确行为
CWG 1213	C++11	对数组右值使用下标运算符会导致左值	重新分类为右值
CWG 1458	C++98	对声明了 operator& 的不完整类类型的左值应用 & 会导致 未定义行为	未指明 使用哪个 &
CWG 1642	C++98	内置成员指针访问运算符中的 rhs  可以是左值	只能是右值
CWG 1800	C++98	当对 成员匿名联合体的非静态数据成员应用 & 时，不清楚 匿名联合体是否参与结果类型	匿名联合体 不包含在 结果类型中
CWG 2614	C++98	如果 E2 是引用成员或枚举器，则 E1.E2 的结果不明确	已明确
CWG 2725	C++98	如果 E2 是静态成员函数，则 E1.E2 是良构的 即使它不是 operator() 的左操作数	E1.E2 是非良构的 在这种情况下
CWG 2748	C++98	如果 E1 是 空指针且 E2 引用静态成员，则 E1->E2 的行为不明确	在这种情况下，行为是 未定义的
CWG 2813	C++98	如果 E1.E2 命名静态成员或枚举器，则 E1 不是弃值表达式	它是
CWG 2823	C++98	如果 expr 不指向对象或函数，则 *expr 的行为不明确	已明确

另请参阅

运算符优先级

运算符重载

常用运算符
赋值	递增 递减	算术	逻辑	比较	成员 访问	其他
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	函数调用
						a(...)
						逗号
						a, b
						条件
						a ? b : c
特殊运算符
static_cast 将一种类型转换为另一种相关类型 dynamic_cast 在继承层次结构中转换 const_cast 添加或删除 cv 限定符 reinterpret_cast 将类型转换为不相关类型 C 风格类型转换 通过混合 static_cast、const_cast 和 reinterpret_cast 将一种类型转换为另一种类型 new 创建具有动态存储期的对象 delete 销毁先前由 new 表达式创建的对象并释放获取的内存区域 sizeof 查询类型的长度 sizeof... 查询 参数包 的长度 （自 C++11 起） typeid 查询类型的类型信息 noexcept 检查表达式是否可以抛出异常 （自 C++11 起） alignof 查询类型的对齐要求 （自 C++11 起）

C 文档 中的 成员访问运算符