Life is short, use emplace_back()。探究一下C++11的push_back, move, rvalue, emplace_back

前言

一直以来写代码，vector想都没想就是push_back，今天发现的C++11的emplace_back碾压了传统的push_back

总结一句话：Life is short, use emplace_back()。

简单叙述原因：emplace_back可以“同时构造和插入，一次搞定”，push_back需要“先构造，后插入，而且插入的时候还伴随着拷贝或者移动”。

Talk is cheap, show me the code

#include <iostream>
#include <utility>
#include <chrono>
#include <vector>
#include <string>
using namespace std;
using namespace chrono;

int main()
{
vector<string> v;
int num = 100000;
v.reserve(num);                    // capacity 一次性增大到十万，减少vector多次增大时候的拷贝次数

cout << "push_back way one:     ";
auto start = system_clock::now();
for (int i = 0; i < num; ++i)
{
string temp("caitao");
v.push_back(temp);             // push_back(const string&)，参数是左值引用
}
auto end = system_clock::now();
auto duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

cout << "push_back way two:     ";
v.clear();
start = system_clock::now();
for (int i = 0; i < num; ++i)
{
string temp("caitao");
v.push_back(move(temp));       // push_back(string &&), 参数是右值引用。
// move可以理解为类型转换：左值引用 → 右值引用。右值引用就是临时对象。
}
end = system_clock::now();
duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

cout << "push_back way three:   ";
v.clear();
start = system_clock::now();
for (int i = 0; i < num; ++i)
{
v.push_back(string("caitao")); // push_back(string &&), 参数是右值引用
}
end = system_clock::now();
duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

cout << "push_back way four:    ";
v.clear();
start = system_clock::now();
for (int i = 0; i < num; ++i)
{
v.push_back("caitao");         // push_back(string &&)，参数是右值引用，和 way three 几乎一样（只有vector元素是string才可以这么写，为了C++和C的字符串兼容）
}
end = system_clock::now();
duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

cout << "emplace_back(fastest): ";
v.clear();
start = system_clock::now();
for (int i = 0; i < num; ++i)
{
v.emplace_back("caitao");      // 只有一次构造函数，不调用拷贝构造函数，速度最快
}
end = system_clock::now();
duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

system("pause");
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
72
73
74
75
76
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
72
73
74
75
76

分析

第一种方法，速度最慢。push_back的参数是左值引用。首先定义一个temp对象的时候，调用一次构造函数，然后push_back的时候调用一次拷贝构造函数。两次构造很花时间，因为内存里面需要重新分配空间。

第二~四种方法，速度中等。push_back的参数是右值引用。首先定义一个temp对象的时候，调用一次构造函数，然后push_back的时候调用一次移动构造函数。移动构造函数花的时间比拷贝构造函数花的时间少，因为不需要内存重新分配空间。（不知道为什么第二种方法会比方法三和四花费的时间多一点点。。。）

第五种方法，即emplace_back速度最快，因为emplace_back只调用一次构造函数，没有移动构造函数，也没有拷贝构造函数。cplusplus.com说：Arguments forwarded to construct the new element. 意思是：emplace_back的参数就是构造函数的参数。

证明上述的分析

写一个类，重载构造函数，重载拷贝构造函数，重载移动构造函数。代码如下：

#include <vector>
#include <string>
#include <iostream>
using namespace std;

struct Complicated
{
int year;
double country;
string name;

Complicated(int a, double b, string c) :year(a), country(b), name(c)
{
cout << "is constucted" << endl;
}

Complicated(const Complicated & other) : year(other.year), country(other.country), name(other.name)
{
cout << "is copied" << endl;
}

Complicated(Complicated && other) : year(move(other.year)), country(move(other.country)), name(move(other.name))
{
cout << "is moved" << endl;
}
};

int main()
{
int anInt = 4;
double aDouble = 5.0;
string aString = "C++";

vector<Complicated> v;
v.reserve(10);

cout << "--emplace_back--" << endl;
v.emplace_back(anInt, aDouble, aString);            // construct

cout << endl << "--push_back--" << endl;
Complicated temp(anInt, aDouble, aString);          // construct
cout << endl;

v.push_back(temp);                                  // copy
cout << endl;

v.push_back(move(temp));                            // move
cout << endl;

v.push_back(Complicated(anInt, aDouble, aString));  // construct + move
cout << endl;

system("pause");
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
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

输出结果如下： 

一种“更加公平”的比较方式

emplace_back可以“构造和插入同时进行”，堪称“开挂”。如果对象构造好了，只是单纯的比较插入（抛开外挂），谁快一些呢？

这次是“单纯”比较的push_back和emplace_back的插入功能：

#include <iostream>
#include <utility>
#include <chrono>
#include <vector>
#include <string>
using namespace std;
using namespace chrono;

int main()
{
vector<string> v;
int num = 100000;
v.reserve(num);                    // capacity 一次性增大到十万，减少vector多次增大时候的拷贝次数

string caitao("caitao");
vector<string> storage(num, caitao);

cout << "push_back(copy):  ";
auto start = system_clock::now();
for (int i = 0; i < num; ++i)
{
v.push_back(storage[i]);
}
auto end = system_clock::now();
auto duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

cout << "push_back:(move): ";
v.clear();
start = system_clock::now();
for (int i = 0; i < num; ++i)
{
v.push_back(move(storage[i]));
}
end = system_clock::now();
duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

cout << "emplace_back:     ";
v.clear();
start = system_clock::now();
for (int i = 0; i < num; ++i)
{
v.emplace_back(storage[i]);
}
end = system_clock::now();
duration = duration_cast<microseconds>(end - start);
cout << duration.count() << " microseconds." << endl << endl;

system("pause");
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
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



emplace_back最快，push_back(move())次之，push_back最慢。所以呀，大家忘了push_back吧