Exit Zen
5
:32
English
But since the elements aren't ordered, the output of:
22/530 · 53
6
:41
English
can be in any order. For example, it might be:
19/460 · 46
7
:50
English
There are other differences, which are listed in the xref:regular.adoc#comparison[Comparison with Associative Containers] section.
50/1300 · 130
8
:53
English
Iterator Invalidation
5/210 · 21
9
:55
English
It is not specified how member functions other than `rehash` and `reserve` affect the bucket count, although `insert` can only invalidate iterators when the insertion causes the container's load to be greater than the maximum allowed. For most implementations this means that `insert` will only change the number of buckets when this happens. Iterators can be invalidated by calls to `insert`, `rehash` and `reserve`.
166/4170 · 417
10
:62
English
As for pointers and references, they are never invalidated for node-based containers (`boost::unordered_[multi]set`, `boost::unordered_[multi]map`, `boost::unordered_node_set`, `boost::unordered_node_map`), but they will be when rehashing occurs for `boost::unordered_flat_set` and `boost::unordered_flat_map`: this is because these containers store elements directly into their holding buckets, so when allocating a new bucket array the elements must be transferred by means of move construction.
319/4970 · 497
11
:70
English
In a similar manner to using `reserve` for ``vector``s, it can be a good idea to call `reserve` before inserting a large number of elements. This will get the expensive rehashing out of the way and let you store iterators, safe in the knowledge that they won't be invalidated. If you are inserting `n` elements into container `x`, you could first call:
125/3520 · 352
12
:76
English
``` x.reserve(n); ```
21/210 · 21
13
:80
English
`reserve(n)` reserves space for at least `n` elements, allocating enough buckets
38/800 · 80
14
:81
English
so as to not exceed the maximum load factor. + Because the maximum load factor is defined as the number of elements divided by the total number of available buckets, this function is logically equivalent to: + ``` x.rehash(std::ceil(n / x.max_load_factor())) ``` + See the xref:reference/unordered_map.adoc#unordered_map_rehash[reference for more details] on the `rehash` function.
190/3810 · 381
15
:94
English
:idprefix: comparison_
22/220 · 22
16
:96
English
Comparison with Associative Containers
8/380 · 38
:100
:100
English
Associative Containers
4/220 · 22
:100
:100
English
Unordered Associative Containers
6/320 · 32
19
:100
English
Parameterized by an ordering relation `Compare`
23/470 · 47
20
:100
English
Parameterized by a function object `Hash` and an equivalence relation `Pred`
26/760 · 76
21
:100
English
Keys can be compared using `key_compare` which is accessed by member function `key_comp()`, values can be compared using `value_compare` which is accessed by member function `value_comp()`.
72/1890 · 189
22
:100
English
Keys can be hashed using `hasher` which is accessed by member function `hash_function()`, and checked for equality using `key_equal` which is accessed by member function `key_eq()`. There is no function object for compared or hashing values.
95/2410 · 241
23
:100
English
Constructors have optional extra parameters for the comparison object.
20/700 · 70
24
:100
English
Constructors have optional extra parameters for the initial minimum number of buckets, a hash function and an equality object.
42/1260 · 126