运算符重载的基本规则和习惯用法是什么？

注意：答案是按照特定的顺序给出的，但由于许多用户根据投票而不是给出的时间对答案进行排序，因此这里的答案索引按照最有意义的顺序排列：

C ++ 中运算符重载的通用语法
C ++ 中运算符重载的三个基本规则
会员与非会员之间的决定
常见的运算符过载
- 分配操作员
- 输入和输出运算符
- 函数调用运算符
- 比较运算符
- 算术运算符
- 数组订阅
- 指针类型的运算符
- 转换运算符
重载新的和删除

_{（注意：这是Stack Overflow 的 C ++ 常见问题解答的一个条目。如果你想批评在这种形式下提供常见问题解答的想法，那么发布所有这些的 meta 上的帖子就是这样做的地方。这个问题在C ++ 聊天室中受到监控，其中 FAQ 的想法首先出现在那里，所以你的答案很可能被那些提出想法的人阅读。）}

答案

常见的运算符过载

超载运营商的大部分工作都是锅炉板代码。这并不奇怪，因为操作符只是语法糖，它们的实际工作可以通过（通常转发到）普通函数来完成。但重要的是你要正确使用这种锅炉板代码。如果您失败，您的操作员代码将无法编译，或者您的用户代码将无法编译，或者您的用户代码将出现令人惊讶的行为。

分配操作员

关于作业有很多话要说。但是，大部分内容已经在GMan 着名的 Copy-And-Swap 常见问题解答中说过了，所以我将在这里跳过大部分内容，仅列出完美的赋值运算符以供参考：

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

Bitshift 运算符（用于流 I / O）

bitshift 运算符<<和>>虽然仍然用于它们从 C 继承的位操作函数的硬件接口，但在大多数应用程序中作为重载流输入和输出运算符变得更加普遍。有关作为位操作运算符的指导重载，请参阅下面的二进制算术运算符部分。要在对象与 iostream 一起使用时实现自己的自定义格式和解析逻辑，请继续。

流运算符（最常见的是重载运算符）是二进制中缀运算符，其语法对它们应该是成员还是非成员没有限制。由于它们改变了左参数（它们改变了流的状态），根据经验法则，它们应该被实现为左操作数类型的成员。但是，它们的左操作数是来自标准库的流，虽然标准库定义的大多数流输出和输入操作符确实被定义为流类的成员，但当您为自己的类型实现输出和输入操作时，无法更改标准库的流类型。这就是为什么你需要为你自己的类型实现这些运算符作为非成员函数。两者的规范形式是：

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;
}

实现operator>> ，只有在读取本身成功时才需要手动设置流的状态，但结果不是预期的结果。

函数调用运算符

用于创建函数对象的函数调用运算符（也称为函子）必须定义为成员函数，因此它始终具有成员函数的隐式this参数。除此之外，它可以重载以获取任意数量的附加参数，包括零。

这是一个语法示例：

class foo {
public:
    // Overloaded call operator
    int operator()(const std::string& y) {
        // ...
    }
};

用法：

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

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

比较运算符

根据经验法则，二进制中缀比较运算符应该实现为非成员函数¹ 。一元前缀否定!应该（根据相同的规则）实现为成员函数。（但重载它通常不是一个好主意。）

标准库的算法（例如std::sort() ）和类型（例如std::map ）将始终只期望operator<存在。但是， 您的类型的用户也希望所有其他运算符都存在 ，因此如果您定义operator< ，请确保遵循运算符重载的第三个基本规则，并定义所有其他布尔比较运算符。实现它们的规范方法是：

inline bool operator==(const X& lhs, const X& rhs){ /* do actual comparison */ }
inline bool operator!=(const X& lhs, const X& rhs){return !operator==(lhs,rhs);}
inline bool operator< (const X& lhs, const X& rhs){ /* do actual comparison */ }
inline bool operator> (const X& lhs, const X& rhs){return  operator< (rhs,lhs);}
inline bool operator<=(const X& lhs, const X& rhs){return !operator> (lhs,rhs);}
inline bool operator>=(const X& lhs, const X& rhs){return !operator< (lhs,rhs);}

这里需要注意的重要事项是，这些操作符中只有两个实际执行任何操作，其他操作符只是将其参数转发给这两个操作符中的任何一个来完成实际操作。

重载剩余的二进制布尔运算符（ || ， && ）的语法遵循比较运算符的规则。然而，这是不太可能，你会发现这些²合理的利用情况。

¹ _{与所有经验法则一样，有时可能有理由打破这一个。如果是这样，不要忘记二元比较运算符的左手操作数，对于成员函数将是*this ，也需要是const 。因此，作为成员函数实现的比较运算符必须具有以下签名：}

bool operator<(const X& rhs) const { /* do actual comparison with *this */ }

_{（注意最后的const 。）}

² _{应该注意的是||的内置版本和&&使用快捷语义。虽然用户定义的（因为它们是方法调用的语法糖）不使用快捷语义。用户希望这些运算符具有快捷语义，并且它们的代码可能依赖于它，因此强烈建议不要定义它们。}

算术运算符

一元算术运算符

一元递增和递减运算符有前缀和后缀两种风格。为了告诉另一个，后缀变体采用额外的伪 int 参数。如果重载增量或减量，请确保始终实现前缀和后缀版本。这是增量的规范实现，减量遵循相同的规则：

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

请注意，后缀变体是根据前缀实现的。另请注意，postfix 会额外复制。 ²

重载一元减号和加号不是很常见，可能最好避免。如果需要，它们可能应该作为成员函数重载。

² _{另请注意，后缀变体功能更多，因此使用效率低于前缀变量。这是一个很好的理由通常更喜欢前缀增量而不是后缀增量。虽然编译器通常可以优化内置类型的后缀增量的额外工作，但它们可能无法对用户定义的类型执行相同的操作（这可能是像列表迭代器一样无辜地看起来的东西）。一旦你习惯了做i++ ，当i不是内置类型时（你更改类型时必须更改代码），当i不是内置类型时，很难记住做++i ，所以最好是养成一直使用前缀增量的习惯，除非明确需要后缀。}

二元算术运算符

对于二进制算术运算符，不要忘记遵守第三个基本规则运算符重载：如果你提供+ ，还提供+= ，如果你提供- ，不要省略-=等等。据说 Andrew Koenig 是第一个观察到复合赋值算子可以作为非复合对应物的基础。也就是说，operator +以+=实现， -以-=等实现。

根据我们的经验法则， +和它的同伴应该是非成员，而他们的复合赋值对应物（ +=等），改变他们的左参数，应该是成员。以下是+=和+的示例代码，其他二进制算术运算符应以相同的方式实现：

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

operator+=返回每个引用的结果，而operator+返回其结果的副本。当然，返回引用通常比返回副本更有效，但在operator+的情况下，无法复制。当你写a + b ，你希望结果是一个新值，这就是operator+必须返回一个新值的原因。 ³另请注意， operator+ 通过复制而不是 const 引用来获取其左操作数。其原因与给出operator=每个副本的参数的原因相同。

位操作运算符~ & | ^ << >>应该以与算术运算符相同的方式实现。但是，（除了输出和输入的重载<<和>>之外）很少有合理的用例来重载这些。

³ _{同样，从中可以得出的教训是， a += b通常比a + b更有效，并且如果可能的话应该是优选的。}

数组订阅

数组下标运算符是二元运算符，必须作为类成员实现。它用于容器类型，允许通过键访问其数据元素。提供这些的规范形式是这样的：

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

除非您不希望类的用户能够更改operator[]返回的数据元素（在这种情况下您可以省略非 const 变量），否则应始终提供运算符的两种变体。

如果已知 value_type 引用内置类型，则运算符的 const 变量应返回副本而不是 const 引用。

指针类型的运算符

要定义自己的迭代器或智能指针，必须重载一元前缀解引用运算符*和二进制中缀指针成员访问运算符-> ：

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

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

一元地址运算符永远不应该重载。

对于operator->*()请参阅此问题。它很少使用，因此很少超载。实际上，即使是迭代器也不会使它超载。

继续转换操作员

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

当谈到 C ++ 中的运算符重载时， 您应该遵循三个基本规则 。与所有这些规则一样，确实有例外。有时人们偏离了它们，结果并不是错误的代码，但这种积极的偏差很少而且很远。至少，我所看到的 100 个这样的偏差中有 99 个是没有道理的。然而，它可能也是 1000 中的 999. 所以你最好坚持以下规则。

只要操作员的意义不明显且无可争议，它就不应该超载。 相反，提供具有精心选择的名称的功能。
基本上，重载运营商的第一个也是最重要的规则是： 不要这样做 。这可能看起来很奇怪，因为有很多关于运算符重载的知识，因此很多文章，书籍章节和其他文本都涉及到这一切。但尽管有这些看似明显的证据， 但只有极少数情况下运营商超载是合适的 。原因是实际上很难理解运算符应用背后的语义，除非在应用程序域中使用运算符是众所周知且无可争议的。与流行的看法相反，情况并非如此。
始终坚持运营商众所周知的语义。
C ++ 对重载运算符的语义没有限制。您的编译器将很乐意接受实现二元+运算符的代码，以从其右操作数中减去。然而，这样的操作者的用户决不会怀疑表达a + b减去a从b 。当然，这假设应用程序域中的运算符的语义是无可争议的。
始终提供一系列相关操作。
运营商彼此之间以及与其他运营相关。如果您的类型支持a + b ，则用户也可以调用a += b 。如果它支持前缀增量++a ，他们将期望a++可以工作。如果他们可以检查是否a < b ，他们肯定也希望能够检查是否a > b 。如果他们可以复制构造您的类型，他们希望分配也可以工作。

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

C ++ 中运算符重载的通用语法

您无法在 C ++ 中更改内置类型的运算符的含义，只能为用户定义的类型¹重载运算符。也就是说，至少一个操作数必须是用户定义的类型。与其他重载函数一样，运算符只能为一组参数重载一次。

并非所有运算符都可以在 C ++ 中重载。无法超载的运营商包括： . :: sizeof typeid .*和 C ++ 中唯一的三元运算符， ?:

可以在 C ++ 中重载的运算符包括：

算术运算符： + - * / %和+= -= *= /= %= （所有二进制中缀）; + - （一元前缀）; ++ -- （一元前缀和后缀）
位操作： & | ^ << >>和&= |= ^= <<= >>= （所有二进制中缀）; ~ （一元前缀）
布尔代数： == != < > <= >= || && （所有二进制中缀）; ! （一元前缀）
内存管理： new new[] delete delete[]
隐式转换运算符
miscellany： = [] -> ->* , （所有二进制中缀）; * & （所有一元前缀） () （函数调用，n-ary 中缀）

但是，您可以重载所有这些并不意味着您应该这样做。请参阅运算符重载的基本规则。

在 C ++ 中，运算符以具有特殊名称的函数形式重载。与其他函数一样，重载运算符通常可以实现为其左操作数类型的成员函数，也可以实现为非成员函数 。您是否可以自由选择或约束使用其中任何一个取决于几个标准。 ²应用于对象 x 的一元运算符@ ³ ，可以作为operator@(x)或x.operator@()调用。应用于对象x和y的二进制中缀运算符@被称为operator@(x,y)或x.operator@(y) 。 ⁴

实现为非成员函数的运算符有时是其操作数类型的朋友。

¹ _{“用户定义” 一词可能略有误导。 C ++ 区分内置类型和用户定义类型。前者属于例如 int，char 和 double; 后者属于所有 struct，class，union 和 enum 类型，包括来自标准库的类型，即使它们不是由用户定义的。}

² _{本常见问题解答的后续部分将对此进行介绍。}

³ _{@在 C ++ 中不是有效的运算符，这就是我将它用作占位符的原因。}

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

继续使用C ++ 中的运算符重载的三个基本规则。