Use of equal_range for unordered_map

Question

As it makes sense, lower_bound and upper_bound are absent for std::unordered_map because there is no order for elements.

However std::unordered_map has method equal_range. it return iterators for range corresponding to a key.

How does it make sense? Since there can be only one element with a key in std::unordered_map. It is just find method.

Also, in std::unordered_multimap, does it presence means all elements with same key will always come together while iterating unordered_multimap with a iterator?

NathanOliver · Accepted Answer · 2018-11-28T14:26:17.027

10

How does it make sense?

It kind of does. The standard requires all associative container to offer equal_range so the non multi containers need to provide it. It does make writing generic code easier so I suspect that is the reason why all of the containers are required to use it.

Does it presence means all elements with same key will always come together while iterating unordered_map with a iterator?

Actually, yes. Since the all of the keys will have the same value they will hash to the same value which means they all get stored in the same bucket and will be grouped together since the keys compare equally. From [unord.req]/6

An unordered associative container supports unique keys if it may contain at most one element for each key. Otherwise, it supports equivalent keys. unordered_set and unordered_map support unique keys. unordered_multiset and unordered_multimap support equivalent keys. In containers that support equivalent keys, elements with equivalent keys are adjacent to each other in the iteration order of the container. Thus, although the absolute order of elements in an unordered container is not specified, its elements are grouped into equivalent-key groups such that all elements of each group have equivalent keys. Mutating operations on unordered containers shall preserve the relative order of elements within each equivalent-key group unless otherwise specified.

^{emphasis mine}

edited Nov 28 '18 at 14:26

answered Nov 28 '18 at 13:54

NathanOliver

171,901
28
288
402

1

if they are in the same bucket it doesn't mean they are continious by itself, because other lement can be in the same bucket – RiaD Nov 28 '18 at 13:59
@RiaD Yes, you can have a hash collision but the map has to keep those equally hashed elements separate by checking the equality of the key. That is why the unordered containers requires the key be hash-able and equally comparable. – NathanOliver Nov 28 '18 at 14:01
1

my point was that I understood your second not quoted paragraph to imply that (they are in the same bucket) => (they are grouped). If you was trying to say that, I'm sorry, i've misunderstood that then – RiaD Nov 28 '18 at 14:24
btw, I am not really sure I agree with a decision to require equivalent element to be grouped, but of course it's question not to you but to standard commitee – RiaD Nov 28 '18 at 14:25
@RiaD It would make implementing `equal_range` difficult if they didn't. You'd have to have a skip iterator that could skip of the elements in the bucket that don't have the same key value. – NathanOliver Nov 28 '18 at 14:27
yes, I understand that, But I have never used `equal_range` so it's kinda paying for what I do not use – RiaD Nov 28 '18 at 14:28

score 3 · Answer 2 · answered Nov 28 '18 at 13:57

It's for consistency with the other containers.

It makes more sense in the _multi variants, but is present in all the associative (and unordered associative) containers in the standard library.

It allows you to write code like

template <typename MapLike, typename KeyLike>
void do_stuff(const MapLike & map, const KeyLike & key)
{
    auto range = map.equal_range(key);
    for (auto it = range.first; it != range.second; ++it)
         // blah
}

Which does not care about what specific container it is dealing with

score 2 · Answer 3 · answered Nov 28 '18 at 13:49

cplusplus.com writes about std::unordered_map::equal_range:

Returns the bounds of a range that includes all the elements in the container with a key that compares equal to k. In unordered_map containers, where keys are unique, the range will include one element at most.

JFMR · Answer 4 · 2018-11-28T14:44:34.677

Also, in std::unordered_multimap, does it presence means all elements with same key will always come together while iterating unordered_multimap with a iterator?

In general, the order, in which elements stored in a std::unordered_multimap are obtained while traversing it, is actually not defined. However, note that std::unordered_multimaps are usually implemented as hash tables. By analysing such an implementation you will realize that the ordering is not going to be as "undefined" as someone might initially think.

At element insertion (or hash table rehashing), the value resulting of applying the hash function to an element's key is used to select the bucket where that element is going to be stored. Two elements with equal keys will result in the same hash value, therefore they will be stored in the same bucket, so they come together^X while iterating an std::unordered_multimap.

^XNote that even two elements with different keys might also result in the same hash value (i.e., a collision). However, std::unordered_multimap can handle these cases by comparing the keys against equality, and therefore still group elements with equal keys together.

Use of equal_range for unordered_map

4 Answers4