2. Boost Unordered Translation (zh_Hans)
3. English
4. Zen

25 :284
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Convertible to `const_iterator`. 32/10000 · 32
:324 :324
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
26 :26
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — xref:reference/header_unordered_flat_map.adoc[`<boost/unordered/unordered_flat_map.hpp>`] 89/10000 · 89
26 :100
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Keys `k1`, `k2` are considered equivalent if `Pred(k1, k2)` 59/10000 · 59
26 :79
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The C++ standard specification of unordered associative containers impose severe limitations on permissible implementations, the most important being that closed addressing is implicitly assumed. Slightly relaxing this specification opens up the possibility of providing container variations taking full advantage of open-addressing techniques. 344/10000 · 344
26 :122
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — std::size_t hash_value(point const& p) { std::size_t seed = 0; boost::hash_combine(seed, p.x); boost::hash_combine(seed, p.y); return seed; } 141/10000 · 141
:74 :74
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — h|by key, duplicate elements h|by key, duplicate elements, + max load factor 5 78/10000 · 78
26 :261
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — There's a latency/throughput tradeoff here: it will take longer for incoming keys to be processed (since they are buffered), but the number of processed keys per second is higher. `bulk_visit_size` is the recommended chunk size —smaller buffers may yield worse performance. 273/10000 · 273
26 :68
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `const_local_iterator end(size_type n) const` 45/10000 · 45
26 :107
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Container traversal. 20/10000 · 20
26 :112
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Insertion is algorithmically similar: empty buckets are located using SIMD, and when going past a full group its corresponding overflow bit is set to 1. 152/10000 · 152
26 :58
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```plaintext (gdb) print example_unordered_map $1 = boost::unordered_map with 3 elements = {["C"] = "c", ["B"] = "b", ["A"] = "a"} (gdb) print example_unordered_map_begin $2 = iterator = { {first = "C", second = "c"} } (gdb) print example_unordered_map_end $3 = iterator = { end iterator } (gdb) print example_unordered_set $4 = boost::unordered_set with 3 elements = {[0] = "c", [1] = "b", [2] = "a"} (gdb) print example_unordered_set_begin $5 = iterator = { "c" } (gdb) print example_unordered_set_end $6 = iterator = { end iterator } ``` 540/10000 · 540
26 :28
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — xref:reference/header_concurrent_flat_map_fwd.adoc[+++<code style="color: inherit;">+++<boost/unordered/concurrent_flat_map_fwd.hpp>+++</code>+++ Synopsis] 155/10000 · 155
26 :45
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Release 1.85.0 14/10000 · 14
:327 :327
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The iterator category is at least a forward iterator. 53/10000 · 53
:287 :287
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
26 :281
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `BOOST_UNORDERED_ENABLE_STATS` 30/10000 · 30
26 :392
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Concurrent invocations of `operator()` on the same const instance of `Hash` or `Pred` are required to not introduce data races. For `Alloc` being either `Allocator` or any allocator type rebound from `Allocator`, concurrent invocations of the following operations on the same instance `al` of `Alloc` are required to not introduce data races: 342/10000 · 342
26 :375
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Concurrent invocations of `operator()` on the same const instance of `Hash` or `Pred` are required to not introduce data races. For `Alloc` being either `Allocator` or any allocator type rebound from `Allocator`, concurrent invocations of the following operations on the same instance `al` of `Alloc` are required to not introduce data races: 342/10000 · 342
26 :322
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Concurrent invocations of `operator()` on the same const instance of `Hash` or `Pred` are required to not introduce data races. For `Alloc` being either `Allocator` or any allocator type rebound from `Allocator`, concurrent invocations of the following operations on the same instance `al` of `Alloc` are required to not introduce data races: 342/10000 · 342