operator[]
will insert an entry for you with a default-constructed value, if one isn't already there. It is equivalent to, but will probably be implemented more efficiently than:
iterator iter = map.find(key);
if(iter == map.end())
{
iter = map.insert(value_type(key, int())).first;
}
return *iter;
operator[]
can be quicker than doing the work manually with find()
and insert()
, because it can save having to re-hash the key.
One way you can work around having multiple lookups in your code is to take a reference to the value:
int &stored_val = map[key];
// return the corresponding value if we find the key in the map - ie != 0
if (stored_val) return stored_val;
// if not in map
stored_val = value;
return value;
Note that if the value doesn't exist in the map, operator[]
will default-construct and insert one. So while this will avoid multiple lookups, it might actually be slower if used with a type that is slower to default-construct + assign than to copy- or move-construct.
With int
though, which cheaply default-constructs to 0, you might be able to treat 0 as a magic number meaning empty. This looks like it might be the case in your example.
If you have no such magic number, you've got two options. What you should use depends on how expensive it is for you to compute the value.
First, when hashing the key is cheap but computing the value is expensive, find()
may be the best option. This will hash twice but only compute the value when needed:
iterator iter = map.find(key);
// return the corresponding value if we find the key in the map
if(iter != map.end()) return *iter;
// if not in map
map.insert(value_type(key, value));
return value;
But if you've got the value already, you can do it very efficiently -- perhaps slighty more efficiently than using a reference + magic number as above:
pair<iterator,bool> iter = map.insert(value_type(key, value));
return *iter.first;
If the bool returned by map.insert(value_type)
is true, the item was inserted. Otherwise, it already existed and no modifications were made. The iterator returned points to the inserted or existing value in the map. For your simple example, this may be the best option.