本节书摘来自异步社区出版社《C++面向对象高效编程（第2版）》一书中的第3章，第3.4节，作者： 【美】Kayshav Dattatri，更多章节内容可以访问云栖社区“异步社区”公众号查看。

3.4 赋值操作符

C++面向对象高效编程（第2版）
现在，让我们分析main程序中的语句：

a = b ;　　// 将一个栈赋值给另一个栈
在该语句中，我们将对象b赋值给对象a，使用赋值操作符完成赋值操作。如果a和b都是简单的整数，无论a中的值是什么，编译器都会用b中的值将其擦写（overwrite）。就是这么简单。但是在该例中，a和b都是我们创建的对象，这意味着由我们负责赋值操作。我们知道TIntStack类对象之间如何进行赋值，并且能够实现赋值操作符。对于任何赋值操作符，都应注意以下几点：

（1）确保对象没有自我赋值（如a = a）。

（2）复用被赋值对象中的资源或销毁它。

（3）从源对象中将待复制内容复制到目的对象。

（4）最后，返回对目的对象的引用。

赋值操作符已在类中声明。TIntStack类的赋值操作符签名如下：

TIntStack& operator=(TIntStack& source) // ①
TIntStack& operator=(const TIntStack& source) // ②```
下面是赋值操作符的实现：

TIntStack& TIntStack::operator=(const TIntStack& source)
{
　　// 检查自我复制（即a = a）。
　　// source是被赋值的对象，&source给出对象source的地址，
　　// ‘this’是被赋值对象的地址。
　　if (this == &source) {
　　　　　　cout << “Warning: Assignment to self.n”;
　　　　　　return *this;
　　}
　　　/*
　　　　如果源对象栈中的元素数目小于或等于目的对象的大小，则没有任何问题。
　　　　我们要做的就是复制栈中相应的元素和_count变量。
　　　　但是，如果源对象栈中元素的数目大于目的对象的大小，则必须先删除目的对象_sp中内存，再为其分配新的内存（与源对象栈中元素的数目相等），然后复制所有元素。
　　　*/
　　if (source._count > this->_size) {
　　　　　// 源对象中元素的数目大于目的对象的大小，
　　　　　// 删除_sp中的内存并重新分配内存。
　　　　　// 见下文解释
　　　　　　delete [] _sp;
　　　　　　this->_size = source._size;
　　　　　　_sp = new int [ this->_size ];
　　}
　　　　// 无论是小于等于还是大于的情况，都会用到以下代码遍历栈，
　　　　// 并复制元素
　　　　for (int i = 0; i < source._count; i++)
　　　　　　this->_sp[i] = source._sp[i]; // 复制元素
　　　　this->_count = source._count;
　　　　return *this; // 见下文解释
}`
分析：赋值操作由程序员显式完成，系统（编译器）绝不会直接调用它。赋值是在两个现有对象之间执行的操作。如下语句：
`
a = b;`
当a和b都为对象时，上句可解析为：
`
operator=(b);`
换言之，左侧（left hand side，缩写为LHS）的对象调用成员函数operator=()，右侧（right hand side，缩写为RHS）操作数作为operator=()的参数。赋值操作右侧的对象（该例中为b）不能被修改，该操作的副作用（side effect）是：返回对左侧对象（该例中为a）的引用。因为不能修改右侧的对象（我们只能读取右侧对象并写入左侧对象），所以该对象应作为const实参传递给operator=()函数（如②所示）。然而，如果使用没有const参数的赋值操作符（如①所示），就可以被修改右侧的对象。我们并不推荐使用①这样的赋值操作符，因为类的用户并不希望在赋值操作中改变右侧的对象。由于a和b都是真正的现有对象，因此，将b赋值给a时，a中的值将被b中的值擦写（overwrite）。

记住：

如果我们在类中未提供赋值操作符，编译器会为类生成一个默认赋值操作符（编译器绝不会自动调用它，但确实会生成一个）。但是，这样的默认赋值操作符可能无法满足我们的要求，下一章将对此作详细介绍。

在任何赋值操作中，我们要做的就是将数据从源对象赋值到目的对象。一般而言，这很容易，但在某些情况下会有困难。在TIntStack的示例中，我们需要从源栈赋值到目的栈。如果源栈中的元素数目少于或等于目的栈中的可用空间，赋值操作便非常简单，只需复制相应的栈元素。但是，如果源栈中的元素数目多于目的栈所能持有的数目会怎样？我们不允许这样的操作发生，在打印出错误消息后将从赋值操作返回。不过，这样限制太大。或者，我们可以改变目的栈的大小，使其能容纳所有元素。如果我们接受后者的方案，就需要在目的栈上为源栈的元素分配与源栈大小相等的新内存。这样做之前，我们还要删除目的栈中_sp所指向的现有内存（无法扩展这个内存），这就是上面的赋值操作符中调用delete所完成的任务。一旦完成内存分配，我们就只需要复制相应的元素进栈即可（见图3-3和图3-4）。

（摘自前面的main程序）

TIntStack a(5);　　// 自动对象（_auto object_），在退出main时被销毁
TIntStack b(20);　　// 另一个自动对象```
最后，我们返回对目的对象（也就是栈a）的引用。你可能会质疑，为什么要这样做？假设我们编写了一个级联赋值操作（cascaded assignment operation）如下：`c = a = b; // 将b赋值给a，然后将结果再赋值给c`
赋值操作按从右到左的顺序执行1，此表达式即转换为：`c = (a = b); // 首先将b赋值给a，然后将结果赋值给c`
警告：
既然可以写“a = b;”，那么也可以写`a = a;  // 语法上正确，但是逻辑上错误！`
这样的表达式可能会通过指针和引用（别名）直接或间接地发生，我们的实现必须检查是否出现这种情况。因此，必须核实源地址和目的地址是否相同。如果赋值发生在相同的对象之间，则不会进行任何操作，只返回对目的对象的引用。这就是上面示例的实现中，进行自我赋值检查所完成的工作。如果没有进行自我赋值检查，可能会导致严重问题。考虑以下包含指针数据成员的TString类：

class TString {
　　　　public:
　　　　　　　TString (const char* sp) {
　　　　　　　　　_data = new char[strlen(sp) + 1];
　　　　　　　　　 strcpy(_data, sp);
　　　　　　　}
　　　　　　　TString & operator=(const TString & assign);
　　　　private:
　　　　　　　char* _data; // 字符串指针
};
TString& TString::operator=(const TString& assign)
{
　　　　// 错误代码，未检查自我赋值　　
　　delete [] this->_data; // ①
　　　data = new char[strlen(assign.data) + 1]; // ②
　　　strcpy(this->_data, assign._data);
　　　return *this;
}
TString　x1(“Text string1”);
x1 = x1;`
以上operator=的实现并不安全，其中的①，删除的是x1._data。接着在②中，我们又试图使用assign._data。因为左侧的对象（*this）与右侧的对象（assign）是同一个对象，即assign._data与x1._data相同。所以，我们搬起石头砸自己的脚。当执行②时，该程序可能崩溃，或者在别的地方出现问题。因此，在赋值操作的实现中，必须进行自我赋值检查。

图3-4

将b赋值给a非常简单，之前的示例中已介绍过赋值如何工作。我们希望将赋值（b赋值给a）的结果再赋值给c。为使其正常工作，第1个赋值操作应返回a的值（或对a的引用）。否则，从a到c的第2次赋值就会出问题。通常，在C和C++中，我们只知道使用赋值操作的结果，却并不了解内部的实现。例如，正是因为赋值操作的副作用，才使得以下代码可以正常工作：

int i = 10, j = 20; // 此处无赋值操作
int k;
cout << (i = j) << endl; // 将j赋值给i，并打印赋值结果①。if (k = j) ｛　// 将j赋值给k，如果结果不为0，执行if体内部的语句②。// 省略此处代码
}```
在①中，完成赋值后返回i的值，并打印该值。与此类似，在②中，将j赋值给k，完成赋值后，返回k的值并与0进行比较。为了让以上赋值都能正常工作，必须确保在赋值操作完成后，该赋值操作返回对a对象的引用。`Pascal：`在类似Pacal的语言中，以下的赋值操作没有副作用：`a := b;`
在赋值后无法返回a的值。因此，以下语句`c := a := b;`
无法在Pascal（以及类似的语言，如Modula-2）中使用。思考：对比复制构造函数和赋值操作符中的代码，会发现很多相似的地方。它们都将现有对象复制到另一个对象中。但是，你能否发现两处代码的主要差别？换言之，复制构造函数和赋值操作符的代码有何区别？能否让它们共享实现？为完成TIngStack的示例，其余的成员函数实现如下：

void TIntStack::Push(int what)
{
　　　if (_count < _size) {　　// 如有更多空间储存元素
　　　　_sp[_count] = what;　　// 储存元素
　　　　_count++;　　// 递增count
　　　}
　　　else {
　　　　cout << “Stack is FULL. Cannot Push value” << what << endl;
　　　}
}
int TIntStack::Pop()
{
　　　if (_count <= 0) {　// 栈为空
　　　　　cout << “Stack is EMPTYn”;
　　　　　exit (1);　　// 如果失败如何报错？可在此处抛出异常。
　　　}
　　　_count--;
　　　return　_sp[_count];
}
unsigned TIntStack::HowMany() const
{
　　　return　_count;
}`
1此处用到操作符重载和操作符结合律，将在第8章中介绍。在本章讨论中，只需记住赋值从右向左结合。
本文仅用于学习和交流目的，不代表异步社区观点。非商业转载请注明作译者、出处，并保留本文的原始链接。