My take away isn’t about how to initialize a std::map, but to never access one via [] without .find()’ing first, especially if you’re in static scope. Freaky.

There are situations where “[]=” might be faster than the insert. In the “[]=”-version mapped_type::operator= is used that might accept its parameter by value and use copy-and-swap. Together with a compiler employing RVO which eliminates this copy in case where the right hand side of the assignment was an rvalue you end up with an assignment that doesn’t copy the object at all. It is constructed into a temporary and swapped with the default-constructed value of the map.

This should apply to many (well-designed) resource handle classes where copying is expensive and swapping is cheap.

map<int, int> myMap;
myMap[10] = 20;
myMap[10] = 40;

will leave a value 40 corresponding to the key 10. However, with insert() function, we have the option to see if the key already exists or not. It returns a pair. The iterator points to the element with the key specified and the bool shows if the operation was successful or not (If the element already existed, the insertion won’t take place and the return value will be false).

For example,

typedef map<int, int>::iterator MyMapIterator;
typedef pair<int, int> MyPair;
// Add a pair (10, 20) to the map
myMap[10] = 20;
// Try to add the pair (10, 30) using insert
 pair P = myMap.insert(MyPair(10, 30));

Now the value of P.second wil be false as the insertion failed and P.first will point to the element (10, 20).

If we had simply used the operator [] for insertion, we would have ended up with an element (10, 30).

However, when there is the need of overwriting the existing elements or when you are absolutely sure that you are not going to overwrite any of the values, you can use the operator []. It is easy to use and more readable.

I forgot that wordpress likes to swallow angle brackets.

-P

typedef std::map map_t;
phonebook.insert(map_t::value_type(“Alf”,”555 8531″));

Also, the [] approach might be faster in some cases because it might not involve much copying. Any decently designed “value class” uses the “copy & swap”-idiom for assignment which is known to avoid unneccesary copying when the compiler performs return-value-optimization, see here.

-P

Please keep watching the blog.

map<string,string> phonebook;
phonebook["Alf"] = “555 8531″;