为什么非成员函数不能用于重载赋值运算符？

Question

可以使用成员函数重载赋值运算符，但不能使用非成员 friend 函数：

class Test
{
    int a;
public:
    Test(int x)
        :a(x)
    {}
    friend Test& operator=(Test &obj1, Test &obj2);
};

Test& operator=(Test &obj1, Test &obj2)//Not implemented fully. just for test.
{
    return obj1;
}

它会导致以下错误：

错误 C2801：“operator =”必须是非静态成员

为什么不能使用 friend 函数来重载赋值运算符？编译器允许使用 friend 重载其他运算符，例如 += 和 -=。支持 operator= 的固有问题/限制是什么？

Answer 1

首先，应该注意的是，这与具体实现为朋友的操作员无关。它实际上是将复制赋值实现为成员函数或非成员（独立）函数。该独立函数是否成为友元完全无关：可能是，也可能不是，具体取决于它想要在类内访问什么。

现在，这个问题的答案在 D&E 书中给出了（C++ 的设计与演化 ）。原因是编译器总是为类声明/定义成员复制赋值运算符（如果您没有声明自己的成员复制赋值运算符）。

如果语言还允许将复制赋值运算符声明为独立（非成员）函数，则最终可能会得到以下结果

// Class definition
class SomeClass {
  // No copy-assignment operator declared here
  // so the compiler declares its own implicitly
  ...
};

SomeClass a, b;

void foo() {
  a = b;
  // The code here will use the compiler-declared copy-assignment for `SomeClass`
  // because it doesn't know anything about any other copy-assignment operators
}

// Your standalone assignment operator
SomeClass& operator =(SomeClass& lhs, const SomeClass& rhs);

void bar() {
  a = b;
  // The code here will use your standalone copy-assigment for `SomeClass`
  // and not the compiler-declared one 
}

如上例所示，复制赋值的语义将在翻译单元的中间发生变化- 在声明独立运算符之前，使用编译器的版本。声明后，将使用您的版本。程序的行为将根据您放置独立复制赋值运算符的声明的位置而改变。

这被认为是不可接受的危险（确实如此），因此 C++ 不允许将复制赋值运算符声明为独立函数。

确实，在您的特定示例中，恰好专门使用了 friend 函数，该运算符很早就在类定义中声明了（因为这就是声明友元的方式）。因此，在您的情况下，编译器当然会立即知道您的运算符的存在。然而，从 C++ 语言的角度来看，一般问题与友元函数没有任何关系。从C++语言的角度来看，这是关于成员函数与非成员函数的问题，并且出于上述原因完全禁止复制赋值的非成员重载。

Answer 2

因为编译器提供的默认 operator= （成员复制）始终优先。也就是说，你的朋友 operator= 永远不会被调用。

编辑：这个答案正在回答

支持 = 运算符的固有问题/限制是什么？

问题的一部分。这里的其他答案引用了标准中说你不能这样做的部分，但这很可能就是标准的该部分以这种方式编写的原因。

Answer 3

因为有一些运营商必须是会员。这些运算符是：
运算符[]
运算符=
运算符()
operator->

和类型转换运算符，如operator int。

尽管有人可能能够准确地解释为什么运算符 = 必须是成员，但他们的论点不能适用于列表中的其他人，这使我相信“​​为什么”的答案是“只是因为”。

华泰

Answer 4

$13.5.3 - “赋值运算符应由只有一个参数的非静态成员函数来实现。因为如果用户未声明，则为类隐式声明复制赋值运算符operator=（12.8），因此基类赋值运算符总是被派生类的复制赋值运算符隐藏。”

Answer 5

operator= 是一个特殊的成员函数，如果您不自己声明，编译器将提供它。由于 operator= 的这种特殊状态，要求它成为成员函数是有意义的，因此不可能同时存在编译器生成的成员 operator=和用户声明的朋友 operator= 并且无法在两者之间进行选择。

Answer 6

为什么友元函数不能用于重载赋值运算符？

简短回答：只是因为。

更长的答案：这就是修复语法的方式。一些运算符必须是成员函数。赋值运算符是其中之一，

Answer 7

operator= 的目的是对当前对象进行赋值操作。那么 LHS 或左值是相同类型的对象。

考虑 LHS 是整数或其他类型的情况。这是由operator int() 或相应的operator T() 函数处理的情况。因此，LHS 的类型已经定义，但非成员 operator= 函数可能会违反这一点。

因此它被避免了。

Answer 8

因为类中已经有'='的隐式运算符重载函数来进行浅复制。因此，即使您使用友元函数进行重载，您也永远无法调用它，因为我们所做的任何调用都会调用隐式浅复制方法，而不是重载的友元函数。

Answer 9

本文适用于 C++11

为什么有人想要非成员 operator=？好吧，使用成员 operator= 则可以使用以下代码：

Test const &ref = ( Test() = something ); 

它创建一个悬空引用。非成员运算符可以修复此问题：

Test& operator=(Test &obj1, Test obj2)

因为现在纯右值 Test() 将无法绑定到 obj1。事实上，这个签名将强制我们永远不会返回悬空引用（当然，除非我们提供了一个悬空引用）——该函数总是返回一个“有效”左值，因为它强制使用左值进行调用。

然而，在 C++11 中，现在有一种方法可以指定只能在左值上调用成员函数，因此您可以通过编写成员函数来实现相同的目标：

Test &operator=(Test obj2) &
//                        ^^^

现在，上面带有悬空引用的代码将无法编译。

---

注意。 operator= 应通过值或 const 引用获取右侧。在实现复制和交换习惯用法时，按值获取非常有用，用于轻松编写安全（但不一定是最快）复制赋值和移动赋值运算符的技术。