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_node_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_node_map`, the following operations by a user-provided visitation function on the element passed do not introduce data races:当由 `boost::concurrent++_++node++_++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_node_map`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_node_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_node_map`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_node_map` execute sequentially in a multithreaded scenario.如果某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 是 `boost::concurrent++_++node++_++map` 的实例），则先前对 `x` 的阻塞操作将与 *op* 同步。因此，在多线程场景中，对同一 `concurrent++_++node++_++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_node_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_node_map` do not introduce data races — that is, they are thread-safe.除析构操作外，对同一个 `concurrent++_++node++_++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`从 `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
---
---
:388
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]<Hhash>::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.，则直接使用原哈希函数；否则会添加一个比特混合后处理阶段，以额外计算开销为代价提升哈希质量。</hash>
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.通过调用 `insert`/`emplace`，或执行 `rehash`/`reserve` 操作，可自动增大桶数组的大小。哈希表的**负载因子**（元素数量除以桶数量）永远不会大于 `max_load_factor()`，仅在尺寸极小时，实现可能允许更高的负载。
06/05/2026
User avatar admin

Translation uploaded
The element nodes of the table are held into an internal _bucket array_. An node is inserted into a bucket determined by the hash code of its element, but if the bucket is already occupied (a _collision_), an available one in the vicinity of the original position is used.
The element nodes of the table are held into an internal _bucket array_. An node is inserted into a bucket determined by the hash code of its element, 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
User avatar admin

Translation uploaded
An allocator whose value type is the same as the table's value type.
An allocator whose value type is the same as the table's value type.值类型与该表的值类型一致的分配器。
06/05/2026
User avatar admin

Translation uploaded
_Allocator_
_Allocator_
06/05/2026

Search