命名空间
变体
操作

成员访问运算符

来自 cppreference.cn
< cpp‎ | 语言
 
C++
 
C++ 语言
表达式
替代表示
字面量
布尔字面量 - 整数字面量 - 浮点字面量
字符字面量 - 字符串字面量 - nullptr (C++11)
用户定义 (C++11)
工具
属性 (C++11)
类型
typedef 声明
类型别名声明 (C++11)
类型转换
内存分配
类
类特有的函数属性
explicit (C++11)
static

特殊成员函数
模板
杂项
 
表达式
 

访问其操作数的成员。

  运算符名称             语法           可重载 原型示例（对于 class 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 的指针不能被解引用。指向其他不完整类型的指针可以被解引用，但结果左值只能在允许不完整类型左值的上下文中使用，例如在初始化引用时。

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

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 .伪析构函数 (3)
expr ->伪析构函数 (4)
1) expr 必须是完整类类型 T 的表达式。
如果 id-expr 命名一个静态成员或枚举器，则 expr 是一个丢弃值表达式。
2) expr 必须是指向完整类类型 T* 的指针表达式。
3,4) expr 必须是标量类型表达式（见下文）。

id-expr 是 T 的数据成员或成员函数，或 T 的无歧义且可访问的基类 B 的数据成员或成员函数的名称（形式上是一个标识符表达式，它命名），可选地限定（例如 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 前)亡值（可能是从纯右值实体化而来的）(C++17 起)），则结果是指定 E1 的该非静态数据成员的右值(C++11 前)亡值(C++11 起)。
如果 E2 不是可变成员，则结果的 cv-限定符是 E1 和 E2 的 cv-限定符的并集；否则（如果 E2 是可变成员），它是 E1 和 E2 的 volatile-限定符的并集。
3) 如果 E2 是重载集（一个或多个静态成员函数和非静态成员函数），则 E1.E2 必须是成员函数调用运算符的（可能带括号的）左操作数，并且使用函数重载决议来选择 E2 引用的函数，之后
  • 如果 E2 是静态成员函数，则结果是指定该静态成员函数的左值。本质上，E1 在这种情况下被求值并丢弃。
  • 否则（E2 是非静态成员函数），结果是指定 E1 的该非静态成员函数的纯右值。
4) 如果 E2 是成员枚举器，给定 E2 的类型为 T，则结果是类型为 T 的右值(C++11 前)纯右值(C++11 起)，其值是枚举器的值。
5) 如果 E2 是嵌套类型，则程序格式错误。
6) 如果 E1 具有ScalarType，且 E2 是 ~ 后跟类型名或指定相同类型（减去 cv-限定符）的decltype 说明符，可选地限定，则结果是一种特殊的纯右值，只能用作函数调用运算符的左操作数，不能用于其他目的。
结果函数调用表达式称为“伪析构函数调用”。它不带任何参数，返回 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 指向带有 ref-限定符 & 的成员函数，则程序格式错误，除非该成员函数具有 cv-限定符 const 但没有 volatile(C++20 起)；
7) 如果 E1 是左值，且 E2 指向带有 ref-限定符 && 的成员函数，则程序格式错误。
 (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

[编辑] 标准库

下标运算符被许多标准容器类重载

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

解引用和成员运算符被许多迭代器和智能指针类重载

 解引用指向托管对象的指针
(std::unique_ptr<T,Deleter> 的公共成员函数) [编辑]
 解引用存储的指针
(std::shared_ptr<T> 的公共成员函数) [编辑]
 访问托管对象
(std::auto_ptr<T> 的公共成员函数) [编辑]
 解引用迭代器
(std::raw_storage_iterator<OutputIt,T> 的公共成员函数) [编辑]
 解引用递减后的底层迭代器
(std::reverse_iterator<Iter> 的公共成员函数) [编辑]
 无操作
(std::back_insert_iterator<Container> 的公共成员函数) [编辑]
 无操作
(std::front_insert_iterator<Container> 的公共成员函数) [编辑]
 无操作
(std::insert_iterator<Container> 的公共成员函数) [编辑]
 访问指向的元素
(std::move_iterator<Iter> 的公共成员函数) [编辑]
 返回当前元素
(std::istream_iterator<T,CharT,Traits,Distance> 的公共成员函数) [编辑]
 无操作
(std::ostream_iterator<T,CharT,Traits> 的公共成员函数) [编辑]
 获取当前字符的副本
(std::istreambuf_iterator<CharT,Traits> 的公共成员函数) [编辑]
 无操作
(std::ostreambuf_iterator<CharT,Traits> 的公共成员函数) [编辑]
 访问当前匹配
(std::regex_iterator<BidirIt,CharT,Traits> 的公共成员函数) [编辑]
 访问当前子匹配
(std::regex_token_iterator<BidirIt,CharT,Traits> 的公共成员函数) [编辑]

没有标准库类重载 operator&。重载 operator& 最著名的例子是 Microsoft 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 文档 关于 成员访问运算符
取自“https://cppreference.cn/mwiki/index.php?title=cpp/language/operator_member_access&oldid=172326”