4

Look at this code:

struct Dummy
{
    int bla;
    int blabla;
    char character;

    Dummy (int b, int bb, char c)
        : bla(b), blabla(bb), character(c)
    {}
};

std::stack<Dummy> s;
Dummy dummy;
s.push(dummy);   // (1)
s.emplace(dummy);   // (2)

I fail to see the difference between (1) and (2). I know emplace() is useful when you're providing arguments for the constructor of the object being added, e.g.:

s.emplace(1, 2, 'c');

but I don't know what the difference is in the case I described because both push() and emplace() should take a reference to the local dummy object and create a new object using copy ctor or something like that. Does push() create any temporary objects in the process?

NPS
  • 6,003
  • 11
  • 53
  • 90
  • Why do you think there needs to be a difference? In general terms, emplace is a replacement for push, more general and sometimes more efficient. – rici Nov 03 '14 at 15:42
  • There's no difference as they both construct copies of the arguments passed in. `emplace()` is useful when you want to perfect forward arguments as you did. – David G Nov 03 '14 at 15:46
  • Wouldn't the second call Dummy::Dummy(const Dummy&) since the parameter you are passing? I'd see a use for emplace with, like, s.emplace(); – Exceptyon Nov 03 '14 at 15:50
  • @Exceptyon `s.emplace()` would just try to default construct `Dummy`. – Barry Nov 03 '14 at 16:06

2 Answers2

6

There will be no temporaries. For the standard, push looks like:

void push(const value_type& x) { c.push_back(x); }
void push(value_type&& x) { c.push_back(std::move(x)); }

Whereas emplace looks like:

template <class... Args>
void emplace(Args&&... args) { 
    c.emplace_back(std::forward<Args>(args)...);
}

Where c is the underlying container, defaulting to deque<T>. So in the former case, when you call push, you are calling push(const Dummy&) which will create a new object via Dummy(const Dummy&). In the latter case, you are calling emplace_back(Dummy&) which directly create a new object via Dummy(Dummy&).

In your case - there is no difference between these two copy constructors. They would both call the trivial copy constructor implicitly created by the compiler. So you should see no behavior differences between your (1) and (2) calls.

There would only ever be a difference if one or the other constructors didn't exist (in which case one or the other wouldn't compile), or if they did different things.

Barry
  • 286,269
  • 29
  • 621
  • 977
0

Instead of taking a value_type emplace takes a variadic list of arguments, so that means that you can now perfectly forward the argument and construct directly an object into a container without temporary at all contrary to push which could involve temporaries.

Below is standard definition for emplace:-

Pushes new element on top of the stack. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function.

ravi
  • 10,994
  • 1
  • 18
  • 36