C++ STL的vector相信大家一定都知道，它是一个一般用来当做可变长度列表的类。在C++11之前，一般给vector插入新元素用得都是push_back函数，比如下面这样：
std::vector<std::string> list;
list.push_back(std::string("6666"));
这种写法事实上有很多的冗余计算，我们来分析下，调用这句push_back一共做了哪些操作：
1.执行了std::string的构造函数，传入"6666"构造出一个std::string，这是一个临时变量，我们称它为temp；
2.执行了std::string的拷贝构造函数，将temp的内容拷贝到list的空间中；
3.执行了std::string的析构函数，析构临时变量temp。
从中可以看到，我们需要执行std::string的两个构造函数和一个析构函数，还是比较耗费时间的。仔细分析下可以发现，构造函数还是必须要有一个的（因为必须要为list创建一个std::string对象），但我们完全可以省略掉创建和销毁临时对象temp的操作，只要我们能保证将"6666"直接传入为list构造的std::string对象中。
为了实现这个目标，C++11引入了emplace_back函数，它通过完美转发实现了在vector中插入时直接在容器内构造对象，省略了创建临时对象的操作。我们看下它的代码就不难理解：
template<class _Ty,
class _Alloc = allocator<_Ty>>
class vector
: public _Vector_alloc<_Vec_base_types<_Ty, _Alloc>>
{
...
public:
template<class... _Valty>
decltype(auto) emplace_back(_Valty&&... _Val)
{ // insert by perfectly forwarding into element at end, provide strong guarantee
if (_Has_unused_capacity())
{
return (_Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...));
}
_Ty& _Result = *_Emplace_reallocate(this->_Mylast(), _STD forward<_Valty>(_Val)...);
return (_Result);
}
...
};
对于上面案例中的list(vectorstd::string)来说，_Ty是std::string，调用list.emplace_back("6666")，则_Valty就是const char*，通过完美转发机制（forward<_Valty>）最终将传入的参数_Val（本例中就是"6666"）传入std::string的构造函数中，实现了直接从list中一步到位构造对象，省略了创建临时对象的过程，从而减少了创建的时间。
下面是我做的实验，首先定义一个类A，它可以接受一个const char*来构造：
class A
{
public:
A(const char* c)
{
int count = strlen(c);
content = new char[count];
memcpy(content, c, count);
}
~A()
{
if (content)
{
delete[] content;
}
}
A(const A& a)
{
int count = strlen(a.content);
content = new char[count];
memcpy(content, a.content, count);
}
A(A && a)
{
content = a.content;
a.content = nullptr;
}
private:
char * content = nullptr;;
};
通过以下代码来测试运行时间：
int main()
{
std::vector<A> str_list;
std::vector<A> str_list2;
std::vector<A> str_list3;
std::vector<A> str_list4;
int count = 100000;
//提前留好空间，防止创建内存干扰
str_list.reserve(count * 2);
str_list2.reserve(count * 2);
str_list3.reserve(count * 2);
str_list4.reserve(count * 2);
clock_t start = clock();
for (int i = 0; i < count; i++)
{
A a = "hahahaah";
str_list.push_back(a);
}
clock_t end = clock();
std::cout << end - start << std::endl;
start = clock();
for (int i = 0; i < count; i++)
{
str_list2.push_back("hahahaah");
}
end = clock();
std::cout << end - start << std::endl;
start = clock();
for (int i = 0; i < count; i++)
{
str_list3.emplace_back("hahahaah");
}
end = clock();
std::cout << end - start << std::endl;
start = clock();
for (int i = 0; i < count; i++)
{
A a = "hahahaah";
str_list4.emplace_back(a);
}
end = clock();
std::cout << end - start << std::endl;
system("pause");
return 0;
}
以上四种情况输出的运行时间如下（VS2017、Debug、Win32模式下编译）：
125
84
78
106
可以看到，最耗时的就是第一种：
for (int i = 0; i < count; i++)
{
A a = "hahahaah";
str_list.push_back(a);
}
因为它就是本文前面说的“创建临时对象->创建list中的对象->销毁临时对象”过程。
str_list2的做法相对好一些，因为虽然也会生成临时对象，但因为传入的是右值引用，因此调用的是移动构造函数，相对来说节省一些。
str_list3就是本文上面提到的做法，直接在vector上构造对象，自然是时间最短的。
str_list4还是构造了对象，因此虽然调用的是emplace_back，但传入的是左值引用A&，所以仍然比较耗时间。不过这也说明，emplace_back也可以像push_back一样传入要插入的对象（而不是构造对象的参数），这样的话走的还是类似push_back的流程，通过调用复制构造函数创建新对象。这种用法从试验结果上看，起码不会比push_back性能更差。
