为什么用于将对象流到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;

由于运算符<<被重载为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;

这是非常直观的。

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

当谈到C++中的运算符重载时，您应该遵循三个基本规则。与所有这些规则一样，确实有例外。有时，人们偏离了这些准则，其结果并不坏，但这种积极的偏离很少。至少，我所看到的100个这种偏差中有99个是不合理的。然而，它也可能是千分之999。所以你最好遵守以下规则。

每当运算符的含义不明显且无可争议时，它就不应过载。相反，请提供一个具有精心选择的名称的函数。基本上，重载运算符的首要原则是：不要这样做。这可能看起来很奇怪，因为关于运算符重载有很多事情要知道，所以很多文章、书籍章节和其他文本都涉及到这一切。但是，尽管有这些看似明显的证据，但只有极少数情况下运算符重载是合适的。原因是，实际上很难理解运算符应用程序背后的语义，除非在应用程序域中使用运算符是众所周知且无可争议的。与人们普遍的看法相反，事实并非如此。始终遵循运算符众所周知的语义。C++对重载运算符的语义没有任何限制。编译器将乐于接受实现二进制+运算符的代码，以从其右操作数中减去。然而，这样的运算符的用户永远不会怀疑表达式a+b会从b中减去a。当然，这假设应用程序域中运算符的语义是无可争议的。始终提供一组相关操作中的所有操作。操作员相互关联，并与其他操作相关。如果您的类型支持a+b，用户也可以调用a+=b。如果它支持前缀increment++a，那么他们也希望a++也能工作。如果他们能检查a是否＜b，他们肯定也会检查a是否＞b。如果他们能复制构造你的类型，他们希望赋值也能起作用。

---

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

简而言之，我将提及一些要点，这些要点是我在过去一周学习Python和C++、oops和其他东西时提出的，因此如下所示：

运算符的Arity不能被进一步修改为原来的值！重载运算符只能有一个默认参数，而函数调用运算符不能使用该参数。只有内置运算符可以重载，其余的不能！

有关更多信息，您可以参考以下链接，该链接将您重定向到GeekforGeeks提供的文档。

https://www.geeksforgeeks.org/g-fact-39/

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

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

并非所有的运算符都可以在C++中重载。不能重载的运算符包括：.：：sizeof typeid.*和C++中唯一的三元运算符，？：

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

算术运算符：+-*/%和+=-=*=/=%=（所有二进制中缀）；+-（一元前缀）；++--（一元前缀和后缀）位操作：&|^<<>>和&=|=^=<<>>=（所有二进制中缀）；~（一元前缀）布尔代数：==！=<><>=|&&&（所有二进制中缀）！（一元前缀）内存管理：新建[]删除删除[]隐式转换运算符杂项：=[]->->*，（所有二进制中缀）；*&（全一元前缀）（）（函数调用，n元中缀）

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

在C++中，运算符以具有特殊名称的函数的形式重载。与其他函数一样，重载运算符通常可以实现为其左操作数类型的成员函数或非成员函数。您是否可以自由选择或绑定使用其中一个取决于几个条件。2应用于对象x的一元运算符@3被调用为运算符@（x）或x.operator@（）。应用于对象x和y的二进制中缀运算符@被调用为操作符@（x，y）或x.运算符@（y）。4

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

1“用户定义”一词可能有点误导。C++区分了内置类型和用户定义类型。前者属于例如int、char和double；所有struct、class、union和enum类型都属于后者，包括标准库中的类型，即使它们本身不是由用户定义的。

2这将在本常见问题解答的后面部分介绍。

3@在C++中不是有效的运算符，这就是为什么我将它用作占位符。

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

---

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

常见操作员过载

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

赋值运算符

关于任务有很多话要说。然而，GMan著名的“复制和交换常见问题解答”中已经提到了其中的大部分内容，因此我将跳过这里的大部分，只列出完美的赋值运算符以供参考：

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

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

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

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

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

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

函数调用运算符

用于创建函数对象（也称为函子）的函数调用运算符必须定义为成员函数，因此它始终具有成员函数的隐式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）始终只希望运算符<出现。但是，您类型的用户也会期望所有其他运算符都存在，因此如果您定义了运算符<，请确保遵循运算符重载的第三个基本规则，并定义所有其他布尔比较运算符。实现它们的规范方法是：

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

这里需要注意的重要一点是，这些操作符中只有两个真正做了任何事情，其他操作符只是将它们的论点转发给这两个操作符中的任何一个来做实际的工作。

重载剩余的二进制布尔运算符（||，&&）的语法遵循比较运算符的规则。然而，您不太可能找到这些2的合理用例。

1与所有经验法则一样，有时也有理由打破这一法则。如果是这样，请不要忘记，二进制比较运算符的左手操作数（对于成员函数为*this）也需要是常量。因此，作为成员函数实现的比较运算符必须具有以下签名：

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

（注意末尾的常量。）

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

算术运算符

一元算术运算符

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

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

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

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

2还请注意，后缀变体比前缀变体工作更多，因此使用效率更低。这是一个很好的理由，通常更喜欢前缀增量而不是后缀增量。虽然编译器通常可以优化内置类型的后缀增量这一额外工作，但对于用户定义的类型，编译器可能无法做到这一点（这可能像列表迭代器一样看起来很无辜）。一旦你习惯了使用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+返回其结果的副本。当然，返回引用通常比返回副本更有效，但在运算符+的情况下，没有办法避免复制。当您编写a+b时，您希望结果是一个新值，这就是为什么运算符+必须返回一个新的值。3还要注意，运算符+通过复制而不是常量引用获取其左操作数。这样做的原因与operator=为每个副本获取其参数的原因相同。

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

3同样，要从中吸取的教训是，一般来说，a+=b比a+b更有效，如果可能的话，应该首选。

阵列订阅

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

class X {
        value_type& operator[](index_type idx);
  const value_type& operator[](index_type idx) 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;
};

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

运算符的一元地址不应重载。

对于运算符->*（），请参见此问题。它很少使用，因此很少过载。事实上，即使迭代器也不会重载它。

---

继续转换运算符

成员与非成员之间的决定

二进制运算符=（赋值）、[]（数组订阅）、->（成员访问）以及n元（）（函数调用）运算符必须始终作为成员函数实现，因为语言的语法要求它们实现。

其他运算符可以作为成员或非成员实现。然而，其中一些函数通常必须实现为非成员函数，因为您无法修改它们的左操作数。其中最突出的是输入和输出运算符<<and>>，其左操作数是标准库中的流类，您无法更改。

对于必须选择将其作为成员函数或非成员函数实现的所有运算符，请使用以下经验规则来决定：

如果它是一元运算符，请将其实现为成员函数。如果二进制运算符对两个操作数一视同仁（保持不变），则将此运算符作为非成员函数实现。如果一个二元运算符不能平等对待两个操作数（通常它会改变其左操作数），如果它必须访问操作数的私有部分，则将其设置为左操作数类型的成员函数可能会很有用。

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

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

如果要重载它的递增和递减运算符，则不能将其作为成员函数，因为在C++中，枚举类型不能具有成员函数。所以你必须把它作为一个自由函数重载。嵌套在类模板中的类模板的运算符<（）在作为类定义中内联的成员函数时更容易编写和读取。但这些确实是罕见的例外。

（但是，如果发生异常，请不要忘记操作数的常量问题，对于成员函数，该操作数将成为隐式this参数。如果作为非成员函数的运算符将其最左边的参数作为常量引用，则作为成员函数的同一运算符需要在末尾有一个常量，以使*this成为常量引用。）

---

继续到“常用运算符”以重载。