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

Question

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

The General Syntax of operator overloading in C++

The Three Basic Rules of Operator Overloading in C++

The Decision between Member and Non-member

Common operators to overload

赋值运算符

输入和输出运算符

函数调用运算符

比较运算符

算术运算符

数组下标

指针类型的

运算符

Conversion Operators

Overloading new and delete

(注意:这是Stack Overflow's C++ FAQ的条目。如果您想批评以这种形式提供FAQ的想法，那么the posting on meta that started all this就是这样做的地方。对该问题的答案在C++ chatroom中进行监控，其中FAQ想法最初是从头开始的，因此提出这个想法的人很可能会读懂您的答案。)

Answer 1

普通运算符重载

重载操作员中的大部分工作是样板代码。这也就不足为奇了，因为运算符仅仅是语法糖，所以它们的实际工作可以由(通常转发给)普通函数来完成。但是，重要的是您正确理解此样板代码。如果失败，则操作员的代码将无法编译，或者用户的代码将无法编译，或者用户的代码将表现异常。

赋值运算符

关于分配有很多要说的。但是，大多数内容已经在GMan's famous Copy-And-Swap FAQ中说过了，因此在这里我将跳过大部分内容，仅列出完美的赋值运算符以供参考:

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

位移位运算符(用于流I / O)

位移位运算符<<和>>尽管仍用于它们从C继承的位操作功能的硬件接口(interface)中，但在大多数应用程序中已作为重载流输入和输出运算符而变得更加普遍。有关作为位操作运算符的指导超载，请参见下面有关二进制算术运算符的部分。当对象与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++标准库中，始终复制功能对象。因此，您自己的函数对象应该廉价复制。如果功能对象绝对需要使用复制成本很高的数据，则最好将该数据存储在其他位置，并让功能对象引用它。

比较运算符

根据经验法则，二进制中缀比较运算符应实现为非成员函数1。一元前缀否定!应该(根据相同规则)实现为成员函数。 (但通常不建议重载它。)

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

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

这里要注意的重要一点是，这些运算符中只有两个实际执行任何操作，其他运算符只是将其参数转发给这两个运算符中的任一个来执行实际工作。

重载其余二进制 bool(boolean) 运算符(||，&&)的语法遵循比较运算符的规则。但是，您不太可能为这些找到合理的用例2。

1与所有经验法则一样，有时可能也有理由打破这一原则。如果是这样，请不要忘记二进制比较运算符的左侧操作数(对于成员函数而言，该操作数将是*this)也需要也是const。因此，实现为成员函数的比较运算符必须具有以下签名:

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

(请注意最后的const。)

2应该注意的是，||和&&的内置版本使用快捷方式语义。尽管用户定义的语法(因为它们是方法调用的语法糖)，却不使用快捷方式语义。用户将期望这些运算符具有快捷方式语义，并且它们的代码可能依赖于此，因此，强烈建议不要定义它们。

算术运算符

一元算术运算符

一元递增和递减运算符具有前缀和后缀形式。为了彼此区分，后缀变体采用了另一个哑int参数。如果重载递增或递减，请确保始终同时实现前缀和后缀版本。
这是递增的规范实现，递减遵循相同的规则:

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

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

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

2还请注意，postfix变体比前缀变体工作更多，因此使用效率较低。这是一个很好的理由，通常优先选择前缀增量而不是后缀增量。尽管编译器通常可以优化内置类型的后缀增量的其他工作，但对于用户定义的类型，它们可能无法执行相同的工作(这可能像列表迭代器一样无辜)。一旦您习惯了i++，当++i不是内置类型(加上更改类型时必须更改代码)时，就很难记住改用i了，因此最好制作一个除非明确需要后缀，否则总是使用前缀增量的习惯。

二元算术运算符

对于二进制算术运算符，请不要忘记遵守第三个基本规则运算符重载:如果提供+，还提供+=，如果提供-，请不要省略-=，等等。据说安德鲁·科尼希(Andrew Koenig)是第一个观察到的复合赋值运算符可以用作其非复合对应物的基础。也就是说，运算符+是根据+=实现的，-是根据-=实现的等。

根据我们的经验法则，+及其伴随对象应为非成员，而其复合赋值对应对象(+=等)(更改其左参数)应为成员。这是+=和+的示例代码；其他二进制算术运算符应以相同的方式实现:

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+必须返回新值的原因。3
另请注意，operator+通过复制而不是通过const引用获取其左操作数 。这样做的原因与给operator=每个副本取其参数的原因相同。

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

3同样，从中可以吸取的教训是，通常a += b比a + b更有效，如果可能，应该首选operator[]。

数组下标

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

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

除非您不希望您的类的用户能够更改*返回的数据元素(在这种情况下，您可以忽略non-const变体)，否则应始终提供运算符的两个变体。

如果已知value_type引用内置类型，则运算符的const变体最好返回一个副本，而不是const引用:

class X {
  value_type& operator[](index_type idx);
  value_type  operator[](index_type idx) 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->*()返回非类类型的值。

一元运算符的地址永远不要重载。

有关ojit_code的信息，请参见this question。它很少使用，因此也很少过载。实际上，即使迭代器也不会使它过载。

继续Conversion Operators