最近在写一段代码的时候，突然很好奇C++11中对push_back有没有什么改进以增加效率，上网搜了一些资料，发现果然新增了emplace_back方法，比push_back的效率要高很多。
首先，写了一个类用于计时，
//time_interval.h
#pragma once #include <iostream>
#include <memory>
#include <string>
#ifdef GCC
#include <sys/time.h>
#else
#include <ctime>
#endif // GCC class TimeInterval
{
public:
TimeInterval(const std::string& d) : detail(d)
{
init();
} TimeInterval()
{
init();
} ~TimeInterval()
{
#ifdef GCC
gettimeofday(&end, NULL);
std::cout << detail
<< * (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec) /
<< " ms" << endl;
#else
end = clock();
std::cout << detail
<< (double)(end - start) << " ms" << std::endl;
#endif // GCC
} protected:
void init() {
#ifdef GCC
gettimeofday(&start, NULL);
#else
start = clock();
#endif // GCC
}
private:
std::string detail;
#ifdef GCC
timeval start, end;
#else
clock_t start, end;
#endif // GCC
}; #define TIME_INTERVAL_SCOPE(d) std::shared_ptr<TimeInterval> time_interval_scope_begin = std::make_shared<TimeInterval>(d)
使用方法就是在作用域中使用宏TIME_INTERVAL_SCOPE(d)，d为打印用的字符串，输出作用域的耗时情况。
其次，看一下现在push到vector的5种方法的耗时情况对比：
#include <vector>
#include <string>
#include "time_interval.h" int main() { std::vector<std::string> v;
int count = ;
v.reserve(count); //预分配十万大小，排除掉分配内存的时间 {
TIME_INTERVAL_SCOPE("push_back string:");
for (int i = ; i < count; i++)
{
std::string temp("ceshi");
v.push_back(temp);// push_back(const string&)，参数是左值引用
}
} v.clear();
{
TIME_INTERVAL_SCOPE("push_back move(string):");
for (int i = ; i < count; i++)
{
std::string temp("ceshi");
v.push_back(std::move(temp));// push_back(string &&), 参数是右值引用
}
} v.clear();
{
TIME_INTERVAL_SCOPE("push_back(string):");
for (int i = ; i < count; i++)
{
v.push_back(std::string("ceshi"));// push_back(string &&), 参数是右值引用
}
} v.clear();
{
TIME_INTERVAL_SCOPE("push_back(c string):");
for (int i = ; i < count; i++)
{
v.push_back("ceshi");// push_back(string &&), 参数是右值引用
}
} v.clear();
{
TIME_INTERVAL_SCOPE("emplace_back(c string):");
for (int i = ; i < count; i++)
{
v.emplace_back("ceshi");// 只有一次构造函数，不调用拷贝构造函数，速度最快
}
}
}
vs2015 release下编译，运行结果：
第1中方法耗时最长，原因显而易见，将调用左值引用的push_back，且将会调用一次string的拷贝构造函数，比较耗时，这里的string还算很短的，如果很长的话，差异会更大
第2、3、4中方法耗时基本一样，参数为右值，将调用右值引用的push_back，故调用string的移动构造函数，移动构造函数耗时比拷贝构造函数少，因为不需要重新分配内存空间。
第5中方法耗时最少，因为emplace_back只调用构造函数，没有移动构造函数，也没有拷贝构造函数。
为了证实上述论断，我们自定义一个类，并在普通构造函数、拷贝构造函数、移动构造函数中打印相应描述：
#include <vector>
#include <string>
#include "time_interval.h" class Foo {
public:
Foo(std::string str) : name(str) {
std::cout << "constructor" << std::endl;
}
Foo(const Foo& f) : name(f.name) {
std::cout << "copy constructor" << std::endl;
}
Foo(Foo&& f) : name(std::move(f.name)){
std::cout << "move constructor" << std::endl;
} private:
std::string name;
};
int main() { std::vector<Foo> v;
int count = ;
v.reserve(count); //预分配十万大小，排除掉分配内存的时间 {
TIME_INTERVAL_SCOPE("push_back T:");
Foo temp("ceshi");
v.push_back(temp);// push_back(const T&)，参数是左值引用
//打印结果：
//constructor
//copy constructor
} v.clear();
{
TIME_INTERVAL_SCOPE("push_back move(T):");
Foo temp("ceshi");
v.push_back(std::move(temp));// push_back(T &&), 参数是右值引用
//打印结果：
//constructor
//move constructor
} v.clear();
{
TIME_INTERVAL_SCOPE("push_back(T&&):");
v.push_back(Foo("ceshi"));// push_back(T &&), 参数是右值引用
//打印结果：
//constructor
//move constructor
} v.clear();
{
std::string temp = "ceshi";
TIME_INTERVAL_SCOPE("push_back(string):");
v.push_back(temp);// push_back(T &&), 参数是右值引用
//打印结果：
//constructor
//move constructor
} v.clear();
{
std::string temp = "ceshi";
TIME_INTERVAL_SCOPE("emplace_back(string):");
v.emplace_back(temp);// 只有一次构造函数，不调用拷贝构造函数，速度最快
//打印结果：
//constructor
}
}
2020 4/4 更新，以前对于emplace_back有误解，发现只有在传入临时变量时才会由于push_back
class A
{
public:
A(int i)
{
m_i=i;
printf("construct A %d\n",i);
} A(const A& aa)
{
m_i=aa.m_i;
printf("copy construct A %d\n",m_i);
} ~A()
{
printf("destruct A %d\n",m_i);
}
int m_i;
};
void testFun(A a)
{
printf("111\n");
} int main()
{
vector<A> vec;
vec.reserve();
for(int i=;i<;i++)
{ //vec.push_back(i); //这个和下面的效果一样
vec.push_back(A(i)); //vec.emplace_back(A(i));
// vec.emplace_back(i); //只有这条在调用的时候不会再调用拷贝构造！！！
printf("capacity %d\n",vec.capacity());
}
}