97

In C++11 emplace_back() is generally preferred (in terms of efficiency) to push_back() as it allows in-place construction, but is this still the case when using push_back(std::move()) with an already-constructed object?

For instance, is emplace_back() still preferred in cases like the following?

std::string mystring("hello world");
std::vector<std::string> myvector;

myvector.emplace_back(mystring);
myvector.push_back(std::move(mystring));
// (of course assuming we don't care about using the value of mystring after)

Additionally, is there any benefit in the above example to instead doing:

myvector.emplace_back(std::move(mystring));

or is the move here entirely redundant, or has no effect?

Nicol Bolas
  • 378,677
  • 53
  • 635
  • 829
Riot
  • 13,698
  • 3
  • 55
  • 59
  • `myvector.emplace_back(mystring);` copies and doesn't move. The other two moves and should be equivalent. – T.C. Nov 11 '14 at 09:20
  • See also this question and results: [Requested Survey for VC++ regarding insert and emplace](http://stackoverflow.com/q/24925004/636019) – ildjarn Nov 11 '14 at 11:59

2 Answers2

123

Let's see what the different calls that you provided do:

  1. emplace_back(mystring): This is an in-place construction of the new element with whatever argument you provided. Since you provided an lvalue, that in-place construction in fact is a copy-construction, i.e. this is the same as calling push_back(mystring)

  2. push_back(std::move(mystring)): This calls the move-insertion, which in the case of std::string is an in-place move-construction.

  3. emplace_back(std::move(mystring)): This is again an in-place construction with the arguments you provided. Since that argument is an rvalue, it calls the move-constructor of std::string, i.e. it is an in-place move-construction like in 2.

In other words, if called with one argument of type T, be it an rvalue or lvalue, emplace_back and push_back are equivalent.

However, for any other argument(s), emplace_back wins the race, for example with a char const* in a vector<string>:

  1. emplace_back("foo") calls std::string(char const*) for in-place-construction.

  2. push_back("foo") first has to call std::string(char const*) for the implicit conversion needed to match the function's signature, and then a move-insertion like case 2. above. Therefore it is equivalent to push_back(string("foo"))

Paiusco
  • 188
  • 12
Arne Mertz
  • 22,733
  • 2
  • 43
  • 86
  • 1
    Move constructor is generally more efficient than copy constructors, therefore using rvalue (case 2, 3) is more efficient than using an lvalue (case 1) despite the same semantics. – Ryan Li Jun 30 '17 at 16:33
  • what about such situation? void foo(string&& s) { vector.emplace(s); // 1 vector.emplace(std::move(s)); // 2 } – VALOD9 Jun 12 '18 at 16:15
  • @VALOD those are numbers 1 and 3 of my list again. `s` may be defined as rvalue reference that binds only to rvalues, but inside of `foo`, `s` is an lvalue. – Arne Mertz Jun 12 '18 at 16:27
1

The emplace_back gets a list of rvalue references and tries to construct a container element direct in place. You can call emplace_back with all types which the container element constructors supports. When call emplace_back for parameters which are not rvalue references, it 'falls back' to normal references and at least the copy constructor ist called when the parameter and the container elements are of the same type. In your case 'myvector.emplace_back(mystring)' should make a copy of the string becaus the compiler could not know that the parameter myvector is movable. So insert the std::move what gives you the desired benefit. The push_back should work as well as emplace_back for already constructed elements.

Tunichtgut
  • 291
  • 1
  • 6