What could an unordered_map potentially do with the hint? Well, if the iterator addresses an element with the same key as the element that emplace_hint has been asked to insert, then it can fail quickly – just a key comparison without any hashing or groping through any list of hash-colliding elements at that bucket. But … Read more
In response to questions about performance in relation to the number of missed searches, I have refactored the test to parameterise this. Example results: searches set_size miss ordered unordered flat_map 1000000 0 100% 4384 12901 681 1000000 99 99.99% 89127 42615 86091 1000000 172 99.98% 101283 53468 96008 1000000 303 99.97% 112747 53211 107343 1000000 … Read more
The template arguments for an unordered_map looks like this: template< class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator< std::pair<const Key, T> > > class unordered_map; std::hash is not specialized for tuples (scroll down to Standard specializations for library types). Therefore you need to provide your own, something … Read more
To comply with C++11 you’re unfortunately a bit limited in how you can tackle this. Your options basically boil down to: Iterate over the unordered_map and build a list of keys to delete like so: //std::unordered_map<…> mymap; std::vector<decltype(mymap)::key_type> vec; for (auto&& i : mymap) if (/*compare i*/) vec.emplace_back(i.first); for (auto&& key : vec) mymap.erase(key); Iterate … Read more
On the site you linked it says: When the default allocator is used, this results in the key being copy constructed from key and the mapped value being value-initialized. So the int is value-initialized: The effects of value initialization are: […] 4) otherwise, the object is zero-initialized This is why the result is 0.
The answer is no (you can’t use remove_if on associative containers). You need to do a simple loop; the erase(iterator) member now returns the next valid iterator – so your loop becomes: for(auto it = begin(m_map); it != end(m_map);) { if (it->second == 0) { it = m_map.erase(it); // previously this was something like m_map.erase(it++); … Read more
The iteration order of unordered associative containers can only change when rehashing as a result of a mutating operation (as described in C++11 23.2.5/8). You are not modifying the container between iterations, so the order will not change. Although the specification doesn’t explicitly state that rehashing can’t occur at any other time, doing so would … Read more
If you know that the key is in the map, you can utilize operator[] which returns a reference to the mapped value. Hence it will be map[key] = new_value. Be careful, however, as this will insert a (key, new_value) if the key does not already exist in the map. You can also use find which … Read more
Yes, they’re guaranteed to return equal in this case. The specific wording (from N4659, ยง[unord.req]/12) is: Two unordered containers a and b compare equal if a.size() == b.size() and, for every equivalent-key group [Ea1, Ea2) obtained from a.equal_range(Ea1), there exists an equivalent-key group [Eb1, Eb2) obtained from b.equal_range(Ea1), such that is_permutation(Ea1, Ea2, Eb1, Eb2) returns … Read more
If your intention is to test for the existence of the key, I would not use my_map[k1][k2] because operator[] will default construct a new value for that key if it does not already exist. Rather I would prefer to use std::unordered_map::find. So if you are certain the first key exists, but not the second you … Read more