C ++：value_type与make_pair，对于地图插入更快？

Question

typedef map<KeyType, ValType> KVMap;
KVMap kvmap;

kvmap.insert( KVMap::value_type( key, val ) );
kvmap.insert( make_pair( key, val ) );

Which of the above options to insert to a STL map is always faster? Why?

Note: I am well aware that insert() is faster than using []= for adding (not updating) key-value pairs to a map. Please assume that my query is about adding, not updating. Hence I have restricted it to insert() .

Answer 1

Chances are that the first will be 'epsilon-faster' , because of this (from 23.3.1 in the standard) :

typedef pair<const Key, T> value_type;

[...]

pair<iterator, bool> insert(const value_type& x);

• In the first version, you directly construct the appropriate type expected by std::map<K,V>::insert

• In the second version, a conversion using std::pair template constructor is involved. Indeed, std::make_pair will most likely deduce its template arguments to KeyType and ValType , thus returning a std::pair<KeyType, ValType> .

  This does not match the parameter type of std::map<K,V>::insert , which is std::pair<const KeyType, ValType> (the difference being the const -qualified first). The std::pair conversion constructor will be used to create a std::pair<const K, V> from the std::pair<K, V> .

To be fair, I don't believe you could even measure the difference (and I'm not even sure that popular compilers will actually generate a different code for these).

Answer 2

There actually is an argument to be made for value_type over make_pair . This is because, for various arcane reasons, make_pair accepts its arguments by value. On the other hand, value_type , an alias for std::pair<const Key, value> , will have its constructor called with the arguments passed by const reference. There's a potential loss of efficiency from the pass-by-value in make_pair versus pass-by-reference, which could in theory have a noticeable impact on your program.

Another issue to be worried about with make_pair is that make_pair will usually create a pair of type std::pair<Key, Value> versus the std::pair<const Key, Value> needed inside the map . This means that there might be another unnecessary copy being made, this time of the pair to get the conversion working correctly.

In short, using make_pair might cause two completely unnecessary copies of the key and value to get made, while using the value_type constructor has none.

Answer 3

This is just a supplementation.

insert( make_pair(...) ) calls copy constructor 4 times notionally because of the reason other answerers mentioned.

insert( value_type(...) ) calls copy constructor 2 times.

operator[] calls default constructor once and copy constructor 2 times in a typical implementation. default constructor is called inside operator[] for insert( value_type( ..., mapped_type() ) ) . copy constructor is called once for copying insert() 's argument( pair ), and once to copy-construct an internal node of the map.

So, if you use insert with make_pair , it cannot be said that insert is always faster than operator[] even for adding. Probably, it depends on the situation. As you may know, in view of the above, emplace was proposed for the new standard.

Answer 4

They are fundamentally the same thing. KVMap::value_type is a typedef for std::pair<KeyType, ValType> , so that's just calling the constructor. std::make_pair is a template function that simply calls the constructor (it exists because template types can be deduced for free functions, but not for constructors). Once all the unbelievably-standard optimizations are done, there is no reason for there to be any difference.

I don't know how you're testing, but there are many, many ways to do that wrong.

As for insert() vs. assigning via operator[] , the latter has to do more work conceptually (when you add a new element this way, it first is supposed to default-construct an element, and then assign over top of it), but depending on the ValType , it could conceivably be optimized into basically the same thing again.