Zen

Translation

Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
251/5900 · 590

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
get_allocator
get_allocator
``` allocator_type get_allocator() const noexcept; ```
``` allocator_type get_allocator() const noexcept; ```
Returns:;; The table's allocator.
返回值：;; 表的分配器。
:1326
---
---
hash_function
哈希函数
``` hasher hash_function() const; ```
``` hasher hash_function() const; ```
Returns:;; The table's hash function.
返回值：;; 表的哈希函数。
:1336
---
---
key_eq
key_eq
``` key_equal key_eq() const; ```
``` key_equal key_eq() const; ```
Returns:;; The table's key equality predicate.
返回值：;; 表的键相等性断言。
:1346
---
---
Set Operations
集合操作
count
count
```c++ size_type count(const key_type& k) const; template<class K> size_type count(const K& k) const; ```
```c++ size_type count(const key_type&amp; k) const; template<class k=""> size_type count(const K&amp; k) const; ```</class>
Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
返回值：;; 键与`k`等价的元素数量（0 或 1）。
备注：;; `template<class k="">` 重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。

在存在并发插入操作时，返回的值可能无法准确反映执行后表的真实状态。</class>
:1364
---
---
contains
包含
```c++ bool contains(const key_type& k) const; template<class K> bool contains(const K& k) const; ```
```c++ bool contains(const key_type&amp; k) const; template<class k=""> bool contains(const K&amp; k) const; ```</class>
Returns:;; A boolean indicating whether or not there is an element with key equal to `k` in the table. Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
返回值：;; 布尔值，表示表中是否存在键与`k`相等的元素。
备注：;; `template<class k="">` 重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。
在存在并发插入操作时，返回的值可能无法准确反映执行后表的真实状态。</class>
:1380
---
---
Bucket Interface
桶接口
bucket_count
bucket_count
```c++ size_type bucket_count() const noexcept; ```
```c++ size_type bucket_count() const noexcept; ```
Returns:;; The size of the bucket array.
返回值：;; 哈希桶数组的大小。
:1391
---
---
Hash Policy
哈希策略
load_factor
负载因子
```c++ float load_factor() const noexcept; ```
```c++ float load_factor() const noexcept; ```
Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, or `0` if `bucket_count() == 0`.
返回值：;; `static_cast<float>(size()) / static_cast<float>(bucket_count())`；若`bucket_count() == 0`，则返回`0`。</float></float>
:1403
---
---
English Chinese (Simplified Han script) Actions
```c++ template<class F> size_type erase_if(const key_type& k, F f); template<class K, class F> size_type erase_if(const K& k, F f); ```
```c++ template<class f=""> size_type erase_if(const key_type&amp; k, F f); template<class k,="" class="" f=""> size_type erase_if(const K&amp; k, F f); ```</class></class>
```c++ template<class F> size_type erase_if(F f); ```
```c++ template<class f=""> size_type erase_if(F f); ```</class>
Successively invokes `f` with references to each of the elements in the table, and erases those for which `f` returns `true`.
依次以表中每个元素的引用调用`f`，并删除`f`返回`true`的元素。
Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `f`.
返回值：;; 删除的元素数量。
抛出：;; 仅当 `f` 抛出异常时才会抛出异常。
Throws:;; Depending on the exception handling mechanism of the execution policy used, may call `std::terminate` if an exception is thrown within `f`. Notes:;; Only available in compilers supporting C++17 parallel algorithms. + + This overload only participates in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `true`. + + Unsequenced execution policies are not allowed.
抛出：;; 根据所使用执行策略的异常处理机制，若`f`内抛出异常，则可能调用`std::terminate`。
备注：;; 仅在支持C++17并行算法的编译器中可用。

该重载仅当`std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;`为`true`时才参与重载决议。

不允许使用无顺序执行策略。</std::remove_cvref_t<executionpolicy>
swap
交换
Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
抛出：;; 除非`key_equal`或`hasher`在交换时抛出异常，否则不抛出任何异常。
并发：;; 阻塞`*this`和`other`。
clear
清空
```c++ void clear() noexcept; ```
```c++ void clear() noexcept; ```
Erases all elements in the table.
清空表中的所有元素。
Move-inserts all the elements from `source` whose key is not already present in `*this`, and erases them from `source`.
将`source`中所有键尚未存在于`*this`中的元素移动插入，并从`source`中删除这些元素。
Returns:;; The number of elements inserted. Concurrency:;; Blocking on `*this` and `source`.
返回值：;; 插入的元素数量。
并发：;; 阻塞`*this`和`source`。
Observers
观察器
get_allocator
get_allocator
``` allocator_type get_allocator() const noexcept; ```
``` allocator_type get_allocator() const noexcept; ```
Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
返回值：;; 键与`k`等价的元素数量（0 或 1）。
备注：;; `template<class k="">` 重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。

在存在并发插入操作时，返回的值可能无法准确反映执行后表的真实状态。</class>
bucket_count
bucket_count
```c++ size_type bucket_count() const noexcept; ```
```c++ size_type bucket_count() const noexcept; ```
Returns:;; The size of the bucket array.
返回值：;; 哈希桶数组的大小。
Hash Policy
哈希策略
load_factor
负载因子
```c++ float load_factor() const noexcept; ```
```c++ float load_factor() const noexcept; ```
Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, or `0` if `bucket_count() == 0`.
返回值：;; `static_cast<float>(size()) / static_cast<float>(bucket_count())`；若`bucket_count() == 0`，则返回`0`。</float></float>
```c++ float max_load_factor() const noexcept; ```
```c++ float max_load_factor() const noexcept; ```
Returns:;; Returns the table's maximum load factor.
返回值：;; 返回哈希表的最大负载因子。
Set max_load_factor
设置最大负载因子
```c++ void max_load_factor(float z); ```
```c++ void max_load_factor(float z); ```
Effects:;; Does nothing, as the user is not allowed to change this parameter. Kept for compatibility with `boost::unordered_set`.
效果：;; 不执行任何操作，因为不允许用户修改此参数。保留该函数是为了与 `boost::unordered_set` 保持兼容。
Returns:;; The maximum number of elements the table can hold without rehashing, assuming that no further elements will be erased. Note:;; After construction, rehash or clearance, the table's maximum load is at least `max_load_factor() * bucket_count()`. This number may decrease on erasure under high-load conditions. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
返回值：;; 哈希表在不进行重哈希的前提下可容纳的最大元素数量（假设不会再删除任何元素）。
备注：;; 构造完成、重哈希或清空后，哈希表的最大负载至少为 `max_load_factor() * bucket_count()`。在高负载条件下执行删除操作后，该数值可能会降低。
在存在并发插入操作时，返回的值可能无法准确反映执行后哈希表的真实状态。
rehash
重哈希

Loading…

User avatar admin

Translation uploaded
Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if返回值：;; 键与`k`等价的元素数量（0 或 1）。
备注：;; `template<class k="">` 重载仅当 `Hash::is_transparent` and和 `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both为合法成员类型别名时才参与重载决议。标准库假定 `Hash` 可同时接受 `K` and与 `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.类型调用，且 `Pred` 是透明的。这实现了异构查找，避免了实例化 `Key` 类型对象的开销。

在存在并发插入操作时，返回的值可能无法准确反映执行后表的真实状态。</class>
06/05/2026
User avatar admin

String added in the repository
Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
Returns:;; The number of elements with key equivalent to `k` (0 or 1). Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. + + In the presence of concurrent insertion operations, the value returned may not accurately reflect the true state of the table right after execution.
06/05/2026
Browse all string changes

Things to check

Mismatched full stop

Source and translation do not both end with a full stop.

Reset

Mismatching line breaks

Number of new lines in translation does not match source.

Reset

Glossary

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

String information

Flags
safe-html, strict-same
Unit identifier
50492
Source string location
:1358
String age
06/05/2026
Last updated
06/06/2026
Source string age
06/05/2026
Translation file AsciiDoc file
doc/modules/ROOT/pages/reference/concurrent_flat_set_zh_Hans.adoc, string 349