为什么复制赋值运算符必须返回引用/常量引用？

Question

在 C++ 中，我不清楚从复制赋值运算符返回引用的概念。为什么复制赋值运算符不能返回新对象的副本？另外，如果我有类 A 和以下内容：

A a1(param);
A a2 = a1;
A a3;

a3 = a2; //<--- this is the problematic line

operator= 定义如下：

A A::operator=(const A& a)
{
    if (this == &a)
    {
        return *this;
    }
    param = a.param;
    return *this;
}

Answer 1

稍微澄清一下为什么最好通过 operator= 的引用返回而不是按值返回 --- 因为链 a = b = c 如果 a返回值。

如果您返回参考，则只需完成最少的工作。一个对象的值被复制到另一个对象。

但是，如果您按 operator= 的值返回，则每次调用赋值运算符时都会调用构造函数和析构函数！

所以，给定：

A& operator=(const A& rhs) { /* ... */ };

那么，

a = b = c; // calls assignment operator above twice. Nice and simple.

但是，

A operator=(const A& rhs) { /* ... */ };

a = b = c; // calls assignment operator twice, calls copy constructor twice, calls destructor type to delete the temporary values! Very wasteful and nothing gained!

总而言之，按价值返回没有任何收获，反而会失去很多。

（注意：这并不是为了解决让赋值运算符返回左值的优点。请阅读其他文章以了解为什么这样做可能更好）

Answer 2

严格来说，复制赋值运算符的结果不需要返回引用，尽管为了模仿 C++ 编译器使用的默认行为，它应该返回对被赋值对象的非常量引用（隐式生成的复制）赋值运算符将返回非常量引用 - C++03: 12.8/10)。我见过很多从复制赋值重载中返回 void 的代码，但我不记得这是什么时候导致了严重的问题。返回 void 将阻止用户“赋值链”(a = b = c;)，并阻止在测试表达式中使用赋值结果。虽然这种代码绝不是闻所未闻，但我也不认为它特别常见 - 特别是对于非原始类型（除非类的接口旨在用于此类测试，例如 iostream）。

我并不是建议您这样做，只是指出这是允许的，而且它似乎不会引起很多问题。

这些其他 SO 问题是相关的（可能不完全是骗人的），其中包含您可能感兴趣的信息/意见。

• 有人吗发现需要将复制赋值运算符的返回参数声明为 const？
• 重载赋值运算符在 C++ 中

Answer 3

当您重载operator=时，您可以编写它来返回您想要的任何类型。如果您非常想要，可以重载 X::operator= 以返回（例如）某个完全不同的类 Y 或 Z 的实例代码>.不过，这通常是非常不可取的。

特别是，您通常希望像 C 一样支持 operator= 的链接。例如：

int x, y, z;

x = y = z = 0;

既然如此，您通常希望返回被分配类型的左值或右值。只剩下是否返回对 X 的引用、对 X 的 const 引用或 X（按值）的问题。

返回 X 的常量引用通常是一个糟糕的主意。特别是，允许​​ const 引用绑定到临时对象。临时变量的生命周期会延长到它所绑定的引用的生命周期，但不会递归地延长到可能分配给的任何内容的生命周期。这使得返回悬空引用变得很容易——const 引用绑定到一个临时对象。该对象的生命周期延长到引用的生命周期（在函数结束时结束）。当函数返回时，引用和临时的生命周期已经结束，因此分配的是悬空引用。

当然，返回非常量引用并不能提供完全的保护，但至少可以让您更加努力地工作。您仍然可以（例如）定义一些本地变量，并返回对它的引用（但大多数编译器也可以并且会对此发出警告）。

返回值而不是引用存在理论和实际问题。从理论上讲， = 通常的含义与在这种情况下的含义之间存在基本脱节。特别是，赋值通常意味着“获取此现有源并将其值分配给此现有目标”，它开始意味着更像“获取此现有源，创建它的副本，并将该值分配给此现有目标。 ”

从实际角度来看，尤其是在发明右值引用之前，这可能会对性能产生重大影响——在将 A 复制到 B 的过程中创建一个全新的对象是意想不到的，而且通常非常慢。例如，如果我有一个小向量，并将其分配给一个较大的向量，我预计最多需要时间来复制小向量的元素加上（一点）固定开销来调整大小目标向量。如果涉及两个个副本，一个从源到临时，另一个从临时到目标，以及（更糟糕的是）临时向量的动态分配，我对操作复杂性的期望将是完全被摧毁。对于小向量，动态分配的时间很容易比复制元素的时间高很多倍。

唯一的其他选项（在 C++11 中添加）是返回右值引用。这很容易导致意外结果 - 像 a=b=c; 这样的链式赋值可能会破坏 b 和/或 c 的内容，这将是非常出乎意料的。

这就使得返回普通引用（不是对 const 的引用，也不是右值引用）成为（合理地）可靠地产生大多数人通常想要的结果的唯一选项。

Answer 4

部分原因是返回对 self 的引用比按值返回更快，但除此之外，它还允许原始类型中存在的原始语义。

Answer 5

operator= 可以定义为返回您想要的任何内容。您需要更具体地了解问题的实际情况；我怀疑您的复制构造函数在内部使用 operator= ，这会导致堆栈溢出，因为复制构造函数调用 operator= ，它必须使用复制构造函数返回 A 的价值无限。

Answer 6

对于用户定义的 operator= 的结果类型没有核心语言要求，但标准库确实有这样的要求：

C++98 §23.1/3：

”这些组件中存储的对象类型必须满足CopyConstructible的要求
类型 (20.1.3)，以及 Assignable 类型的附加要求。

C++98 §23.1/4：

” 在表 64 中，T 是用于实例化容器的类型，t 是 TT，而 u 是一个值（可能是 const）T。

---

按值返回副本仍将支持赋值链，如 a = b = c = 42;，因为赋值运算符是右结合的，即被解析为a = (b = (c = 42));。但返回副本会禁止像 (a = b) = 666; 这样无意义的构造。对于较小的类，返回副本可能是最有效的，而对于较大的类，通过引用返回通常是最有效的（而副本则效率极低）。

在了解标准库要求之前，我曾经让 operator= 返回 void，以提高效率并避免支持基于副作用的不良代码的荒谬。

---

对于 C++11，对于赋值运算符的 default 还需要 T& 结果类型，因为

C++11 §8.4.2/1：

” 显式默认的函数应 [...] 具有相同的声明函数类型（除了可能不同的引用限定符以及除了
对于复制构造函数或复制赋值运算符，参数类型可以是“对非 const T 的引用”，其中 T 是成员函数的类的名称）就好像它已经被隐式声明了

Answer 7

1. 复制赋值不应为 void，否则赋值链将无法工作

a = b = c; 
// because assignment operator is right-associative
// it is equal to
a = (b = c);  // oops, (b = c) return nothing, the code won't compile

2. 复制赋值不应返回值，否则将调用不必要的复制构造函数和析构函数

// suppose a, b and c are of type X, which holds some resource that will take efforts to copy
a = b = c;
// is equal to
X temp1.X::( (b = c) ); // copy constructor called once
X temp2.X::( a.X::operator=(temp1) ); // copy constructor called twice; temp1 destructed inside a.X::operator=(temp1)

3. 复制赋值不应返回右值引用，因为它可能具有已赋值的值对象移动。再次以赋值链为例

a = b = c;
// if a has a copy assignment overload that takes rvalue reference as argument like the following
X& operator=(X &&);
// then the result of (b = c) will be moved into a, and make b an invalid object afterwards

Answer 8

我想，因为用户定义的对象应该表现得像内置类型。
例如：

char c;
while ((c = getchar()) != -1 ) {/* do the stuff */}