C++ vectors: emplace_back vs. push_back

Question

Why is the method emplace_back() necessary at all?

Why can compiler constructors not simply use the faster "create at end" way, when implementing push_back()? What part of the C++ standard prohibits that? What would be the problem in adjusting this part of the standard instead of introducing still another method? As far as I can see, the anonymous object constructed, copied, then deleted has no further life or purpose afterwards.

What is the merit of having two completely equivalent methods, one faster, the other more commonly known and used? Or IS there a difference?

Answer 1

Compare them, using the reference:

https://en.cppreference.com/w/cpp/container/vector/emplace_back

https://en.cppreference.com/w/cpp/container/vector/push_back

push_back takes a reference or rvalue reference.

emplace_back takes a parameter pack. emplace_back is used to construct a type "in place", whereas push_back can only move or copy an object, not construct it in place.

(Note that push_back can implicitly call a constructor function, but this causes two function calls. A constructor function call followed by a move or copy. That is not the same for emplace_back which calls a constructor only.)

For example, consider a non-trivial type:

struct ContainsAFewThings
{
    ContainsAFewThings(a, b)
        : a(a)
        , b(b)
    {
    }

    int a;
    int b;
}

We can construct it directly using emplace_back.

std::vector<ContainsAFewThings> vect;
vect.emplace_back(1, 2);

This performs one call to the constructor function, and no calls to a move or copy constructor. The alternative with push_back calls the constructor function, then copy or move:

std::vector<ContainsAFewThings> vect;
vect.push_back(ContainsAFewThings(1, 2)); // push_back with explicit constructor

// does the same thing as this:
vect.push_back(1, 2); // hidden impicit constructor call here!

To understand more, learn about perfect forwarding and "The Forwarding Problem" in C++. There is a discussion about it here.

Answer 2

The creation, copying and destruction of the temporary object may have side effects, so the compiler is not allowed to generally skip them even if it is aware that the call to push_back does not cause any other use of the temporary object. This way push_back with a temporary as argument may behave differently than the equivalent emplace_back directly from the constructor arguments. If the compiler realizes that there are no side effects, it can of course optimize a push_back call to the same machine code it would emit for an equivalent emplace_back call.

Also, push_back allows for list initialization of the temporary object in its argument, while emplace_back always uses (non-list) direct initialization. So some uses of push_back with a temporary are not valid for emplace_back.

Furthermore, push_back has been there since the beginning of standardized C++ and earlier, but variadic templates exists only since C++11. So it wouldn't have been possible to specify emplace_back before C++11. It would have needed to be limited to some arbitrary finite number of arguments. Also without C++11 forwarding references it doesn't work out so nicely either.

If you don't need to support anything before C++11 then you can almost always use emplace_back and ignore push_back.