User avatar admin

Translation uploaded
No equivalent. Since the elements aren't ordered `lower_bound` and `upper_bound` would be meaningless.
No equivalent. Since the elements aren't ordered 无对应接口。由于元素无序，`lower_bound` and `和 `upper_bound` would be meaningless. `无实际意义。
06/05/2026
User avatar admin

Translation uploaded
Member function `lower_bound(k)` and `upper_bound(k)`
Member function 成员函数`lower_bound(k)` and 和`upper_bound(k)`
06/05/2026
User avatar admin

Translation uploaded
Keys `k1`, `k2` are considered equivalent if `Pred(k1, k2)`
Keys `若`谓词对象(k1`, `k2` are considered equivalent if `Pred(k1, k2)`)成立`，则键`k1`、`k2`视为等价。
06/05/2026
User avatar admin

Translation uploaded
Keys `k1`, `k2` are considered equivalent if `!Compare(k1, k2) && !Compare(k2, k1)`.
Keys `k1`, `k2` are considered equivalent if `!Compare(k1, k2) && !Compare(k2, k1)`.若`!对象(k1, k2) && !对象(k2, k1)`，则键`k1`、`k2`视为等价。
06/05/2026
User avatar admin

Translation uploaded
Constructors have optional extra parameters for the initial minimum number of buckets, a hash function and an equality object.
Constructors have optional extra parameters for the initial minimum number of buckets, a hash function and an equality object.构造函数包含可选的额外参数，用于指定初始最小哈希桶数量、哈希函数以及相等性判断对象。
06/05/2026
User avatar admin

Translation uploaded
Constructors have optional extra parameters for the comparison object.
Constructors have optional extra parameters for the comparison object.构造函数包含用于比较对象的可选额外参数。
06/05/2026
User avatar admin

Translation uploaded
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.
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.键可通过成员函数`hash_function()`获取的`哈希对象`进行哈希计算，并通过成员函数`key_eq()`获取的`键相等比较对象`检查是否相等。不存在用于值比较或值哈希的函数对象。
06/05/2026
User avatar admin

Translation uploaded
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()`.
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()`.键可通过成员函数`key_comp()`获取的`键比较对象`进行比较，值可通过成员函数`value_comp()`获取的`值比较对象`进行比较。
06/05/2026
User avatar admin

Translation uploaded
Parameterized by a function object `Hash` and an equivalence relation `Pred`
Parameterized by a function object `Hash` and an equivalence relation `Pred`由函数对象`哈希对象`和等价关系`谓词对象`参数化。
06/05/2026
User avatar admin

Translation uploaded
Parameterized by an ordering relation `Compare`
Parameterized by an ordering relation通过排序关系 `Compare` 进行 参数化
06/05/2026
User avatar admin

Translation uploaded
Unordered Associative Containers
Unordered Associative Containers无序关联容器
:100
06/05/2026
User avatar admin

Translation uploaded
Associative Containers
Associative Containers关联容器
:100
06/05/2026
User avatar admin

Translation uploaded
Comparison with Associative Containers
Comparison with Associative Containers与关联容器的对比
06/05/2026
User avatar admin

Translation uploaded
:idprefix: comparison_
:idprefix: comparison_
06/05/2026
User avatar admin

Translation uploaded
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.
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: + ``` 以确保不超过最大负载因子。由于最大负载因子定义为元素数量除以可用桶的总数，该函数在逻辑上等价于：
```cppx.rehash(std::ceil(n / x.max_load_factor())) ``` + See the
有关 `rehash` 函数的更多详细信息，请参阅 xref:reference/unordered_map.adoc#unordered_map_rehash[reference for more details] on the `rehash` function.参考文档]。
06/05/2026
User avatar admin

Translation uploaded
`reserve(n)` reserves space for at least `n` elements, allocating enough buckets
`reserve(n)` reserves space for at least `n` elements, allocating enough buckets为至少 `n` 个元素预留空间，分配足够数量的桶，
06/05/2026
User avatar admin

Translation uploaded
``` x.reserve(n); ```
``` x.reserve(n); ```
06/05/2026
User avatar admin

Translation uploaded
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:
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:与为 `vector` 使用 `reserve` 类似，在插入大量元素之前调用 `reserve` 是一个好主意。这样可以避免代价高昂的重哈希操作，并且让你能够存储迭代器，确信它们不会被失效。如果你要向容器 `x` 插入 `n` 个元素，可以先调用：
06/05/2026
User avatar admin

Translation uploaded
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.
As for pointers and references, they are never invalidated for node-based containers (对于基于节点的容器（ `boost::unordered_[multi]++_[++multi++]++set`, 、 `boost::unordered_[multi]++_[++multi++]++map`, 、 `boost::unordered_node_++_++node++_++set`, 、 `boost::unordered_node_map`), but they will be when rehashing occurs for++_++node++_++map` ），其指针和引用永远不会失效。但对于 `boost::unordered_flat_++_++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.++_++flat++_++map` ，在发生重哈希时指针和引用将会失效：这是因为这些容器将元素直接存储在桶中，当分配新的桶数组时，必须通过移动构造来转移元素。
06/05/2026
User avatar admin

Translation uploaded
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`.
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` 操作仅当导致容器负载超过最大允许值时才会使迭代器失效。在大多数实现中，这意味着 `insert` 仅在此种情况下才会改变桶的数量。迭代器可能因调用 `insert`, 、 `rehash` and或 `reserve`. 而失效。
06/05/2026

Search