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_node_set`, 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_set`, the following operations by a user-provided visitation function on the element passed do not introduce data races:当由 `boost::concurrent++_++node++_++set` 内部执行时，用户提供的访问函数对传递的元素执行以下操作不会引入数据竞争：
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_set`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_node_set` 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_set`, prior blocking operations on `x` synchronize with *op*. So, blocking operations on the same `concurrent_node_set` execute sequentially in a multithreaded scenario.若某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 为 `boost::concurrent++_++node++_++set` 实例），则先前对 `x` 的阻塞操作将与 *op* 同步。因此，在多线程场景中，对同一 `concurrent++_++node++_++set` 的阻塞操作将按顺序执行。
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_set` 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_set` do not introduce data races — that is, they are thread-safe.除析构操作外，对同一 `concurrent++_++node++_++set` 实例并发调用任何操作均不会引入数据竞争——即这些操作是线程安全的。
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<Alloc>++&lt;++Alloc++&gt;++::destroy`
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::construct`
`std::allocator_++_++traits<Alloc>++&lt;++Alloc++&gt;++::construct`
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::deallocate`
`std::allocator_++_++traits<Alloc>++&lt;++Alloc++&gt;++::deallocate`
06/05/2026
User avatar admin

Translation uploaded
`std::allocator_traits<Alloc>::allocate`
`std::allocator_++_++traits<Alloc>++&lt;++Alloc++&gt;++::allocate`
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
---
---
:335
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
`std::allocator_traits<Allocator>::pointer` and `std::allocator_traits<Allocator>::const_pointer` must be convertible to/from `value_type*` and `const value_type*`, respectively.
`std::allocator_traits<Aallocator>::pointer` and与 `std::allocator_traits<Aallocator>::const_pointer` must be convertible to/from必须分别可与 `value_type*` and和 `const value_type*`, respectively. 相互转换。</allocator></allocator>
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

Search