std::stack::emplace vs std::stack::push

Both std::stack::emplace and std::stack::push are used to add elements to a stack, but they do it in slightly different ways.

std::stack::push

This function takes an object of the stack's element type and pushes it onto the stack. If the object is an rvalue, it will be moved onto the stack. If it's an lvalue, it will be copied.

1std::stack<std::string> s;
2std::string str = "Hello";
3
4// str is copied onto the stack
5s.push(str);
6
7// temporary string is moved onto the stack
8s.push(std::string("World"));

std::stack::emplace

This function constructs a new object directly on the stack, using the arguments passed to emplace as the arguments for the object's constructor. This avoids creating a temporary object and then copying or moving it onto the stack.

1std::stack<std::string> s;
2
3// string is constructed directly on the stack
4s.emplace("Hello");

When to use emplace over push (or vice versa) depends on your specific use case:

• If you have an existing object that you want to push onto the stack, you must use push.
• If you don't have an existing object and you would need to create a temporary object to push onto the stack, emplace can be more efficient, as it constructs the object directly on the stack, avoiding the creation of a temporary.

Here's an example that demonstrates the difference:

1#include <iostream>
2#include <stack>
3#include <string>
4
5int main() {
6  std::stack<std::string> s;
7
8  std::cout << "Pushing..." << std::endl;
9  // temporary string created and moved
10  s.push(std::string("Hello, "));
11
12  std::string world = "world!";
13  // world copied onto the stack
14  s.push(world);
15
16  std::cout << "Emplacing..." << std::endl;
17  // string constructed directly on the stack
18  s.emplace("Hello, ");
19
20  // string(5, 'A') constructed on the stack
21  s.emplace(5, 'A');
22}

1Pushing...
2Emplacing...

In this code, the first push operation creates a temporary std::string object and then moves it onto the stack. The second push copies the world string onto the stack.

The first emplace operation constructs a string directly on the stack from a const char*. The second emplace operation constructs a string directly on the stack using the constructor std::string(size_t n, char c).

In general, emplace can provide better performance by avoiding temporary objects, but the difference is often negligible unless you're working with very large numbers of objects or very expensive-to-construct objects. The readability and clarity of your code should also be considered when choosing between push and emplace.