速度测试
1. emplace_back 使用方法
#include <iostream>
#include <memory>
#include <string>
#include <ctime>
// 计时器类
class TimeInterval
{
public:
TimeInterval(const std::string& d)
: detail(d)
{
init();
}
TimeInterval()
{
init();
}
~TimeInterval()
{
end = clock();
std::cout << detail << (double)(end - start) << " ms" << std::endl;
}
protected:
void init()
{
start = clock();
}
private:
std::string detail;
clock_t start;
clock_t end;
};
#define TIME_INTERVAL_SCOPE(d) std::shared_ptr<TimeInterval> time_interval_scope_begin = std::make_shared<TimeInterval>(d)
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;
};
// 测试例程
void emplaceRate1();
void emplaceRate2();
void emplaceRate1()
{
std::vector<std::string> coll;
int count = 1e7;
coll.reserve(count);
{
TIME_INTERVAL_SCOPE("push_back string:");
for (int i = 0; i < count; ++i)
{
// push_back(const string&)，参数是左值引用
std::string temp("TEST");
coll.push_back(temp);
}
}
coll.clear();
{
TIME_INTERVAL_SCOPE("push_back move(string):");
for (int i = 0; i < count; ++i)
{
// push_back(string &&), 参数是右值引用
std::string temp("TEST");
coll.push_back(std::move(temp));
}
}
coll.clear();
{
TIME_INTERVAL_SCOPE("push_back(string):");
for (int i = 0; i < count; ++i)
{
// push_back(string &&), 参数是右值引用
coll.push_back(std::string("TEST"));
}
}
coll.clear();
{
TIME_INTERVAL_SCOPE("push_back(c string):");
for (int i = 0; i < count; ++i)
{
// push_back(string &&), 参数是右值引用
coll.push_back("TEST");
}
}
coll.clear();
{
TIME_INTERVAL_SCOPE("emplace_back(c string):");
for (int i = 0; i < count; ++i)
{
// 只有一次构造函数，不调用拷贝构造函数，速度最快
coll.emplace_back("TEST");
}
}
}
void emplaceRate2()
{
std::vector<Foo> coll;
int count = 1e7;
coll.reserve(count);
{
TIME_INTERVAL_SCOPE("push_back T:");
// push_back(const T&)，参数是左值引用
// 打印结果：
// constructor
// copy constructor
Foo temp("TEST");
coll.push_back(temp);
}
coll.clear();
{
TIME_INTERVAL_SCOPE("push_back move(T):");
// push_back(T &&), 参数是右值引用
// 打印结果：
// constructor
// move constructor
Foo temp("TEST");
coll.push_back(std::move(temp));
}
coll.clear();
{
TIME_INTERVAL_SCOPE("push_back(T&&):");
// push_back(T &&), 参数是右值引用
// 打印结果：
// constructor
// move constructor
coll.push_back(Foo("TEST"));
}
coll.clear();
{
TIME_INTERVAL_SCOPE("push_back(string):");
// push_back(T &&), 参数是右值引用
// 打印结果：
// constructor
// move constructor
std::string temp("TEST");
coll.push_back(temp);
}
coll.clear();
{
TIME_INTERVAL_SCOPE("emplace_back(string):");
// 只有一次构造函数，不调用拷贝构造函数，速度最快
// 打印结果：
// constructor
std::string temp("TEST");
coll.emplace_back(temp);
}
}
测试结果
push_back string:327 ms
push_back move(string):213 ms
push_back(string):229 ms
push_back(c string):215 ms
emplace_back(c string):122 ms
方法1耗时最长，原因是将调用左值引用的push_back，且将会调用一次string的拷贝构造函数。
方法2、3、4耗时基本一样，参数为右值，将调用右值引用的push_back，故调用string的移动构造函数，移动构造函数耗时比拷贝构造函数少，因为不需要重新分配内存空间。
方法5耗时最少，因为emplace_back只调用构造函数，没有移动构造函数，也没有拷贝构造函数。
2. 优缺点
The real primary difference has to do with implicit vs. explicit constructors. Consider the case where we have a single argument that we want to pass to push_back or emplace_back.
std::vector<T> v;
v.push_back(x);
v.emplace_back(x);
After your optimizing compiler gets its hands on this, there is no difference between these two statements in terms of generated code. The traditional wisdom is that push_back will construct a temporary object, which will then get moved into v whereas emplace_back will forward the argument along and construct it directly in place with no copies or moves. This may be true based on the code as written in standard libraries, but it makes the mistaken assumption that the optimizing compiler's job is to generate the code you wrote. The optimizing compiler's job is actually to generate the code you would have written if you were an expert on platform-specific optimizations and did not care about maintainability, just performance.
The actual difference between these two statements is that the more powerful emplace_back will call any type of constructor out there, whereas the more cautious push_back will call only constructors that are implicit. Implicit constructors are supposed to be safe. If you can implicitly construct a Ufrom a T, you are saying that U can hold all of the information in T with no loss. It is safe in pretty much any situation to pass a T and no one will mind if you make it a U instead. A good example of an implicit constructor is the conversion from std::uint32_t to std::uint64_t. A bad example of an implicit conversion is double to std::uint8_t.
We want to be cautious in our programming. We do not want to use powerful features because the more powerful the feature, the easier it is to accidentally do something incorrect or unexpected. If you intend to call explicit constructors, then you need the power of emplace_back. If you want to call only implicit constructors, stick with the safety of push_back.
An example
std::vector<std::unique_ptr<T>> v;
T a;
v.emplace_back(std::addressof(a)); // compiles
v.push_back(std::addressof(a)); // fails to compile
std::unique_ptr<T> has an explicit constructor from T *. Because emplace_back can call explicit constructors, passing a non-owning pointer compiles just fine. However, when v goes out of scope, the destructor will attempt to call delete on that pointer, which was not allocated by new because it is just a stack object. This leads to undefined behavior.
This is not just invented code. This was a real production bug I encountered. The code was std::vector<T *>, but it owned the contents. As part of the migration to C++11, I correctly changed T * to std::unique_ptr<T> to indicate that the vector owned its memory. However, I was basing these changes off my understanding in 2012, during which I thought "emplace_back does everything push_back can do and more, so why would I ever use push_back?", so I also changed the push_back to emplace_back.
Had I instead left the code as using the safer push_back, I would have instantly caught this long-standing bug and it would have been viewed as a success of upgrading to C++11. Instead, I masked the bug and didn't find it until months later.
3. 参考
https://www.cnblogs.com/lidabo/p/7792838.html https://en.cppreference.com/w/cpp/container/vector/emplace_back https://en.cppreference.com/w/cpp/container/vector/push_back https://stackoverflow.com/questions/10890653/why-would-i-ever-use-push-back-instead-of-emplace-back https://stackoverflow.com/questions/4303513/push-back-vs-emplace-back
