As far as I can tell, the issue isn’t caused by map::emplace, but by pair‘s constructors: #include <map> struct A { A(int) {} A(A&&) = delete; A(A const&) = delete; }; int main() { std::pair<int, A> x(1, 4); // error } This code example doesn’t compile, neither with coliru’s g++4.8.1 nor with clang++3.5, which are … Read more
push() adds a copy of an already constructed object into the queue as a parameter, it takes an object of the queue’s element type. emplace() constructs a new object in-place at the end of the queue. It takes as parameters the parameters that the queue’s element types constructor takes. If your usage pattern is one … Read more
Your test case isn’t very helpful. push_back takes a container element and copies/moves it into the container. emplace_back takes arbitrary arguments and constructs from those a new container element. But if you pass a single argument that’s already of element type to emplace_back, you’ll just use the copy/move constructor anyway. Here’s a better comparison: Foo … Read more
unordered_map::insert copies or moves a key-value pair into the container. It is overloaded to accept reference-to-const or an rvalue reference: std::pair<iterator,bool> insert(const std::pair<const Key, T>& value); template<class P> std::pair<iterator,bool> insert(P&& value); unordered_map::emplace allows you to avoid unnecessary copies or moves by constructing the element in place. It uses perfect forwarding and a variadic template to … Read more
The arguments you pass to map::emplace get forwarded to the constructor of map::value_type, which is pair<const Key, Value>. So you can use the piecewise construction constructor of std::pair to avoid intermediate copies and moves. std::map<int, Foo> m; m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2.3, “hello”)); Live demo
Let’s see what the different calls that you provided do: 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) push_back(std::move(mystring)): This calls the move-insertion, which in the case … Read more
In the particular case of a map the old options were only two: operator[] and insert (different flavors of insert). So I will start explaining those. The operator[] is a find-or-add operator. It will try to find an element with the given key inside the map, and if it exists it will return a reference … Read more