Exit Zen
15
:60
English
Thus container-wide iteration is turned into traversing the non-empty bucket groups (an operation with constant time complexity) which reduces the time complexity back to `O(size())`. In total, a bucket group is only 4 words in size and it views `sizeof(std::size_t) * CHAR_BIT` buckets meaning that for all common implementations, there's only 4 bits of space overhead per bucket introduced by the bucket groups.
156/4130 · 413
15
:17
English
xref:reference/header_unordered_flat_map.adoc[+++<code style="color: inherit;">+++<boost/unordered/unordered_flat_map.hpp>+++</code>+++ Synopsis]
153/1450 · 145
15
:247
English
A unary function object type that acts a hash function for a `Key`. It takes a single argument of type `Key` and returns a value of type `std::size_t`.
69/1510 · 151
15
:300
English
_Hash_
6/100 · 6
15
:309
English
A unary function object type that acts a hash function for a `Key`. It takes a single argument of type `Key` and returns a value of type `std::size_t`.
38/1510 · 151
15
:344
English
A unary function object type that acts a hash function for a `Key`. It takes a single argument of type `Key` and returns a value of type `std::size_t`.
57/1510 · 151
15
:248
English
_Hash_
6/100 · 6
15
:245
English
An allocator whose value type is the same as the container's value type.
20/720 · 72
15
:297
English
_Hash_
6/100 · 6
15
:287
English
A binary function object that implements an equivalence relation on values of type `Key`. A binary function object that induces an equivalence relation on values of type `Key`. It takes two arguments of type `Key` and returns a value of type bool.
66/2470 · 247
15
:66
English
For unsuccessful lookups, the average number of element comparisons should be close to 0.0.
23/910 · 91
16
:16
English
xref:reference/unordered_map.adoc[`unordered_map`]
50/500 · 50
16
:72
English
predicates, especially if you're using a function pointer. If you compare two containers with different equality predicates then the result is undefined. For most stateless function objects this is impossible - since you can only compare objects with the same equality predicate you know the equality predicates must be equal. But if you're using function pointers or a stateful equality predicate (e.g. `boost::function`) then you can get into trouble.
162/4530 · 453
16
:65
English
All sets and maps in Boost.Unordered are instantiatied similarly as `std::unordered_set` and `std::unordered_map`, respectively:
90/1280 · 128
16
:67
English
Open-addressing containers provided by Boost.Unordered only work with reasonably compliant C++11 (or later) compilers. Language-level features such as move semantics and variadic template parameters are then not emulated. The containers are fully https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer[AllocatorAware^] and support https://en.cppreference.com/w/cpp/named_req/Allocator#Fancy_pointers[fancy pointers^].
249/4300 · 430
16
:118
English
The average number of comparisons per unsuccessful lookup should be close to 0.0.
21/810 · 81
16
:96
English
Comparison with Associative Containers
8/380 · 38
16
:31
English
In Visual Studio Natvis, supported any container with an allocator that uses fancy pointers. This applies to any fancy pointer type, as long as the proper Natvis customization point "Intrinsic" functions are written for the fancy pointer type.
98/2430 · 243
:32
:32
English
Using in your project
6/210 · 21
16
:159
English
Whole-Table Visitation
4/220 · 22