C++ 11的移动语义 - 清晰的示例及浅显的说理

C++ 11引入了移动语义以提高对象“复制”的效率，这种复制效率对于容器而言至关重要。清晰明了地向学生解释移动语义、右值引用并不是一件容易的事，为此，我们设计了一个简单明了的示例，化繁为简地说理，试图解决这一问题。

本文引用自作者编写的下述图书; 本文允许以个人学习、教学等目的引用、讲授或转载，但需要注明原作者"海洋饼干叔
叔"；本文不允许以纸质及电子出版为目的进行抄摘或改编。
1.《Python编程基础及应用》，陈波，刘慧君，高等教育出版社。免费授课视频 Python编程基础及应用
2.《Python编程基础及应用实验教程》, 陈波，熊心志，张全和，刘慧君，赵恒军，高等教育出版社Python编程基础及应用实验教程
3. 《简明C及C++语言教程》，陈波，待出版书稿。免费授课视频

19.9 移动语义*

19.9.1 对象复制的编译优化

编译器会穷尽所能进行代码优化，避免不必要的对象复制行为。在下述代码中，我们定义了一个Message类，其中包含一个动态分配的缓冲区buffer用于存储真正的消息文本。此外，Message类还定义了拷贝构造函数以及自定义operator=()操作符函数。理论上，一个Message对象可以十分“巨大”，对其进行复制费时费力。

//Project - MessageCopy
#include 
#include 
using namespace std;

class Message {
    char* buffer = nullptr;
public:
    int id = 0;
    Message(){ cout << "Constructor, id = " << id << endl; }

    Message(int id, const char* text){
        cout << "Constructor, id = " << id << endl;
        this->id = id;
        buffer = new char[strlen(text)+1];
        strcpy(buffer,text);
    }

    Message(const Message& r){
        cout << "Copy Constructor, from " << r.id << " to " << id << endl;
        id = r.id;
        if (buffer) delete [] buffer;
        buffer = new char[strlen(r.buffer)+1];
        strcpy(buffer,r.buffer);
    }

    Message& operator=(const Message& r){
        cout << "operator=(), from " << r.id << " to " << id << endl;
        id = r.id;
        if (buffer) delete [] buffer;
        buffer = new char[strlen(r.buffer)+1];
        strcpy(buffer,r.buffer);
        return *this;
    }

    const char* content() const { return buffer; }

    ~Message(){
        cout << "Destructor, id = " << id << endl;
        if (buffer) delete[] buffer;
    }
};

Message fetchMessage(){
    Message m(1,"Washington, this is pearl harbour, we are under japanese attack!");
    return m;
}

int main() {
    Message s = fetchMessage();
    cout << "Message " << s.id << ": " << s.content() << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

上述代码的执行结果为：

Constructor, id = 1
Message 1: Washington, this is pearl harbour, we are under japanese attack!
Destructor, id = 1
1
2
3

第44 ~ 47行：fetchMessage()函数构造“局部”对象m，然后返回。

第50行：main()函数的“局部”对象s接收fetchMessage()的返回对象。

逻辑上，上述代码至少存在两个Message对象，分别是main()函数内的s以及fetchMessage()函数里的m。多数读者会推导出如下的代码执行序列：m被构造并返回；返回的m作为参数参与s的拷贝构造；m被析构；s在main()函数返回时被析构。但作者计算机上的执行结果不支持上述推导，整个程序的生命周期内，只有编号为1的对象被构造及析构，整个程序事实上只生成了一个Message对象！

显然，这是编译器代码优化的结果。编译器认为先构造一个临时对象m再复制给s是没有必要的，它选择绕过中间对象的m，直接构造s：在fetchMessage()函数内对对象m进行的操作，事实上发生在外部的s对象上。从程序结果上看，编译器做得很好，省时省力且没有“误解”程序员的本意。

但编译器还没有厉害到可以完美地避免一切不必要的对象复制的程度。将上述代码的main()函数稍作调整：在第50行先构造对象s，然后再用s接受fetchMessage()返回对象的赋值。

int main() {
    Message s;
    s = fetchMessage();
    cout << "Message " << s.id << ": " << s.content() << endl;
    return 0;
}
1
2
3
4
5
6

调整后的代码在作者的计算机上获得了如下的执行结果：

Constructor, id = 0
Constructor, id = 1
operator=(), from 1 to 0
Destructor, id = 1
Message 1: Washington, this is pearl harbour, we are under japanese attack!
Destructor, id = 1
1
2
3
4
5
6

根据程序执行结果，我们可以逐行反推代码的执行序列：1).编号为0的对象s被构造；2).编号为1的对象m被构造；3).由于s已存在，返回对象m通过s的operator=()操作符函数复制给s；4).对象m析构；5).打印s的内容；6).对象s析构，由于s由m复制而来，所以执行结果第6行显示的编号为1。

“不必要”的对象复制发生在第3步。在operator=()操作符函数里，s对象分配了新的缓冲区buffer，然后一个字节又一个字节地从m对象复制缓冲区内容。考虑到临时对象m将很快被销毁，如果直接将m对象的缓冲区“偷”走，直接“挪”给s对象，将显著提高程序的执行效率。【C++ 11】引入了移动语义（move semantics）来解决这个问题。

19.9.2 右值引用

int a = 69;
a = a + 3;
1
2

C++标准引入了术语左值（lvalue）和右值（rvalue）来区分两种不同类型的对象。上述代码中的a具有确定的内存地址，它可以被赋值，我们称a为一个左值对象。在机器语言层面，表达式a+3的计算通常是借助于CPU寄存器来完成的，然后再从寄存器复制到对象a的内存。这个位于寄存器的临时对象没有确定的内存地址且“用完即弃”，我们称该对象为一个右值对象。

int a = 69;
int& ar = a;    //正确：左值引用ar绑定左值对象a
ar = ar + 3;
int& t = a + 2; //错误：左值引用不可以绑定右值对象
1
2
3
4

严格意义上，本书第6章所讨论的引用是指左值引用：对左值对象的引用。上述代码中的ar（reference of a）即为左值引用，它绑定了左值对象a。如第6章所述，ar事实上“包含”了对象a的指针，它通过该地址来“引用”左值对象a。一个左值引用，既可以放在=号操作符的左边被赋值，也可以放在=号右边的表达式中被取值（第3行）。如第4行注释所述，a+2是一个右值对象，它不具备确定的内存地址且用完即弃，无法将左值引用t与其绑定。

int a = 69;
int&& arr = a + 2;
arr = arr + 3;
cout << "address of arr: " << &arr << endl;
1
2
3
4

【C++ 11】使用&&来标识右值引用：对右值对象的引用。上述代码中的arr（reference of right value object a）即为右值引用，它绑定了右值对象a + 2。右值对象通常不会被分配内存，上述代码中第3行和第4行的存在“迫使”编译器为临时对象a+2分配了内存，从而使得右值引用arr可以被赋值甚至被取地址。请读者不要写出如第3行、第4行这样正确而又十分有害的代码，如果确实需要一个对象来保存计算的中间结果，普通的左值对象是更佳选择。

int a = 69;
int&& arr1 = a;  //错误：右值引用不可以直接引用左值对象
int&& arr2 = std::move(a); //正确：将左值引用强制类型转换成右值引用
1
2
3

如上述代码第2行的注释所述，编译器不允许右值引用绑定在左值对象上，这就好比一个正在使用中的铁制下水道井盖被标识为“无主丢弃物”：右值引用arr1“告诉”编译器其引用的对象a将很快被销毁，而事实上左值对象a将在其作用域内“长期”生存。稍后我们将会看到一个右值引用所引用对象的“资源”可能会被“偷”走，此时，任何对那个被引用的左值对象的访问都十分危险。

上述代码的第3行通过std::move()函数强制性地为左值对象a建立右值引用，读者可以自行查看std::move()的源代码加以确认。这是程序员对编译器的承诺：右值引用arr2所引用的对象虽然是个左值，但我承诺代码将不再访问左值对象a，a的资源可以随时被“偷走”。当然，作为一个普通的int对象，a没什么资源可偷。但是，上一小节所介绍的Message对象中的缓冲区，有被偷的价值。

19.9.3 移动赋值及移动构造

为了避免不必要的对象复制，我们修改了19.9.1节中的代码：

//Project - MessageMove
#include 
#include 
using namespace std;

class Message {
    char* buffer = nullptr;
public:
    int id = 0;
    Message(){ cout << "Constructor, id = " << id << endl; }

    Message(int id, const char* text){
        cout << "Constructor, id = " << id << endl;
        this->id = id;
        buffer = new char[strlen(text)+1];
        strcpy(buffer,text);
    }

    Message(const Message& r){
        cout << "Copy Constructor, from " << r.id << " to " << id << endl;
        id = r.id;
        if (buffer) delete [] buffer;
        buffer = new char[strlen(r.buffer)+1];
        strcpy(buffer,r.buffer);
    }

    Message(Message&& r) noexcept {
        cout << "Move Constructor, from " << r.id << " to " << id << endl;
        id = r.id;
        buffer = r.buffer;
        r.buffer = nullptr;
    }

    Message& operator=(const Message& r){
        cout << "operator=(), from " << r.id << " to " << id << endl;
        id = r.id;
        if (buffer) delete [] buffer;
        buffer = new char[strlen(r.buffer)+1];
        strcpy(buffer,r.buffer);
        return *this;
    }

    Message& operator=(Message&& r) noexcept {
        cout << "move operator=(), from " << r.id << " to " << id << endl;
        if (this==&r) return *this;
        id = r.id;
        if (buffer) delete[] buffer;
        buffer = r.buffer;
        r.buffer = nullptr;
        return *this;
    }

    const char* content() const { return buffer; }

    ~Message(){
        cout << "Destructor, id = " << id << endl;
        if (buffer) delete[] buffer;
    }
};

Message fetchMessage(){
    Message m(1,"Washington, this is pearl harbour, we are under japanese attack!");
    return m;
}

int main() {
    Message s;
    s = fetchMessage();
    cout << "Message " << s.id << ": " << s.content() << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

上述代码的执行结果为：

Constructor, id = 0
Constructor, id = 1
move operator=(), from 1 to 0
Destructor, id = 1
Message 1: Washington, this is pearl harbour, we are under japanese attack!
Destructor, id = 1
1
2
3
4
5
6

相较于19.9.1节，上述代码主要有两处修改。

第27 ~ 32行：Message的移动构造函数（move constructor），请读者注意其参数为Message&& r，这表明右值引用r所引用的对象是一个“无用”的临时对象，移动构造函数将其中的资源“移动”到当前对象之下，以避免不必要的复制。代码中的noexcept用于向编译器表明该函数不会抛出异常▲，详见第23章。

第31行：将r的buffer指针设为空，这十分重要，它确保了那个关键资源已被移走的临时对象的析构过程不会出错。如果不这样做，r所引用的临时对象被销毁时，其析构函数将释放已不再属于它的缓冲区。谨慎地确保一个被移动后的对象处于可以安全析构的状态，是程序员的职责。

第43 ~ 51行：Message的移动赋值（move assignment）操作符函数。类似地，该函数的参数为Message&& r，这表明右值引用r所引用的对象中的资源可以“移动”到当前对象之下，以避免不必要的复制。

第45行：如果当前对象的地址等于r的地址，说明对象在自己对自己赋值，直接返回。这种情况下常规代码中不太容易遇到，但做为谨慎的程序员，应考虑这种情况。显然，自己“移动”自己的资源无法做到。

第49行：将r的buffer指针设为空，确保被移动的对象处于可安全析构的状态。

从执行结果的第3行可知，当fetchMessage()函数返回的临时对象m赋值给对象s时，编译器为我们选择了移动赋值操作符函数而不是普通的赋值操作符函数。在移动赋值操作符函数里，对象s在删除自己的原有缓冲区之后，没有新建缓冲区并逐字节复制，而是移走了临时对象m的缓冲区资源为我所用。这样做，既加快了程序的执行速度，同时又不违背程序员的意图：在fetchMessage()函数返回后，局部对象m确实不再被需要了，从中获取可利用的资源是无害且有益的。

为了观察移动构造函数的行为，我们将上述程序中的main()函数修改为：

int main() {
    Message s1(1,"Hello, Hawaii.");
    Message s2 = s1; //等价于Message s2(s1)
    cout << "Message " << s2.id << ": " << s2.content() << endl;
    return 0;
}
1
2
3
4
5
6

修改后程序的执行结果为：

Constructor, id = 1
Copy Constructor, from 1 to 0
Message 1: Hello, Hawaii.
Destructor, id = 1
Destructor, id = 1

1
2
3
4
5
6

从执行结果的第2行可知，编译器选择通过拷贝构造函数完成s1到s2的复制。这样做是合理的，语法上s1是左值对象，其引用也是左值引用，无法与移动构造的右值引用参数相匹配；逻辑上，s1不是临时对象，它应在作用域范围内“长生”，不可以“偷走”它的资源。

如果程序员确定不再需要s1对象，要求程序将s1的资源移动到s2，则应通过std::move()函数生成s1的右值引用。

int main() {
    Message s1(1,"Hello, Hawaii.");
    Message s2 = std::move(s1); //强行生成对s1的右值引用
    cout << "Message " << s2.id << ": " << s2.content() << endl;
    return 0;
}
1
2
3
4
5
6

修改后程序的执行结果为：

Constructor, id = 1
Move Constructor, from 1 to 0
Message 1: Hello, Hawaii.
Destructor, id = 1
Destructor, id = 1
1
2
3
4
5

执行结果的第2行显示，由于程序员“承诺”s1对象不再被需要，编译器选择移动构造函数来完成从s1到s2的“复制”。在复制过程中，缓冲区资源从s1移动到了s2。语法上，std::move(s1)的类型为Message&&，它与移动构造函数的参数类型完美匹配。

19.9.4 移动语义与容器

移动语义与容器的性能息息相关。在19.2节，我们观察到当向量的容量不足以存储新加入的元素时，向量会申请新空间，然后通过拷贝构造函数将已有元素复制到新的存储位置；同时，新加入元素的复制也是通过拷贝构造完成的。

细心的读者或许早已发现这是一种效率低下的“向量的生长”方法。编译器做出这种选择的原因是19.2节中的Fish类型没有移动构造函数。

19.9.3节中的Message类型有自定义的移动构造及移动赋值函数，我们通过下述代码观察元素类型为Message的向量的生长。

//Project - MessageContainer
#include 
#include 
#include 
using namespace std;

//... 与前一小节完全相同的Message类型定义

int main() {
    vector<Message> msgs;
    Message s1(1,"Hello, Hawaii.");
    Message s2(2,"Hello, Phuket.");
    msgs.push_back(s1);
    cout << "-------------------------------------\n";
    msgs.push_back(std::move(s2));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码的执行结果为：

Constructor, id = 1
Constructor, id = 2
Copy Constructor, from 1 to 0
-------------------------------------
Move Constructor, from 2 to 0
Move Constructor, from 1 to 0
Destructor, id = 1
Destructor, id = 2
Destructor, id = 1
Destructor, id = 1
Destructor, id = 2
1
2
3
4
5
6
7
8
9
10
11

说明：在读者的计算机上，考虑到向量的空间管理策略的差异，执行结果可能不同。

第 11、12行：s1、s2的构建，对应执行结果的第1、2行。

第13行：通过msgs.push_back()函数将s1对象加入向量。由于s1是左值对象，真正被加入向量的是s1的复制品，对象复制通过拷贝构造完成，参见执行结果的第3行。

第15行：通过std::move()强行生成s2的右值引用，将s2加入向量。由于std::move(s2)为右值引用，向量执行了Message的移动构造函数来复制对象，s2的资源被移动到了向量的内部元素中。相关移动构造函数的输出见执行结果的第5行。

同时，由于空间不足，向量进行了扩容。向量内原有的编号为1的Message对象也从旧空间搬家至了新空间，为了提高效率，向量通过移动构造来完成这种迁移。相关输出见执行结果的第6行。

执行结果的7 ~ 11行对应了5个对象的析构。这5个对象是：s1、s2、msgs向量内的两个元素以及因msgs向量扩容被迁移的旧对象。

如果读者试图查看向量的push_back()源代码，至少可以看到两个函数名重载的版本：其中一个接受常量型左值引用，而另一个接受右值引用。其大致形式请参考下述伪代码：

template <class T>

class vector {

public:

void push_back(const T& r) {…}

void push_back(T&& rr) {…}

}
1
2
3
4
5
6
7
8
9
10
11

push_back(const T& r)通过拷贝构造完成对象复制，push_back(T&& rr)则通过移动构造来完成。合理推测，向量的其它成员函数，比如insert()，也进行了类似的函数名重载。

为了帮助更多的年轻朋友们学好编程，作者在B站上开了两门免费的网课，一门零基础讲Python，一门零基础C和C++一起学，拿走不谢！

简洁的C及C++

Python编程基础及应用

如果你觉得纸质书看起来更顺手，目前Python有两本，C和C++在出版过程中。

Python编程基础及应用

Python编程基础及应用实验教程