c++ - Calling std::map::emplace() and avoiding unnecessary constructions

Question

I have a std::map whose keys are std::string and values are my own defined type.

Let's suppose I have the following code:

std::map<std::string, MyType> mymap;
std::string str1("test");
MyType value(pars); //I want value to be moved

mymap.emplace(std::make_pair(str1, std::move(value))); //A
mymap.emplace(str, std::move(value)); //B

Assuming std::map stores pairs, I guess A would generate a further call to std::pair constructor (make_pair), followed by another call to std::pair move constructor (in-place construction with rvalue argument).

And I think B would just generate a call to std::pair constructor.

So can we say B is preferred over A in order to avoid unnecessary constructions?

Answer 1

According to http://www.cplusplus.com/reference/map/map/emplace/:

Inserts a new element in the map if its key is unique. This new element is constructed in place using args as the arguments for the construction of a value_type (which is an object of a pair type) ... The element is constructed in-place by calling allocator_traits::construct with args forwarded.

So in option A, you first construct a pair which emplace will forward to the constructor (as an rvalue) for pair which will then do a move construction.

Option B forwards str and the return of std::move(value) to the constructor for pair.

So yes, option A constructs 2 pairs while option B only constructs 1.