Zen

Translation

As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.
96/3120 · 312

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
2+^h| *Closed-addressing containers only* h|*Method* h|*Description*
2+^h| *仅限闭寻址容器* h|*方法* h|*描述*
`size_type max_bucket_count() const`
`size_type max_bucket_count() const`
An upper bound on the number of buckets.
桶数量的上限。
`size_type bucket_size(size_type n) const`
`size_type bucket_size(size_type n) const`
The number of elements in bucket `n`.
返回桶 `n` 中的元素数量。
`size_type bucket(key_type const& k) const`
`size_type bucket(key_type const& k) const`
Returns the index of the bucket which would contain `k`.
返回键 `k` 所对应的桶的索引。
`local_iterator begin(size_type n)`
`local_iterator begin(size_type n)`
1.6+|Return begin and end iterators for bucket `n`.
1.6+|返回编号为 `n` 的桶的起始与末尾迭代器。
`local_iterator end(size_type n)`
`local_iterator end(size_type n)`
`const_local_iterator begin(size_type n) const`
`const_local_iterator begin(size_type n) const`
`const_local_iterator end(size_type n) const`
`const_local_iterator end(size_type n) const`
`const_local_iterator cbegin(size_type n) const`
`const_local_iterator cbegin(size_type n) const`
`const_local_iterator cend(size_type n) const`
`const_local_iterator cend(size_type n) const`
Controlling the Number of Buckets
桶数量控制
As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.
当无序关联容器中的元素不断增加时，冲突次数会随之上升，从而导致性能下降。为解决此问题，容器会在插入元素过程中自动增加桶的数量。用户也可以通过调用 `rehash` 方法来按需调整容器的桶数量。
The standard leaves a lot of freedom to the implementer to decide how the number of buckets is chosen, but it does make some requirements based on the container's _load factor_, the number of elements divided by the number of buckets. Containers also have a _maximum load factor_ which they should try to keep the load factor below.
标准规范虽未强制规定桶数量的具体选择方式，但基于容器的__负载因子__（即元素数量与桶数量的比值）提出了若干要求。同时，容器还设有一个__最大负载因子__，其运行过程中需始终将实际负载因子维持在该阈值以下。
You can't control the bucket count directly but there are two ways to influence it:
用户无法直接控制桶的数量，但可通过以下两种方式间接调控：
Specify the minimum number of buckets when constructing a container or when calling `rehash`.
用户可在构造容器或调用 `rehash` 方法时指定桶数量的最小值。
Suggest a maximum load factor by calling `max_load_factor`.
用户可通过调用 `max_load_factor` 方法来设定最大负载因子的建议值。
`max_load_factor` doesn't let you set the maximum load factor yourself, it just lets you give a _hint_. And even then, the standard doesn't actually require the container to pay much attention to this value. The only time the load factor is _required_ to be less than the maximum is following a call to `rehash`. But most implementations will try to keep the number of elements below the max load factor, and set the maximum load factor to be the same as or close to the hint - unless your hint is unreasonably small or large.
`max_load_factor` 并不允许用户自行设定最大负载因子，该方法仅用于提供__提示__。即便如此，标准也并未强制要求容器必须严格遵守该数值。唯一强制要求负载因子必须小于最大值的场景是在调用 `rehash` 方法之后。但大多数实现会尝试将元素数量维持在最大负载因子以下，并将最大负载因子设定为与提示值相同或接近——除非用户提供的提示值过小或过大。
:111
2+^h| *All containers* h|*Method* h|*Description*
2+^h| *所有容器* h|*方法* h|*描述*
`X(size_type n)`
`X(size_type n)`
Construct an empty container with at least `n` buckets (`X` is the container type).
构造一个至少包含 `n` 个桶的空容器（ `X` 表示容器类型）。
`X(InputIterator i, InputIterator j, size_type n)`
`X(InputIterator i, InputIterator j, size_type n)`
Construct an empty container with at least `n` buckets and insert elements from the range `[i, j)` (`X` is the container type).
构造一个至少包含 `n` 个桶的空容器，并插入范围 `[i, j)` 中的元素（ `X` 表示容器类型）。
`float load_factor() const`
`float load_factor() const`
The average number of elements per bucket.
返回每个桶的平均元素数量。
`float max_load_factor() const`
`float max_load_factor() const`
Returns the current maximum load factor.
返回当前的最大负载因子。
`float max_load_factor(float z)`
`float max_load_factor(float z)`
English Chinese (Simplified Han script) Actions
`size_type bucket_count() const`
`size_type bucket_count() const`
2+^h| *Closed-addressing containers only* h|*Method* h|*Description*
2+^h| *仅限闭寻址容器* h|*方法* h|*描述*
`size_type max_bucket_count() const`
`size_type max_bucket_count() const`
An upper bound on the number of buckets.
桶数量的上限。
`size_type bucket_size(size_type n) const`
`size_type bucket_size(size_type n) const`
The number of elements in bucket `n`.
返回桶 `n` 中的元素数量。
`size_type bucket(key_type const& k) const`
`size_type bucket(key_type const& k) const`
`local_iterator begin(size_type n)`
`local_iterator begin(size_type n)`
1.6+|Return begin and end iterators for bucket `n`.
1.6+|返回编号为 `n` 的桶的起始与末尾迭代器。
`local_iterator end(size_type n)`
`local_iterator end(size_type n)`
`const_local_iterator begin(size_type n) const`
`const_local_iterator begin(size_type n) const`
`const_local_iterator end(size_type n) const`
`const_local_iterator end(size_type n) const`
`const_local_iterator cbegin(size_type n) const`
`const_local_iterator cbegin(size_type n) const`
`const_local_iterator cend(size_type n) const`
`const_local_iterator cend(size_type n) const`
Controlling the Number of Buckets
桶数量控制
As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.
当无序关联容器中的元素不断增加时，冲突次数会随之上升，从而导致性能下降。为解决此问题，容器会在插入元素过程中自动增加桶的数量。用户也可以通过调用 `rehash` 方法来按需调整容器的桶数量。
Specify the minimum number of buckets when constructing a container or when calling `rehash`.
用户可在构造容器或调用 `rehash` 方法时指定桶数量的最小值。
Suggest a maximum load factor by calling `max_load_factor`.
用户可通过调用 `max_load_factor` 方法来设定最大负载因子的建议值。
`max_load_factor` doesn't let you set the maximum load factor yourself, it just lets you give a _hint_. And even then, the standard doesn't actually require the container to pay much attention to this value. The only time the load factor is _required_ to be less than the maximum is following a call to `rehash`. But most implementations will try to keep the number of elements below the max load factor, and set the maximum load factor to be the same as or close to the hint - unless your hint is unreasonably small or large.
`max_load_factor` 并不允许用户自行设定最大负载因子，该方法仅用于提供__提示__。即便如此，标准也并未强制要求容器必须严格遵守该数值。唯一强制要求负载因子必须小于最大值的场景是在调用 `rehash` 方法之后。但大多数实现会尝试将元素数量维持在最大负载因子以下，并将最大负载因子设定为与提示值相同或接近——除非用户提供的提示值过小或过大。
`X(size_type n)`
`X(size_type n)`
Construct an empty container with at least `n` buckets (`X` is the container type).
构造一个至少包含 `n` 个桶的空容器（ `X` 表示容器类型）。
`X(InputIterator i, InputIterator j, size_type n)`
`X(InputIterator i, InputIterator j, size_type n)`
Construct an empty container with at least `n` buckets and insert elements from the range `[i, j)` (`X` is the container type).
构造一个至少包含 `n` 个桶的空容器，并插入范围 `[i, j)` 中的元素（ `X` 表示容器类型）。
`float load_factor() const`
`float load_factor() const`
The average number of elements per bucket.
返回每个桶的平均元素数量。
Returns the current maximum load factor.
返回当前的最大负载因子。
`float max_load_factor(float z)`
`float max_load_factor(float z)`
Changes the container's maximum load factor, using `z` as a hint. +
以 `z` 作为提示值来更改容器的最大负载因子。 +
**Open-addressing and concurrent containers:** this function does nothing: users are not allowed to change the maximum load factor.
**开放寻址与并发容器：**此函数无效，用户不允许更改最大负载因子。
`void rehash(size_type n)`
`void rehash(size_type n)`

Loading…

User avatar admin

Translation uploaded
As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.
As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.当无序关联容器中的元素不断增加时，冲突次数会随之上升，从而导致性能下降。为解决此问题，容器会在插入元素过程中自动增加桶的数量。用户也可以通过调用 `rehash` 方法来按需调整容器的桶数量。
06/05/2026
User avatar admin

String added in the repository
As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.
As more elements are added to an unordered associative container, the number of collisions will increase causing performance to degrade. To combat this the containers increase the bucket count as elements are inserted. You can also tell the container to change the bucket count (if required) by calling `rehash`.
06/05/2026
Browse all string changes

Glossary

English Chinese (Simplified Han script)
No related strings found in the glossary.

String information

Flags
safe-html, strict-same
Unit identifier
51295
Source string location
:82
String age
06/05/2026
Last updated
06/06/2026
Source string age
06/05/2026
Translation file AsciiDoc file
doc/modules/ROOT/pages/buckets_zh_Hans.adoc, string 30