User avatar admin

Translation uploaded
Mutable modification of the element:
Mutable modification of the element:对元素的可变修改：
06/05/2026
User avatar admin

Translation uploaded
Non-mutable modification of the element.
Non-mutable modification of the element.对元素的非可变修改。
06/05/2026
User avatar admin

Translation uploaded
Read access to the element.
Read access to the element.对元素的读取访问。
06/05/2026
User avatar admin

Translation uploaded
When executed internally by a `boost::concurrent_flat_map`, the following operations by a user-provided visitation function on the element passed do not introduce data races:
When executed internally by a `boost::concurrent_flat_map`, the following operations by a user-provided visitation function on the element passed do not introduce data races:当由 `boost::concurrent_flat_map` 内部执行时，用户提供的访问函数对传入元素执行以下操作不会引入数据竞争：
06/05/2026
User avatar admin

Translation uploaded
An operation is said to be _blocking on rehashing of_ ``__x__`` if it blocks on `x` only when an internal rehashing is issued.
An operation is said to be _blocking on rehashing of_ ``__x__`` if it blocks on `x` only when an internal rehashing is issued.若某个操作仅在触发内部重哈希时才会阻塞于 _`x`_，则称该操作阻塞于 _`x`_ 的重哈希过程。
06/05/2026
User avatar admin

Translation uploaded
If an operation *op* is explicitly designated as _blocking on_ `x`, where `x` is an instance of a `boost::concurrent_flat_map`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_flat_map` execute sequentially in a multithreaded scenario.
If an operation *op* is explicitly designated as _blocking on_ `x`, where `x` is an instance of a `boost::concurrent_flat_map`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_flat_map` execute sequentially in a multithreaded scenario.若某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 为 `boost::concurrent_flat_map` 实例），则先前对 `x` 的阻塞操作将与 *op* 同步。因此，在多线程场景中，对同一 `concurrent_flat_map` 的阻塞操作将按顺序执行。
06/05/2026
User avatar admin

Translation uploaded
With the exception of destruction, concurrent invocations of any operation on the same instance of a `concurrent_flat_map` do not introduce data races — that is, they are thread-safe.
With the exception of destruction, concurrent invocations of any operation on the same instance of a `concurrent_flat_map` do not introduce data races — that is, they are thread-safe.除了析构操作外，在同一个 `concurrent_flat_map` 实例上并发调用任何操作都不会引入数据竞争——即这些操作是线程安全的。
06/05/2026
User avatar admin

Translation uploaded
In general, these requirements on `Hash`, `Pred` and `Allocator` are met if these types are not stateful or if the operations only involve constant access to internal data members.
In general, these requirements on通常而言，若 `Hash`, 、 `Pred` and和 `Allocator` are met if these types are not stateful or if the operations only involve constant access to internal data members.这些类型不包含状态，或其操作仅涉及对内部数据成员的常量访问，即可满足上述要求。
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::destroy`
`std::allocator_traits<Aalloc>::destroy`</alloc>
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::construct`
`std::allocator_traits<Aalloc>::construct`</alloc>
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::deallocate`
`std::allocator_traits<Aalloc>::deallocate`</alloc>
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::allocate`
`std::allocator_traits<Aalloc>::allocate`</alloc>
06/05/2026
User avatar admin

Translation uploaded
Copy construction from `al` of an allocator rebound from `Alloc`
Copy construction from `al` of an allocator rebound from `Alloc`从Alloc重新绑定后的分配器的al进行拷贝构造
06/05/2026
User avatar admin

Translation uploaded
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:
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:常量实例并发调用 `operator()` 时不得引入数据竞争。对于 `Alloc` （即 `Allocator` 或其重绑定后的任意分配器类型），在同一实例 `al` 上并发调用以下操作时不得引入数据竞争：
06/05/2026
User avatar admin

Translation uploaded
Concurrency Requirements and Guarantees
Concurrency Requirements and Guarantees并发要求与保证
06/05/2026
User avatar admin

Translation uploaded
---
---
:371
06/05/2026
User avatar admin

Translation uploaded
If `link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]<Hash>::value` is `true`, the hash function is used as-is; otherwise, a bit-mixing post-processing stage is added to increase the quality of hashing at the expense of extra computational cost.
If `若 link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[`hash_is_avalanching]<Hash>++_++is++_++avalanching`]`++&lt;++Hash++&gt;++::value` is为 `true`, the hash function is used as-is; otherwise, a bit-mixing post-processing stage is added to increase the quality of hashing at the expense of extra computational cost. ，则直接使用哈希函数；否则，会添加一个位混合后处理阶段以提高哈希质量，但会牺牲额外的计算成本。
06/05/2026
User avatar admin

Translation uploaded
The size of the bucket array can be automatically increased by a call to `insert`/`emplace`, or as a result of calling `rehash`/`reserve`. The _load factor_ of the table (number of elements divided by number of buckets) is never greater than `max_load_factor()`, except possibly for small sizes where the implementation may decide to allow for higher loads.
The size of the bucket array can be automatically increased by a call to桶数组的大小可通过调用 `insert`/ / `emplace`, or as a result of calling 自动增加，也可通过调用 `rehash`/ / `reserve`. The _load factor_ of the table (number of elements divided by number of buckets) is never greater than `max_load_factor()`, except possibly for small sizes where the implementation may decide to allow for higher loads. 进行调整。容器的__负载因子__（元素数量与桶数量的比值）永远不会超过 `max++_++load++_++factor()` ，但在小规模数据情况下，实现可能允许更高的负载因子。
06/05/2026
User avatar admin

Translation uploaded
The elements of the table are held into an internal _bucket array_. An element is inserted into a bucket determined by its hash code, but if the bucket is already occupied (a _collision_), an available one in the vicinity of the original position is used.
The elements of the table are held into an internal _bucket array_. An element is inserted into a bucket determined by its hash code, but if the bucket is already occupied (a _collision_), an available one in the vicinity of the original position is used.容器的元素存储在内部的__桶数组__中。元素根据其哈希码被插入到对应的桶中，但如果该桶已被占用（即发生__冲突__），则会使用原始位置附近可用的桶。
06/05/2026
User avatar admin

Translation uploaded
Allocators using https://en.cppreference.com/w/cpp/named_req/Allocator#Fancy_pointers[fancy pointers] are supported.
Allocators using 支持使用https://en.cppreference.com/w/cpp/named_req/Allocator#Fancy_pointers[fancy pointers] are supported.花式指针] 的分配器。
06/05/2026

Search