操作员超载的基本规则和习惯是什么？

Question

注意：答案以特定的顺序给出，并且随着时间的推移获得了不同数量的选票。由于答案的顺序取决于您的答案排序偏好，因此答案的 索引 在它们最有意义的顺序中：

• c ++
• C ++
• in -c/4421729＃4421729“>成员与非 通用运营商超载
  • 分配操作员
  • 流插入和提取
  • 功能调用操作员
  • 逻辑运算符
  • 算术运算符
  • 下标操作员
  • 类似指针类型的操作员
• 比较操作员，包括C ++ 20三路比较
• 转换操作员
• a href =“ https://stackoverflow.com/questions/4421706/operator-operator-overloading-in-c/4421791#4421791”> edete and delete
• 规范函数签名的摘要

_{（注意：这是堆栈溢出的C ++常见问题解答。如果您想批评以这种形式提供常见问题的想法，则启动所有这些的Meta上的发布将是这样做的地方。该问题的答案在 C ++聊天室中，FAQ Ideas首先开始的地方，所以您的答案很可能会被那些想到这个想法的人阅读。）}

Answer 1

普通运算符

过载超载操作员大部分工作的 是样板代码。这并不奇怪，因为操作员只是句法糖。他们的实际工作可以通过（通常被转发到）普通功能来完成。但是重要的是要正确获取此样板代码。如果失败，则操作员的代码不会编译，您的用户代码将不会编译，或者您的用户代码的行为会出奇。

作业操作员

关于作业有很多话要说。但是，大多数已经在 ，所以我将在这里跳过大部分，仅列出完美的分配运算符以供参考：

X& X::operator=(X rhs)
{
  swap(rhs);
  return *this;
}

流插入和提取免责

声明
，以超载＆lt;＆lt; and and ＆gt;＆gt;＆gt;＆gt;＆gt; 作为位移动运算符，跳到二进制算术操作员节。

位移动运算符＆lt;＆lt; and ＆gt;＆gt; ，尽管仍用于硬件接口用于其从C所继承的位操作函数，但已变得更加普遍为在大多数应用程序中，过载的流输入和输出运算符。

流操作员是最常见的超载运算符，是二进制输液运算符，该语法未针对其是否应为成员还是非会员指定任何限制。
但是，他们的左操作数是来自标准库的流，您不能将成员函数添加到 ¹ >中，因此您需要作为非成员功能 ^{2 < 1} /sup>。
两者的规范形式是：

std::ostream& operator<<(std::ostream& os, const T& obj)
{
  // Write obj to stream
  return os;
}

std::istream& operator>>(std::istream& is, T& obj)
{
  // Read obj from stream
  if( /* no valid object of T found in stream */ )
    is.setstate(std::ios::failbit);
  return is;
}

实施运算符时，只有在阅读本身成功时，需要手动设置流的状态，但结果不是预期的结果。

¹ 请注意，标准库的某些＆lt;＆lt;＆lt;＆lt; 过载是作为成员函数实现的，有些是免费功能。只有语言环境依赖性函数是成员函数，例如运算符＆lt;＆lt;（long）。

² _{根据经验规则，插入/提取操作员应该是成员功能，因为它们会修改左操作数。但是，我们不能遵循此处的经验规则。}

函数调用操作员

函数调用操作员，用于创建函数对象，也称为函数，必须定义为a 成员 函数，因此它始终具有隐式此成员函数的参数。除此之外，它可以超载以获取包括零在内的任何其他参数。

这是语法：用法的示例

struct X {
    // Overloaded call operator
    int operator()(const std::string& y) {
        return /* ... */;
    }
};

：

X f;
int a = f("hello");

在整个C ++标准库中，函数对象始终被复制。因此，您自己的功能对象应该便宜。如果函数对象绝对需要使用昂贵的数据，则最好将该数据存储在其他地方并具有函数对象。

比较操作员

本节已移动到其他地方，
请参见此FAQ答案 infix == ，！= ，＆lt; ，＆gt; ，＆lt; = 和＆gt; = 运算符以及＆lt; =＆gt; 三路比较，也就是。 C ++ 20中的“飞船运营商”。关于比较操作员有太多的话要说，它将超过此答案的范围。

在最简单的情况下，您可以通过默认＆lt; =＆gt; 在 c ++ 20 ：

#include <compare>

struct X {
  // defines ==, !=, <, >, <=, >=, <=>
  friend auto operator<=>(const X&, const X&) = default;
};

如果不能这样做，请继续链接答案。

逻辑运算

符unary前缀否定！应作为成员函数实现。由于它是多么罕见和令人惊讶，因此通常不是一个好主意。

struct X {
  X operator!() const { return /* ... */; }
};

其余的二进制逻辑运算符（ || ，＆amp;＆amp; ）应作为免费功能实现。但是，这是非常，您不太可能为这些 ¹ 找到合理的用例。

X operator&&(const X& lhs, const X& rhs) { return /* ... */; }
X operator||(const X& lhs, const X& rhs) { return /* ... */; }

¹ 应注意的是，内置版本的 || 和＆amp;＆amp;＆amp; 使用快捷方式语义。虽然用户定义的（因为它们是用于方法调用的句法糖），但不使用快捷语义。用户将期望这些操作员具有捷径语义，并且它们的代码可能取决于它，因此，强烈建议不要定义它们。

算术运算符单位算术运算符，

Unary Arithmetic Operators

Unary增量和减少操作员都在前缀和后缀风味中均具有。要从另一个告诉一个，后缀变体会采取其他虚拟int论点。如果您超负荷增加或减少，请确保始终实现前缀和后缀版本。

这是增量的规范实现，减少遵循相同的规则：

struct X {
  X& operator++()
  {
    // Do actual increment
    return *this;
  }
  X operator++(int)
  {
    X tmp(*this);
    operator++();
    return tmp;
  }
};

请注意，后缀变体是根据前缀实现的。另请注意，Postfix进行了额外的副本。 ¹

超负荷单位负载，加上并不是很常见，并且可能避免使用。如果需要，它们可能应作为成员函数重载。

¹ 还请注意，后缀变体的工作量更多，因此使用效率较低，而不是前缀变体。这是通常更喜欢前缀增量而不是后缀增量的一个很好的理由。虽然编译器通常可以优化内置类型的后缀增量的其他工作，但它们可能无法对用户定义的类型进行相同的操作（这可能是看起来像列表迭代器一样无辜的东西）。一旦您习惯了 i ++ ，就很难记住 ++ i 而不是 i 不是内置的类型（加上更改类型时，您必须更改代码），因此最好养成始终使用前缀增量的习惯，除非明确需要后缀。

二进制算术算术运算符的二进制算术运算

符，不要忘记服从第三个基本规则操作员的重载：如果您提供+，也提供+= ，如果您提供 - ，请勿省略 - = 等。是第一个观察到复合分配操作员可以用作其非混合物的基础的人。也就是说，操作员+是根据+= ， - 实现的 根据我们的

经验规则，+及其同伴应为非会员，而他们的复合分配对应物（+= 等），更改其左参数，应该是成员。这是+= 和+的示例代码;其他二进制算术运算符应以相同的方式实现：

struct X {
  X& operator+=(const X& rhs)
  {
    // actual addition of rhs to *this
    return *this;
  }
};

inline X operator+(const X& lhs, const X& rhs)
{
  X result = lhs;
  result += rhs;
  return result;
}

ocerator+= 每个参考返回其结果，而 operator+返回其结果的副本。当然，返回参考通常比返回副本更有效，但是在操作员+的情况下，副本没有办法。当您编写 a + b 时，您希望结果是一个新值，这就是为什么操作员 + 必须返回一个新值。 ¹

另请注意，运算符+可以通过 lhs 逐个值而不是参考来稍微缩短。
但是，这将泄漏实现细节，使功能签名非对称，并阻止命名返回值优化其中 result 与返回的对象是相同的对象。

有时，用@= （例如hortrix乘法）实现@是不切实际的。
在这种情况下，您还可以将@= 委派给@：

struct Matrix {
  // You can also define non-member functions inside the class, i.e. "hidden friends"
  friend Matrix operator*(const Matrix& lhs, const Matrix& rhs) {
    Matrix result;
    // Do matrix multiplication
    return result;
  }
  Matrix& operator*=(const Matrix& rhs)
  {
    return *this = *this * rhs; // Assuming operator= returns a reference
  }
};

位操作操作员〜 ＆amp; | ^ ＆lt;＆lt; ＆gt;＆gt;＆gt; 应以与算术运算符相同的方式实现。但是，（除了过载＆lt;＆lt; 和＆gt;＆gt; 用于输出和输入），几乎没有合理的用例来超载这些。

¹ 再次，从此获得的课程是 a + = b 通常比 a + b 如果可能的话，应首选。

下标操作员下

标操作员是二进制运营商，必须作为类成员实现。它用于类似容器的类型，可以通过键访问其数据元素。
提供这些提供的规范形式是：

struct X {
        value_type& operator[](index_type idx);
  const value_type& operator[](index_type idx) const;
  // ...
};

除非您不希望班级的用户能够更改 operator [] 返回的数据元素（在这种情况下，您可以省略非const型号） ，您应始终提供操作员的两个变体。

用于定义自己的迭代器或智能指针的类似于指针类型的操作员

，您必须超负荷Unary前缀解码操作员*和二进制Infix Pointer Pointer Member访问操作员 - ＆gt; ：

struct my_ptr {
        value_type& operator*();
  const value_type& operator*() const;
        value_type* operator->();
  const value_type* operator->() const;
};

请注意，这些几乎总是需要const和非const版本。
对于 - ＆gt; 运算符，如果 value_type 是 class （或 struct> struct> struct 或 code> union> Union code>）类型，另一个运算符 - ＆gt;（）被递归地调用，直到 operator-＆gt;（）返回非类型的值。

一级运营商绝不应超载。

对于操作员 - ＆gt;*（）（以及有关 operator-＆gt; 的更多详细信息）参见这个问题。 操作员 - ＆gt;*（）很少使用，因此很少过多。实际上，即使迭代器也不会超载。

---

继续进行转换操作员。

Answer 2

C ++中运算符超载的三个基本规则

在C ++中超载时，有 三个基本规则，您应该遵循 。与所有此类规则一样，确实有例外。有时人们会偏离他们，结果并不是糟糕的代码，但是这种积极的偏差很少，而且相距甚远。至少，在我见过的100个这样的偏差中，有99个是没有道理的。但是，它可能同样是1000中的999。因此，您最好坚持以下规则。

1. 每当操作员的含义显然清晰且无可争议的时，它不应超负荷。 而不是为了提供一个精心选择的名称。
   基本上，从本质上说：不要这样做。这似乎很奇怪，因为关于操作员的超载有很多了解，因此许多文章，书籍章节和其他文本都涉及所有这些。但是，尽管有看似明显的证据，但很少有一个案例使操作员超负荷是适当的。原因是实际上很难理解操作员应用背后的语义，除非在应用程序域中使用操作员是众所周知且无可争议的。与普遍的看法相反，情况并非如此。

   
   

2. 始终坚持操作员的知名语义。
   C ++对超载运算符的语义没有限制。您的编译器将愉快地接受实现二进制+操作员从其正确操作数中减去的代码。但是，从 b 中减去 a ，这种操作员的用户永远不会怀疑表达式 a + b 。当然，这假定应用程序域中的操作员的语义是无可争议的。

3. 始终提供一组相关操作。
   运营商相互关联以及其他操作。如果您的类型支持 a + b ，则用户也希望能够调用 a + = b 。如果它支持前缀增量 ++ a ，他们将期望 a ++ 也可以正常工作。如果他们可以检查 a＆lt; b ，他们肯定会期望能够检查 a＆gt; B 。如果他们可以复制您的类型，他们希望任务也可以工作。

---

继续进行成员与非成员之间的决定。

Answer 3

成员和非成员

类别	操作员	之间的决定
强制性成员函数	[] ，（）， = ， - ＆gt; < /code>，...	成员函数（由C ++标准规定）
指针到成员访问	- ＆gt;*	成员函数
Unary	++ ， -在	​
​	​/code>，*= ，...	成员函数，除了枚举
其他操作员	+， == ， ，＆lt; = ＆gt; ，/，...	更喜欢非成员

二进制运算符 = （分配）， [] （数组订阅）， - ＆gt; （成员访问）以及n-ary （）（函数调用）操作员，必须始终以 成员功能 ，因为该语言的语法需要它们。

其他运营商可以作为成员或非会员实施。但是，其中一些通常必须作为非成员功能实现，因为您的左操作数不能由您修改。其中最突出的是输入和输出操作员＆lt;＆lt; and ＆gt;＆gt; ，其左操作数是来自标准库的流类，您无法更改。

对于所有必须选择以成员函数或非成员函数实现它们的操作员， 使用以下经验规则 来决定：

1. 是否是 单一操作员 ，将其作为 成员 函数实现。
2. 如果二进制操作员对待 两个操作数均等 （它使它们保持不变），请将该操作员实现为A non-ember 功能。
3. 如果二进制运算符确实 不是 对待其两个操作数 同样 （通常会改变其左操作数），则如果必须访问操作数的私有部件，则可以使其成为其左操作数类型的 成员 功能。

当然，与所有经验法则一样，也有例外。如果您有类型

enum Month {Jan, Feb, ..., Nov, Dec}

，并且要超载增量和减少运算符，则不能作为成员函数执行此操作，因为在C ++中，枚举类型不能具有成员函数。因此，您必须将其作为免费功能超载。和运算符＆lt;（）对于嵌套在类模板中的类模板，当在类定义中以成员函数为内联时，编写和读取要容易得多。但是这些确实是罕见的例外。

（但是，如果您有例外，请不要忘记操作数的 const ness的问题，对于成员函数而言，它成为隐式此代码>参数。如果运算符作为非成员函数将最左边的参数作为 const 参考>最后要进行*this a const 参考。）

---

继续通用操作员超载。

Answer 4

C ++中运算符过载的一般语法

您不能更改C ++内置类型的操作员的含义，只能对用户定义的类型 ¹ 才能重载运算符。也就是说，至少一个操作数必须是用户定义的类型。与其他超载功能一样，只有一次，可以将操作员重载一次。

并非所有操作员都可以在C ++中超载。在无法重载的运算符中，是：。 :: sizeof typeID 。*以及C ++，？：在C ++中可以重载的唯一三元

运算符是：

类别	操作员	Arity and Appement
arithmetic	+ - * / ％和+= - = *= /= ％=	二进制infix
	+ -	Unary前缀
	++ -	Unary前缀和Postfix
bitwise	＆amp; | > ^ ＆lt;＆lt; ＆gt;＆gt; and ＆amp; = | = ^= ＆lt;＆lt; = ＆gt;＆gt; =	二进制
	〜	Unary前缀
比较	== ！= ＆lt; ＆gt; ＆lt; = ＆gt; = ＆lt; =＆gt;	binary infix
逻辑	| | | ＆amp;＆amp;	二进制infix
	！	Unary前缀
分配函数	new new [] delete delete [delete [ ]	Unary前缀
用户定义的转换	t	unary
分配	=	binary infix
成员访问	- ＆gt; - ＆gt;*	binary infix
间接/地址 of	* ＆amp;	unary前缀
函数调用	（）	n-ary postfix
sisscript	[]	n-ary 2 Postfix
Coroutine等待	co_await	Unary前缀
comma	，	词组

二进制 您可以超载所有这些并不意味着您应该这样做。参见下一个答案。

在C ++中，运算符以特殊名称 的形式超载。与其他功能一样，超载运算符通常可以用作其左操作数 的 成员功能，也可以作为 non-ember函数 。您是否可以自由选择或必定使用任何一个取决于几个条件。 ³ 一个单一操作员@ ⁴ ，应用于对象x ，将其调用为 operator@（x）或 x.operator@（）。应用于对象 x 和 y 的二进制ifix运算符@被称为 operator@（x，y）< /code>或as x.operator@（y）。 5

作为非成员功能实现的操作员有时是其操作数类型的朋友。

¹ 术语“用户定义”可能会稍微误导。 C ++可以区分内置类型和用户定义类型。前者属于INT，char和double； 包括标准库中的类型，即使不是由用户定义的。

后者属于所有结构，类，联合和枚举类型， 下标运算符曾经是二进制的，直到C ++ 23。

³ _{此FAQ的后期部分。}

问题/4421706/operator-overloading/ 4421729 C ++中的有效操作员，这就是为什么我将其用作占位符的原因。

⁵ _{C ++中唯一的三元运算符不能超载，并且必须始终实现唯一的n-ary操作员作为成员函数。}

---

继续。

Answer 5

转换运算符（也称为用户定义的转换）

在C ++中您可以创建转换操作员，允许编译器在类型和其他定义类型之间进行转换的操作员。转换操作员有两种类型的类型，即隐式和显式。

隐式转换运算符（C ++ 98/C ++ 03和C ++ 11）

隐式转换操作员允许编译器隐式转换（例如 int 和 long ）用户定义类型对其他类型的值。

以下是一个简单的类，带有隐式转换操作员：

class my_string {
public:
  operator const char*() const {return data_;} // This is the conversion operator
private:
  const char* data_;
};

隐式转换运算符，例如单词构造函数，是用户定义的转换。在试图将呼叫与超载函数匹配时，编译器将授予一个用户定义的转换。

void f(const char*);

my_string str;
f(str); // same as f( str.operator const char*() )

起初，这似乎非常有帮助，但是问题在于，隐含的转换甚至在不期望的时候就开始启动。在以下代码中， void f（const char*）将被称为是因为 my_string（）不是 lvalue ，所以第一个不匹配：

void f(my_string&);
void f(const char*);

f(my_string());

初学者很容易弄错了这个错误，甚至经验丰富的C ++程序员有时会感到惊讶，因为编译器选择了，他们不怀疑的超负荷。这些问题可以通过明确的转换操作员来减轻。

与隐式转换操作员不同，显式转换操作员（C ++ 11）

，明确的转换操作员在不期望的情况下永远不会启动。以下是具有显式转换操作员的简单类：

class my_string {
public:
  explicit operator const char*() const {return data_;}
private:
  const char* data_;
};

注意 explicit 。现在，当您尝试从隐式转换运算符中执行意外的代码时，您会收到一个编译器错误：

prog.cpp: In function ‘int main()’:
prog.cpp:15:18: error: no matching function for call to ‘f(my_string)’
prog.cpp:15:18: note: candidates are:
prog.cpp:11:10: note: void f(my_string&)
prog.cpp:11:10: note:   no known conversion for argument 1 from ‘my_string’ to ‘my_string&’
prog.cpp:12:10: note: void f(const char*)
prog.cpp:12:10: note:   no known conversion for argument 1 from ‘my_string’ to ‘const char*’

要调用显式铸造运算符，您必须使用 static_cast ，c-style cast或构造函数样式铸造（即 t（value））。

但是，有一个例外：允许编译器隐式转换为 bool 。此外，在将其转换为 bool 之后，不允许编译器进行另一项隐式转换（允许编译器一次一次进行2个隐式转换，但只有1个用户定义的转换，以最大为max）。

由于编译器不会施放“过去” bool ，因此显式转换操作员现在删除了安全布尔习惯。例如，C ++ 11之前的智能指针使用安全的布尔成语来防止转化为积分类型。在C ++ 11中，Smart Pointers使用显式操作员，因为在将类型明确将类型转换为BOOL之后，不允许编译器隐式转换为积分类型。

继续进行 Overloading new 和 delete delete delete delete 。

Answer 6

Overloading new 和 delete 操作员

^{注意： 这仅处理 语法 Overloading new 和 delete ，而不是使用 实现 。我认为超载的语义 new 和 delete 值得 我永远无法做到这一点。}

他们自己的常见问题

，在操作员超载的主题中， /strong> 喜欢新的t（arg）评估此表达式时发生了两件事：第一个 操作员新 < /em>被调用以获取原始内存，然后调用 t 的适当构造函数将此原始内存转换为有效的对象。同样，当您删除对象时，首先调用其破坏者，然后将内存返回到 operator delete 。
C ++允许您调整这两个操作：在分配的内存下对象的内存管理和对象的构建/破坏。后者是通过为班级编写构造函数和破坏者来完成的。通过编写自己的操作员新和操作员删除来完成微调内存管理。

运算符重载的基本规则的第一个规则 - 不这样做 - 特别适用于过载 new 和 delete 。这些操作员超负荷的唯一原因是 性能问题 和 记忆约束 ，在许多情况下，其他动作，就像使用算法的更改一样，与尝试调整内存管理相比，将提供更高的成本/增益比 更高的成本/增益比 。

C ++标准库带有一组预定义的新和 delete 运算符。最重要的是这些：

void* operator new(std::size_t) throw(std::bad_alloc); 
void  operator delete(void*) throw(); 
void* operator new[](std::size_t) throw(std::bad_alloc); 
void  operator delete[](void*) throw(); 

前两个分配/deallocate对象的内存，后两个对象的后两个对象。如果您提供自己的版本，它们将 不是超载，而是替换 来自标准库中的版本。
如果您超载操作员新，即使您从不打算调用它，也应始终超载匹配运营商删除。原因是，如果构造函数在新表达式评估期间投掷，则运行时系统将将内存返回到操作员删除匹配操作员新是呼吁分配内存以创建对象。如果您不提供匹配运算符删除，则称为默认值，这几乎总是错误的。
如果您过载 new 和删除，则也应该考虑对数组变体过载。

位置新的

C ++允许新的和删除操作员进行其他参数。
所谓的安置新的新设备使您可以在传递给的特定地址创建一个对象：

class X { /* ... */ };
char buffer[ sizeof(X) ];
void f()
{ 
  X* p = new(buffer) X(/*...*/);
  // ... 
  p->~X(); // call destructor 
} 

标准库带有适当的新运算符和删除运算符的过载

void* operator new(std::size_t,void* p) throw(std::bad_alloc); 
void  operator delete(void* p,void*) throw(); 
void* operator new[](std::size_t,void* p) throw(std::bad_alloc); 
void  operator delete[](void* p,void*) throw(); 

： 运算符删除从未调用，除非X的构造函数引发异常。

您还可以使用其他参数过载 new 和 delete 。与安置新的其他参数一样，这些参数也在关键字 new 之后的括号中列出。仅出于历史原因，这种变体通常也称为新的位置，即使它们的论点不是将对象放置在特定地址上的原因。

最常见的是特定于类的新和删除，

您需要微调内存管理，因为测量表明，经常创建和破坏特定类或一组相关类的实例，并且运行的默认存储器管理 - 针对一般绩效调整的时间系统在这种特定情况下效率低下。为了改善这一点，您可以为特定类超载新的和删除：

class my_class { 
  public: 
    // ... 
    void* operator new(std::size_t);
    void  operator delete(void*);
    void* operator new[](std::size_t);
    void  operator delete[](void*);
    // ...  
}; 

超载：因此，新的和删除的表现就像静态成员功能一样。对于 my_class 的对象， std :: size_t 参数将始终为 sizef（my_class）。但是，这些运算符也被要求用于 派生类的动态分配对象 ，在这种情况下，它可能大于此。

全局新和删除

以超载全局新和删除，只需用我们自己的标准库的预定义运算符。但是，这很少需要做。

Answer 7

为什么不能操作员＆lt;＆lt; std :: cout 或对文件是成员函数？

假设您有：

struct Foo
{
   int a;
   double b;

   std::ostream& operator<<(std::ostream& out) const
   {
      return out << a << " " << b;
   }
};

鉴于您无法使用：

Foo f = {10, 20.0};
std::cout << f;

因为 operator＆lt;＆lt;＆lt; 已重载作为 foo 的成员函数，操作员的LHS必须是 foo 对象。这意味着您将需要使用：

Foo f = {10, 20.0};
f << std::cout

这是非常不直觉的。

如果将其定义为非会员函数，

struct Foo
{
   int a;
   double b;
};

std::ostream& operator<<(std::ostream& out, Foo const& f)
{
   return out << f.a << " " << f.b;
}

则可以使用：

Foo f = {10, 20.0};
std::cout << f;

它非常直观。

Answer 8

比较操作员，包括三路比较^{（C ++ 20）}

有等效比较 == 和和！ >，，
和关系比较>。
C ++ 20还引入了三向比较运算符＆lt; =＆gt; 。

操作员的	含义和注释（旧）	含义和注释（C ++ 20）
x == y	如果 x 和 y 是等于 满足 equalityComparable （ std :: Unordered_map 使用）	如果 x 和 y 是等于 （可以用作（x＆lt） ; =＆gt; y）== 0 ，但通常不是） 满足 std :: equality_comparable
x！= y	！（x == y）>	！（x == y）
x＆lt; y	如果 x 低于 y 满足 sillthancomparable （ std :: Set set set ， std :: 等。	>（x＆lt; =＆gt; y）＆lt; 0 可能会满意 std 包裹在函子中时 （例如 std :: ranges :: Less ）
x＆gt; y	y＆lt; x	（x＆lt; =＆gt; y）＆gt; 0
x＆lt; = y	！（x＆lt; y）对于强订单， x == y || x＆lt; y 否则	＆lt; =＆gt; y
（ x	）	（x＆lt; =＆gt; y）＆gt; = 0
x＆lt; =＆gt; y	n/a	三路比较 又名。 “太空飞船操作员” 满足

指南

1. 比较操作员不应是成员函数。 ^1）
2. 如果定义 == ，则定义！= 也（除非在C ++ 20中重写）。
3. 如果定义＆lt; ，则定义＆gt; ，＆lt; = ，以及＆gt; = 。
4. （C ++ 20）优先定义＆lt; =＆gt; 而不是定义每个关系运算符。
5. （C ++ 20）更喜欢默认操作员而不是手动实施。
6. 平等和关系比较应该匹配，这意味着
   x == y 应等于！（x＆lt; y）＆amp;＆amp; ！（y＆lt; x） ^2）
7. 在＆lt; 方面不定义 == ，即使您可以 ^3）

---

^1） 否则，隐式转换将是不对称的， == 有望将相同类型的隐式转换应用于两侧。
^2） 此等价不适用于 float ，但确实适用于 int 和其他强订单的类型。 < br>
^3） 这是由可读性，正确性和性能的动机。

之前的常见成语

实现和C ++ 20免责声明
，如果您使用C ++ 20，则是实现在本节中已被淘汰。 跳过C ++ 20部分，除非您对历史观点感兴趣。

所有运营商通常以非成员函数的形式实现，可能是“隐藏的朋友”>（ friend s在类中定义该功能的位置）。
以下所有代码示例都使用隐藏的朋友，因为无论如何需要比较私人成员，这是必要的。

struct S {
    int x, y, z;

    // (In)equality comparison:
    // implementing a member-wise equality
    friend bool operator==(const S& l, const S& r) {
        return l.x == r.x && l.y == r.y && l.z == r.z;
    }
    friend bool operator!=(const S& l, const S& r) { return !(l == r); }

    // Relational comparisons:
    // implementing a lexicographical comparison which induces a
    // strict weak ordering.
    friend bool operator<(const S& l, const S& r) {
        if (l.x < r.x) return true;   // notice how all sub-comparisons
        if (r.x < l.x) return false;  // are implemented in terms of <
        if (l.y < r.y) return true;
        if (r.y < l.y) return false; // also see below for a possibly simpler
        return l.z < r.z;            // implementation
    }
    friend bool operator>(const S& l, const S& r) { return r < l; }
    friend bool operator<=(const S& l, const S& r) { return !(r < l); }
    friend bool operator>=(const S& l, const S& r) { return !(l < r); }
};

注意：在C ++ 11中，所有这些通常都可以是 noexcept 和 constexpr 。

以＆lt的方式实现所有关系比较;如果我们有部分订购的成员（例如 float ），则无效。
在这种情况下，必须以不同的方式编写＆lt; = 和＆gt; = 。

friend bool operator<=(const S& l, const S& r) { return l == r || l < r; }
friend bool operator>=(const S& l, const S& r) { return r <= l; }

操作员＆lt;

实现操作员并不那么简单，因为正确的词典比较不能简单地比较每个成员一次。
{1，2}＆lt; {3，0} 应该是正确的，即使 2＆lt; 0 是错误的。

词典比较是实现A 严格的弱订单，这是， std :: set 和算法之类的容器，例如 std :: sort 。简而言之，a 严格的弱订购应该像＆lt; 整数操作员，除了允许某些整数等效（例如，所有整数， x＆lt; y 是false）。

如果 x！= y 等效于 x＆lt; y || y＆lt; X ，一种更简单的方法：

friend bool operator<(const S& l, const S& r) {
    if (l.x != r.x) return l.x < r.x;
    if (l.y != r.y) return l.y < r.y;
    return l.z < r.z;
}

常见成语

多个成员的 ，您可以使用 std :: tie 以实现词典的比较：

#include <tuple>

struct S {
    int x, y, z;

    friend bool operator<(const S& l, const S& r) {
        return std::tie(l.x, l.y, l.z) < std::tie(r.x, r.y, r.z);
    }
};

使用 std ::词典词法 对于数组成员。

有些人使用宏或奇怪的重复模板模式（CRTP）保存委派！= ，＆gt; ，＆gt; = ，和＆lt; = ，或模仿C ++ 20的三路比较。

也可以使用 std :: rel_ops /a>（在C ++ 20中弃用）为委托！= ，＆gt; ，＆lt; = ，以及＆gt; = to ＆lt; 和 == 在某些范围中的所有类型。

---

默认比较（C ++ 20）

大量比较操作员只需比较一个类的每个成员。
如果是这样，则实施是纯样板，我们可以让编译器做到这一切：

struct S {
    int x, y, z;
    // ==, !=, <, >, <=, >= are all defined.
    // constexpr and noexcept are inferred automatically.
    friend auto operator<=>(const S&, const S&) = default;
};

注意：默认比较操作员需要是班级的 friend s exship s，而最简单的完成方法是通过将它们定义为班级内的默认值。这使他们成为“隐藏的朋友”。

另外，我们可以默认个人比较操作员。
如果我们要定义平等比较或仅关系比较，这将很有用：

friend bool operator==(const S&, const S&) = default; // inside S

请参阅

。

“ nofollow noreferrer”>默认 使用重写候选人。
因此，即使＆lt; =＆gt; 未默认（这将实现 all 运算符），我们只需要实现 == 和＆lt; =＆gt; ，并且所有其他比较都是根据这两个进行的。

操作员	潜在重写
x == y	y == x
x！= y	！（x == y）或！（y == x）如果平等比较返回 bool
x＆lt; y	（x＆lt; =＆gt; y）＆lt; 0 或 0＆lt; （y＆lt; =＆gt; x）如果比较结果与零
x＆gt; y	（x＆lt; =＆gt; y）＆gt; 0 或 0＆gt; （y＆lt; =＆gt; x）如果...
x＆lt; = y	（x＆lt; =＆gt; y）＆lt; = 0 或 0＆lt; =（y＆lt; =＆gt; x）如果...
x＆gt; = y	（x＆lt; =＆gt; y）＆gt; = 0 或 0＆gt; =（y＆lt; =＆gt; x）如果...

struct S {
    int x, y, z;
    // ==, !=
    friend constexpr bool operator==(const S& l, const S& r) noexcept { /* ... */ }
    // <=>, <, >, <=, >=
    friend constexpr auto operator<=>(const S& l, const S& r) noexcept { /* ... */ }
};

注意： constexpr and noexcept /code>是可选的，但几乎可以始终应用于比较操作员。

注意： p1185r2：＆lt; =＆gt; ！== ，a x == y 表达式也将被重写为（x＆lt; =＆gt; y）== 0 ，但这本来是效率低下的，因为它错过了短路的机会。

三路比较操作员（C ++ 20）

注：它被称为“太空飞船操作员”。另请参见 spaceShip-operator 。

x＆lt; =＆gt; y 是结果告诉我们 x 是否低于，大于，等同或无序的 y 。
这类似于 strcmp 等函数。

// old C style
int compare(int x, int y) {
    if (x < y) return -1;
    if (x > y) return  1;
    return             0; // or simply return (x > y) - (x < y);
}
// C++20 style: this is what <=> does for int.
auto compare_cxx20(int x, int y) {
    if (x < y) return std::strong_ordering::less;
    if (x > y) return std::strong_ordering::greater;
    return            std::strong_ordering::equal;
}
// This is what <=> does for float.
auto compare_cxx20(float x, float y) {
    if (x < y)  return std::partial_ordering::less;
    if (x > y)  return std::partial_ordering::greater;
    if (x == y) return std::partial_ordering::equivalent;
    return             std::partial_ordering::unordered; // NaN
}

比较类别

该运算符的结果既不是 bool bool in int ，而是比较类别的值。

比较类别	示例	可能值
std :: strong_ordering	int	少，等于=等效，更大
std :: feek_ordering	user-defined 1）	> 少，等效，更大
std :: partial_ordering	float	少 ，等效，更大，无序

std :: strong_ordering s可以转换为 std :: feek_ordering ，可以将其转换为 std :: partial_ordering 。
这些类别的值可与（例如（x＆lt; =＆gt; y）== 0 ）相提并论，这与比较上面的函数具有相似的含义。
但是， std :: partial_ordering ::无序返回false以进行所有比较。

---

^1） 没有基本类型的 x＆lt; =＆gt; y 在 std :: feek_ordering 中结果。在实践中，强大和弱的顺序是可以互换的。参见 std :: stront_ordering and std and std and std :: feek_ordering

。 -way比较通常违约，但可以手动实现：

#include <compare> // necessary, even if we don't use std::is_eq

struct S {
    int x, y, z;
    // This implementation is the same as what the compiler would do
    // if we defaulted <=> with = default;
    friend constexpr auto operator<=>(const S& l, const S& r) noexcept {
        // C++17 if statement with declaration makes this more readable.
        // !std::is_eq(c) is not the same as std::is_neq(c); it is also true
        // for std::partial_order::unordered.
        if (auto c = l.x <=> r.x; !std::is_eq(c)) /* 1) */ return c;
        if (auto c = l.y <=> r.y; !std::is_eq(c)) return c;
        return l.y <=> r.y;
    }
    // == is not automatically defined in terms of <=>.
    friend constexpr bool operator==(const S&, const S&) = default;
};

如果 s 的所有成员都不相同，则拥有 auto> auto 返回类型可能是一个问题，因为比较类别（＆lt; =＆gt; 的类型）可能有所不同，并且多个返回语句的扣除不一致。
在这种情况下，我们可以直接指定类别（在返回类型中），也可以使用 std :: common_comparison_category ：

std::common_comparison_category_t<decltype(l.x <=> l.x), /* ... */>

---

^1） _{辅助功能，例如 std :: is_neq 比较＆lt; =＆gt; 的结果为零。
它们更清楚地表达了意图，但是您不必使用它们。}

常见的成语

，我们可以让 std :: tie 弄清楚详细信息：

#include <tuple>

struct S {
    int x, y, z;

    friend constexpr auto operator<=>(const S& l, const S& r) noexcept {
        return std::tie(l.x, l.y, l.z) <=> std::tie(r.x, r.y, r.z);
    }
};

使用 std ::词典词典_compare_three_way_way 数组成员。

Answer 9

规范功能签名的摘要

许多操作员超载几乎可以返回任何内容。例如，没有什么可以阻止您在 operator == 中返回 void 。
但是，这些签名中只有少数是 canonical ，这意味着您通常会以这种方式写下它们，并且可以用 = default 明确地默认此类操作员。

分配运算符

struct X {
  X& operator=(const X&) = default;     // copy assignment operator
  X& operator=(X&&) noexcept = default; // move assignment operator
};

具有 =默认值=默认值; 是可能的，但是您也可以手动实现作业。
移动分配几乎总是 noexcept ，尽管它不是强制性的。

比较操作员

#include <compare> // for comparison categories

struct X {
  friend auto operator<=>(const X&, const X&) = default; // defaulted three-way comparison
  friend std::strong_ordering<=>(const X&, const X&);    // manual three-way comparison

  friend bool operator==(const X&, const X&) = default;  // equality comparisons
  friend bool operator!=(const X&, const X&) = default;  // defaultable since C++20

  friend bool operator<(const X&, const X&) = default;   // relational comparisons
  friend bool operator>(const X&, const X&) = default;   // defaultable since C++20
  friend bool operator<=(const X&, const X&) = default;
  friend bool operator>=(const X&, const X&) = default;
};

参见此答案比较。

算术运算符

struct X {
  friend X operator+(const X&, const X&); // binary plus
  friend X operator*(const X&, const X&); // binary multiplication
  friend X operator-(const X&, const X&); // binary minus
  friend X operator/(const X&, const X&); // binary division
  friend X operator%(const X&, const X&); // binary remainder

  X operator+() const;                    // unary plus
  X operator-() const;                    // unary minus

  X& operator++();                        // prefix increment
  X& operator--();                        // prefix decrement
  X  operator++(int);                     // postfix increment
  X  operator--(int);                     // postfix decrement

  X& operator+=(const X&);                // compound arithmetic assignment
  X& operator-=(const X&);
  X& operator*(const X&);
  X& operator/=(const X&);
  X& operator%=(const X&);
};

也可以按值乘以二进制运算符的左操作员，但这不建议这样做，因为它使签名不对称并抑制编译器的优化。

钻头运算

struct X {
  using difference_type = /* some integer type */;

  friend X operator&(const X&, const X&);         // bitwise AND
  friend X operator|(const X&, const X&);         // bitwise OR
  friend X operator^(const X&, const X&);         // bitwise XOR
  
  friend X operator<<(const X&, difference_type); // bitwise left-shift
  friend X operator>>(const X&, difference_type); // bitwise right-shift

  X operator~() const;                            // bitwise NOT

  X& operator&=(const X&);                        // compound bitwise assignment
  X& operator|=(const X&);
  X& operator^(const X&);
  X& operator/=(const X&);
  X& operator%=(const X&);
};

符流插入和提取

#include <ostream> // std::ostream
#include <istream> // std::istream

struct X {
  friend std::ostream& operator<<(std::ostream&, const X&); // stream insertion
  friend std::istream& operator>>(std::istream&, X&);       // stream extraction
};

功能调用操作员

struct X {
  using result = /* ... */;

         result operator()(user-defined-args...) /* const / volatile / & / && */;
  static result operator()(user-defined-args...);           // since C++23
};

下标子操作员

struct X {
  using key_type = /* ... */;
  using value_type = /* ... */;

  const value_type& operator[](key_type) const;
        value_type& operator[](key_type);

  static value_type& operator[](key_type); // since C++23
};

注意 operator [] 自C ++ 23以来可以接受多个参数。

成员访问操作员

struct X {
  using value_type = /* ... */;

  const value_type& operator*() const; // indirection operator
        value_type& operator*();

  const value_type* operator->() const; // arrow operator
        value_type* operator->();
};

指针到会员操作员

struct X {
  using member_type = /* ... */;
  using member_pointer_type = /* ... */;
  
  const member_type& operator->*(member_pointer_type) const;
        member_type& operator->*(member_pointer_type);
};

地址运算符

struct X {
  using address_type = /* ... */;

  address_type operator&() const; // address-of operator
};

逻辑操作员

struct X {
  friend X operator&&(const X&, const X&); // logical AND
  friend X operator||(const X&, const X&); // logical OR
  friend X operator!(const X&);            // logical NOT
};

注意，这些操作员不会返回 bool ，因为它们仅在 x 已经是一种逻辑类型时才有意义类似于 bool 。

用户定义的转换

struct X {
  using type = /* ... */;

  operator type() const;          // arbitrary implicit conversion

  explicit operator bool() const; // explicit/contextual conversion to bool

  template <typename T>
    requires /* ... */            // optionally constrained
  explicit operator T() const;    // conversion function template
};

Coroutine等待

struct X {
  using awaiter = /* ... */;

  awaiter operator co_await() const;
};

逗号操作员

struct X {
  using pair_type = /* ... */;

  // often a template to support combination of arbitrary types
  friend pair_type operator,(const X&, const X&);
};

分配功能

struct X {
  // class-specific allocation functions
  void* operator new(std::size_t);
  void* operator new[](std::size_t);
  void* operator new(std::size_t, std::align_val_t); // C++17
  void* operator new[](std::size_t, std::align_val_t); // C++17

  // class-specific placement allocation functions
  void* operator new(std::size_t, user-defined-args...);
  void* operator new[](std::size_t, user-defined-args...);
  void* operator new(std::size_t, std::align_val_t, user-defined-args...); // C++17
  void* operator new[](std::size_t, std::align_val_t, user-defined-args...); // C++17

  // class-specific usual deallocation functions
  void operator delete(void*);
  void operator delete[](void*);
  void operator delete(void*, std::align_val_t); // C++17
  void operator delete[](void*, std::align_val_t); // C++17
  void operator delete(void*, std::size_t);
  void operator delete[](void*, std::size_t);
  void operator delete(void*, std::size_t, std::align_val_t); // C++17
  void operator delete[](void*, std::size_t, std::align_val_t); // C++17

  // class-specific placement deallocation functions
  void operator delete(void*, user-defined-args...);
  void operator delete(void*, user-defined-args...);

  // class-specific usual destroying deallocation functions
  void operator delete(X*, std::destroying_delete_t); // C++20
  void operator delete(X*, std::destroying_delete_t, std::align_val_t); // C++20
  void operator delete(X*, std::destroying_delete_t, std::size_t); // C++20
  void operator delete(X*, std::destroying_delete_t, std::size_t, std::align_val_t); // C++20
};

// non-class specific replaceable allocation functions ...

void* operator new(std::size_t);
void* operator delete(void*);
// ...

Answer 10

简短而简单，我将提到一些观点，过去一周我学习Python和C ++，OOP和其他事物，因此，这是：

1. < < a href =“ https://en.wiktionary.org/wiki/arity#noun” rel =“ nofollow noreferrer”> arity bed bed Is！

   
   

2. 超载运算符只能有一个默认参数，该函数调用操作员无法休息。

3. 只有内置的操作员才能超载，其余的不能！

有关更多信息，您可以参考 操作员过载规则 ，将您重定向到