best way to insert std::map

Question

having:

std::map<const std::string,A > cache;

how would you insert into this container(duplicate attempt is possible):

cache.insert(std::make_pair(id,ps));

cache.insert(std::pair<std::string,A>(id,ps));

if(cache.find(id) == cache.end()){
 cache[id] = ps;
}

and why??(in terms of time and memory)

do you have a better solution?

Update: I am not using C++11

Update-2: OK, so far we realised that:

make_pair and pair<> are analogous.

insert and [ ](with or without ifchecking) will both invoke copy. So.. Is the competition between :

1. insert
2. [ ](withifchecking)
3. [ ](withifchecking and swap)

which one would you prefer?

thanks again

Answer 1

I'd suggest emplace:

template< class... Args >
std::pair<iterator,bool> emplace( Args&&... args );

// usage:
cache.emplace(id, ps);

But, it depends a bit on whether you want a second insertion to

• fail (as the above would, returning a std::pair<iterator,bool> in which .second indicates successful insertion or failure - you can ignore that if you don't care, as the only reason for failure is an existing key) or

• overwrite the existing value (for which it's easiest and usually perfectly adequate to write cache[id] = ps;, but if you want to avoid default construction of an element pair then you can use find and then overwrite an existing or emplace a new element as necessary).

Occasionally you might want to consider marking one or both of the parameters as movable-from (i.e. you don't care what (valid) state the local variable is left in after the emplace returns, which may allow extra optimisations). You can see from the prototype above that the arguments are accepted using && which hints at capability to perform such optimnisations.

cache.emplace(std::move(id), std::move(ps));

Answer 2

The third one is clearly inferior in terms of time, since it requiers two lookups in the map when actually doing the insertion (one for find() and one for []). So stick to the insert() function.

Now the question is: std::make_pair() or std::pair<A, B>()? It's generally a good idea to follow the principle of DRY, which means you shouldn't repeat the types, so use std::make_pair().

If you have C++11, the best option is to use emplace():

cache.emplace(id, ps);

---

As a side note, it's pointless to type the map as std::map<const std::string, A>. Keys in a map are already immutable; it's more concise (and doesn't produce a WTF moment) to just use std::map<std::string, A>, and you'll be really hard pressed to find a case where those two differ.

Answer 3

cache.insert(std::make_pair(id,ps));

This will copy id and ps. If they have "heavy" copy constructors this will waste some time and memory.

cache.insert(std::pair<std::string,A>(id,ps));

Its indeed analog for make_pair

if(cache.find(id) == cache.end()){
 cache[id] = ps;
}

Its better to use without check: cache[id] = ps;. But, at first element insertion the "default" object of type decltype(ps) will be constructed. Then, its assigned (using operator=) to ps. If its heavy, this can be problem too. But, i think its preferred way if swap method is not available.

cache.emplace(id, ps);

This can look like zero-copy emplace, but its not. emplace receives constructor parameters, so default copy constructor will be called. Also its C++11.

I think most efficient way is

cache[id].swap(ps);

This should make minimum amount of copies, but drawback is your ps will be reset (or contain old value).