std::map emplace without copying value

Question

The C++11 std::map<K,V> type has an emplace function, as do many other containers.

std::map<int,std::string> m; std::string val {"hello"}; m.emplace(1, val);

This code works as advertised, emplacing the std::pair<K,V> directly, however it results in a copy of key and val taking place.

Is it possible to emplace the value type directly into the map as well? Can we do better than moving the arguments in the call to emplace?

Here's a more thorough example:

struct Foo { Foo(double d, string s) {} Foo(const Foo&) = delete; Foo(Foo&&) = delete; } map<int,Foo> m; m.emplace(1, 2.3, string("hello")); // invalid

@Cheersandhth.-Alf, I've read a bunch of documents and come to the conclusion that it's not possible. However I am not the most experienced C++ developer so wanted to run it past some of the gurus here, in the hope that I am wrong. Can you help? — Drew Noakes
– Drew Noakes, Commented Jan 15, 2015 at 9:41
Do you mean an extra copy? val is an lvalue, so a copy will have to be made at some point. — juanchopanza
– juanchopanza, Commented Jan 15, 2015 at 9:42
@juanchopanza, imagine the value was some more complex type and that it was neither copyable nor moveable (and so of course cannot be introduced as an lvalue, nor moved/cast to an rvalue reference). I want to provide the value's constructor arguments directly to some kind of emplace function so that it is instantiated using perfect forwarding and (presumably) placement new within the map. — Drew Noakes
– Drew Noakes, Commented Jan 15, 2015 at 9:45
I found it again on youtube: youtube.com/watch?v=smqT9Io_bKo#t=46m00s — JorenHeit
– JorenHeit, Commented Jan 15, 2015 at 12:39

Praetorian · Accepted Answer · 2015-01-15 09:46:41Z

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

Just adding that in order to compile this you should add #include <tuple>

James Holderness · Accepted Answer · 2016-10-05 18:57:45Z

39

In C++17 this can more easily be achieved with the try_emplace method.

map<int,Foo> m; m.try_emplace(1, 2.3, "hello");

This addition to the standard library was covered in paper N4279 and should already be supported in Visual Studio 2015, GCC 6.1 and LLVM 3.7 (the libc++ library).

answered Oct 5, 2016 at 18:57

James Holderness

23.1k2 gold badges43 silver badges52 bronze badges

2 Comments

Kai Petzke Over a year ago

Yes, try_emplace() is really the best solution. In particular, emplace() always constructs a Key-Value pair on the heap. So, if the Key is actually found in the table, emplace() will delete that just newly constructed Key-Value pair again. try_emplace on the contrary does everything in the expected order: Check, if they Key exists, and if yes, return an iterator to that Key-Value pair. If not, then it emplaces the new Key and Value into the container.

Deduplicator Over a year ago

Well, simple .emplace() is the only option if the key has to be constructed in-place, and has no drawback if you know it is not yet present in the map.

Collectives™ on Stack Overflow

std::map emplace without copying value

2 Answers 2

2 Comments

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Linked

Related