Chinese (Simplified Han script) (Boost Unordered - en to zh_Hans translation catalogue (325 entries)

en: Class Template concurrent_flat_map
zh_Hans: 类模板 concurrent_flat_map

en: `boost::concurrent_flat_map` — A hash table that associates unique keys with another value and allows for concurrent element insertion, erasure, lookup and access without external synchronization mechanisms.
zh_Hans: `boost::concurrent_flat_map` — 一种哈希表，将唯一键与对应值关联，并允许在无需外部同步机制的情况下进行并发的元素插入、删除、查找和访问。

en: Even though it acts as a container, `boost::concurrent_flat_map` does not model the standard C++ https://en.cppreference.com/w/cpp/named_req/Container[Container^] concept. In particular, iterators and associated operations (`begin`, `end`, etc.) are not provided. Element access and modification are done through user-provided _visitation functions_ that are passed to `concurrent_flat_map` operations where they are executed internally in a controlled fashion. Such visitation-based API allows for low-contention concurrent usage scenarios.
zh_Hans: 尽管它充当容器的角色，boost::concurrent_flat_map 并未遵循标准 C++ 的 https://en.cppreference.com/w/cpp/named_req/Container[Container^] 概念。特别地，它不提供迭代器及相关操作（例如 begin、end 等）。元素的访问和修改是通过用户提供的 访问函数 来完成的，这些函数被传递给 concurrent_flat_map 的操作，并以受控的方式在内部执行。这种基于访问的 API 能够实现低竞争并发的使用场景。

en: The internal data structure of `boost::concurrent_flat_map` is similar to that of `boost::unordered_flat_map`. As a result of its using open-addressing techniques, `value_type` must be move-constructible and pointer stability is not kept under rehashing.
zh_Hans: `boost::concurrent++_++flat++_++map` 的内部数据结构与 `boost::unordered++_++flat++_++map` 类似。由于采用开放寻址技术， `value++_++type` 必须支持移动构造，且在重哈希过程中无法保持指针稳定性。

en: Synopsis
zh_Hans: 概要

en: Description
zh_Hans: 描述

en: *Template Parameters*
zh_Hans: *模板参数*

en: _Key_
zh_Hans: _键_

en: `std::pair<const Key, T>` must be https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] into the table from any `std::pair` object convertible to it, and it also must be https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the table.
zh_Hans: `std::pair<const key,="" t="">` 必须能够从任何可转换为其的 `std::pair` 对象出发，在表中进行 https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] 构造，并且也必须可以从表中进行 https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] 擦除。</const>

en: A unary function object type that acts a hash function for a `Key`. It takes a single argument of type `Key` and returns a value of type `std::size_t`.
zh_Hans: 一种一元函数对象类型，用作Key类型的哈希函数。它接受单个Key类型的参数，并返回std::size_t类型的值。

en: A binary function object that induces an equivalence relation on values of type `Key`. It takes two arguments of type `Key` and returns a value of type `bool`.
zh_Hans: 一种二元函数对象，用于在Key类型的值上引入等价关系。该对象接收两个Key类型的参数，并返回一个bool类型的值。

en: An allocator whose value type is the same as the table's value type.
zh_Hans: 值类型与哈希表值类型相同的分配器。

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

en: 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.
zh_Hans: 容器的元素存储在内部的__桶数组__中。元素根据其哈希码被插入到对应的桶中，但如果该桶已被占用（即发生__冲突__），则会使用原始位置附近可用的桶。

en: 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.
zh_Hans: 桶数组的大小可通过调用 `insert` / `emplace` 自动增加，也可通过调用 `rehash` / `reserve` 进行调整。容器的__负载因子__（元素数量与桶数量的比值）永远不会超过 `max++_++load++_++factor()` ，但在小规模数据情况下，实现可能允许更高的负载因子。

en: 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.
zh_Hans: 若 link:../../../../../container_hash/doc/html/hash.html#ref_hash_is_avalanchinghash[`hash++_++is++_++avalanching`]`++&lt;++Hash++&gt;++::value` 为 `true` ，则直接使用哈希函数；否则，会添加一个位混合后处理阶段以提高哈希质量，但会牺牲额外的计算成本。

en: Concurrency Requirements and Guarantees
zh_Hans: 并发要求与保证

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

en: Copy construction from `al` of an allocator rebound from `Alloc`
zh_Hans: 从Alloc重新绑定后的分配器的al进行拷贝构造

en: `std::allocator_traits<Alloc>::allocate`
zh_Hans: `std::allocator_traits<alloc>::allocate`</alloc>

en: `std::allocator_traits<Alloc>::deallocate`
zh_Hans: `std::allocator_traits<alloc>::deallocate`</alloc>

en: `std::allocator_traits<Alloc>::construct`
zh_Hans: `std::allocator_traits<alloc>::construct`</alloc>

en: `std::allocator_traits<Alloc>::destroy`
zh_Hans: `std::allocator_traits<alloc>::destroy`</alloc>

en: 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.
zh_Hans: 通常而言，若 `Hash` 、 `Pred` 和 `Allocator` 这些类型不包含状态，或其操作仅涉及对内部数据成员的常量访问，即可满足上述要求。

en: 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.
zh_Hans: 除了析构操作外，在同一个 `concurrent_flat_map` 实例上并发调用任何操作都不会引入数据竞争——即这些操作是线程安全的。

en: 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.
zh_Hans: 若某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 为 `boost::concurrent_flat_map` 实例），则先前对 `x` 的阻塞操作将与 *op* 同步。因此，在多线程场景中，对同一 `concurrent_flat_map` 的阻塞操作将按顺序执行。

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

en: 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:
zh_Hans: 当由 `boost::concurrent_flat_map` 内部执行时，用户提供的访问函数对传入元素执行以下操作不会引入数据竞争：

en: Read access to the element.
zh_Hans: 对元素的读取访问。

en: Non-mutable modification of the element.
zh_Hans: 对元素的非可变修改。

en: Mutable modification of the element:
zh_Hans: 对元素的可变修改：

en: ** Within a container function accepting two visitation functions, always for the first function. ** Within a non-const container function whose name does not contain `cvisit`, for the last (or only) visitation function.
zh_Hans: ** 在容器接受两个访问函数的操作中，此条件始终适用于第一个访问函数。 ** 在名称不包含 `cvisit` 的非常量容器函数中，此条件适用于最后一个（或唯一一个）访问函数。

en: Any `boost::concurrent_flat_map operation` that inserts or modifies an element `e` synchronizes with the internal invocation of a visitation function on `e`.
zh_Hans: 任何插入或修改元素 `e` 的 `boost::concurrent_flat_map operation` 操作，都会与针对 `e` 的内部访问函数调用同步。

en: Visitation functions executed by a `boost::concurrent_flat_map` `x` are not allowed to invoke any operation on `x`; invoking operations on a different `boost::concurrent_flat_map` instance `y` is allowed only if concurrent outstanding operations on `y` do not access `x` directly or indirectly.
zh_Hans: 由 `boost::concurrent_flat_map` 容器 `x` 执行的访问函数不得调用 `x` 上的任何操作；仅当对另一 `boost::concurrent_flat_map` 实例 `y` 的并发的未完成操作不直接或间接访问 `x` 时，才允许调用实例 `y` 上的操作。

en: Configuration Macros
zh_Hans: 配置宏

en: In debug builds (more precisely, when link:../../../../../assert/doc/html/assert.html#boost_assert_is_void[`BOOST_ASSERT_IS_VOID`^] is not defined), __container reentrancies__ (illegaly invoking an operation on `m` from within a function visiting elements of `m`) are detected and signalled through `BOOST_ASSERT_MSG`. When run-time speed is a concern, the feature can be disabled by globally defining this macro.
zh_Hans: 在调试版本中（更准确地说，当未定义 link:../../../../../assert/doc/html/assert.html#boost_assert_is_void[`BOOST_ASSERT_IS_VOID`] 时），系统会检测__容器重入__行为（即在访问 `m` 元素的函数内部非法调用 `m` 上的操作），并通过 `BOOST_ASSERT_MSG` 发出信号。若需关注运行时速度，可通过全局定义此宏来禁用该功能。

en: Globally define this macro to enable xref:reference/stats.adoc#stats[statistics calculation] for the table. Note that this option decreases the overall performance of many operations.
zh_Hans: 全局定义此宏以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请注意，此选项会降低多数操作的总体性能。

en: Constants
zh_Hans: 常量

en: Chunk size internally used in xref:concurrent_flat_map_bulk_visit[bulk visit] operations.
zh_Hans: xref:concurrent_flat_map_bulk_visit [批量访问] 操作内部使用的块大小。

en: Constructors
zh_Hans: 构造函数

en: Default Constructor
zh_Hans: 默认构造函数

en: Constructs an empty table using `hasher()` as the hash function, `key_equal()` as the key equality predicate and `allocator_type()` as the allocator.
zh_Hans: 使用hasher()作为哈希函数、key_equal()作为键相等谓词、allocator_type()作为分配器，构造一个空表。

[ctx: :456]
en: Postconditions:;; `size() == 0` Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 后置条件：size() == 0
    要求：若使用默认构造方式，则hasher、key_equal和allocator_type必须满足https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。

en: Bucket Count Constructor
zh_Hans: 桶数构造函数

en: ```c++ explicit concurrent_flat_map(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); ```
zh_Hans: ```c++ explicit concurrent_flat_map(size_type n, const hasher&amp; hf = hasher(), const key_equal&amp; eql = key_equal(), const allocator_type&amp; a = allocator_type()); ```

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `eql` as the key equality predicate, and `a` as the allocator.
zh_Hans: 构造一个至少包含n个桶的空表，使用hf作为哈希函数、eql作为键相等谓词、a作为分配器。

[ctx: :473]
en: Postconditions:;; `size() == 0` Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 后置条件：size() == 0
    要求：若使用默认参数，则hasher、key_equal和allocator_type必须满足https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。

en: Iterator Range Constructor
zh_Hans: 迭代器范围构造函数

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `eql` as the key equality predicate and `a` as the allocator, and inserts the elements from `[f, l)` into it.
zh_Hans: 构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并将 `[f, l)` 范围内的元素插入其中。

[ctx: :492]
en: Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en: Copy Constructor
zh_Hans: 复制构造函数

en: ```c++ concurrent_flat_map(concurrent_flat_map const& other); ```
zh_Hans: ```c++ concurrent_flat_map(concurrent_flat_map const&amp; other); ```

en: The copy constructor. Copies the contained elements, hash function, predicate and allocator.
zh_Hans: 拷贝构造函数。复制容器内的元素、哈希函数、谓词以及分配器。

en: If `Allocator::select_on_container_copy_construction` exists and has the right signature, the allocator will be constructed from its result.
zh_Hans: 若Allocator::select_on_container_copy_construction存在且签名正确，则分配器将根据其返回值构造。

en: Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on `other`.
zh_Hans: 要求：value_type 支持复制构造。 并发特性：阻塞于 other

en: Move Constructor
zh_Hans: 移动构造函数

en: ```c++ concurrent_flat_map(concurrent_flat_map&& other); ```
zh_Hans: ```c++ concurrent_flat_map(concurrent_flat_map&amp;&amp; other); ```

en: The move constructor. The internal bucket array of `other` is transferred directly to the new table. The hash function, predicate and allocator are moved-constructed from `other`. If statistics are xref:concurrent_flat_map_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` and calls `other.reset_stats()`.
zh_Hans: 移动构造函数。other 的内部桶数组会直接转移到新表中。哈希函数、谓词和分配器均从 other 移动构造而来。如果启用了 xref:concurrent_flat_map_boost_unordered_enable_stats [统计功能]，则从 other 转移内部统计信息，并调用 other.reset_stats()。

[ctx: :522]
en: Concurrency:;; Blocking on `other`.
zh_Hans: 并发特性：阻塞于 other

en: Iterator Range Constructor with Allocator
zh_Hans: 带分配器的迭代器范围构造函数

en: ```c++ template<class InputIterator> concurrent_flat_map(InputIterator f, InputIterator l, const allocator_type& a); ```
zh_Hans: ```c++ template<class inputiterator=""> concurrent_flat_map(InputIterator f, InputIterator l, const allocator_type&amp; a); ```</class>

en: Constructs an empty table using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
zh_Hans: 以a作为分配器，使用默认哈希函数与键相等谓词构造空表，并将[f, l)范围内的元素插入其中。

[ctx: :535]
en: Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求：hasher、key_equal 必须满足https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。

en: Allocator Constructor
zh_Hans: 分配器构造函数

en: ```c++ explicit concurrent_flat_map(Allocator const& a); ```
zh_Hans: ```c++ explicit concurrent_flat_map(Allocator const&amp; a); ```

en: Constructs an empty table, using allocator `a`.
zh_Hans: 使用分配器a构造一个空表。

en: Copy Constructor with Allocator
zh_Hans: 带分配器的复制构造函数

en: ```c++ concurrent_flat_map(concurrent_flat_map const& other, Allocator const& a); ```
zh_Hans: ```c++ concurrent_flat_map(concurrent_flat_map const&amp; other, Allocator const&amp; a); ```

en: Constructs a table, copying ``other``'s contained elements, hash function, and predicate, but using allocator `a`.
zh_Hans: 构造一个表，复制other的容器元素、哈希函数和谓词，但使用分配器a。

[ctx: :556]
en: Concurrency:;; Blocking on `other`.
zh_Hans: 并发特性：阻塞于 other

en: Move Constructor with Allocator
zh_Hans: 带分配器的移动构造函数

en: ```c++ concurrent_flat_map(concurrent_flat_map&& other, Allocator const& a); ```
zh_Hans: ```c++ concurrent_flat_map(concurrent_flat_map&amp;&amp; other, Allocator const&amp; a); ```

en: If `a == other.get_allocator()`, the elements of `other` are transferred directly to the new table; otherwise, elements are moved-constructed from those of `other`. The hash function and predicate are moved-constructed from `other`, and the allocator is copy-constructed from `a`. If statistics are xref:concurrent_flat_map_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff `a == other.get_allocator()`, and always calls `other.reset_stats()`.
zh_Hans: 若a == other.get_allocator()，则other的元素会直接转移到新表中；否则，元素从other移动构造而来。
    哈希函数与谓词从other移动构造，分配器从a拷贝构造。
    如果启用了 xref:concurrent_flat_map_boost_unordered_enable_stats [统计功能]：
    当且仅当a == other.get_allocator()时，从other转移内部统计信息
    始终调用other.reset_stats()

[ctx: :573]
en: Concurrency:;; Blocking on `other`.
zh_Hans: 并发特性：阻塞于 other

en: Move Constructor from unordered_flat_map
zh_Hans: 从 unordered_flat_map 的移动构造函数

en: ```c++ concurrent_flat_map(unordered_flat_map<Key, T, Hash, Pred, Allocator>&& other); ```
zh_Hans: ```c++ concurrent_flat_map(unordered_flat_map<key, t,="" hash,="" pred,="" allocator="">&amp;&amp; other); ```</key,>

en: Move construction from a xref:#unordered_flat_map[`unordered_flat_map`]. The internal bucket array of `other` is transferred directly to the new container. The hash function, predicate and allocator are moved-constructed from `other`. If statistics are xref:concurrent_flat_map_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` and calls `other.reset_stats()`.
zh_Hans: 从 xref:#unordered_flat_map [unordered_flat_map] 进行移动构造。other的内部桶数组会直接转移到新容器中。哈希函数、谓词和分配器均从other移动构造而来。如果启用了 xref:concurrent_flat_map_boost_unordered_enable_stats [统计功能]，则从other转移内部统计信息，并调用other.reset_stats()。

en: Complexity:;; O(`bucket_count()`)
zh_Hans: 复杂度：O (`bucket_count()`)

en: Initializer List Constructor
zh_Hans: 初始化列表构造函数

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `eql` as the key equality predicate and `a`, and inserts the elements from `il` into it.
zh_Hans: 构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等性谓词、 `a` 作为分配器，并 `il` 中的元素插入其中。

[ctx: :607]
en: Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en: Bucket Count Constructor with Allocator
zh_Hans: 带分配器的桶数构造函数

en: ```c++ concurrent_flat_map(size_type n, allocator_type const& a); ```
zh_Hans: ```c++ concurrent_flat_map(size_type n, allocator_type const&amp; a); ```

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, the default hash function and key equality predicate and `a` as the allocator.
zh_Hans: 构造一个至少包含 n 个桶的空表，使用 hf 作为哈希函数、默认的键相等谓词，并以 a 作为分配器。

en: Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 后置条件：size() == 0
    要求：hasher 和 key_equal 必须满足https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。

en: Bucket Count Constructor with Hasher and Allocator
zh_Hans: 带哈希函数和分配器的桶数构造函数

en: ```c++ concurrent_flat_map(size_type n, hasher const& hf, allocator_type const& a); ```
zh_Hans: ```c++ concurrent_flat_map(size_type n, hasher const&amp; hf, allocator_type const&amp; a); ```

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, the default key equality predicate and `a` as the allocator.
zh_Hans: 构造一个至少包含 n 个桶的空表，使用 hf 作为哈希函数、默认键相等谓词，并以 a 作为分配器。

en: Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 后置条件：size() == 0
    要求：key_equal 必须满足https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]。

en: Iterator Range Constructor with Bucket Count and Allocator
zh_Hans: 带桶数和分配器的迭代器范围构造函数

en: Constructs an empty table with at least `n` buckets, using `a` as the allocator and default hash function and key equality predicate, and inserts the elements from `[f, l)` into it.
zh_Hans: 构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器以及默认的哈希函数和键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。

[ctx: :647]
en: Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求;; `hasher` 和 `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en: Iterator Range Constructor with Bucket Count and Hasher
zh_Hans: 带桶数和哈希函数的迭代器范围构造函数

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `a` as the allocator, with the default key equality predicate, and inserts the elements from `[f, l)` into it.
zh_Hans: 构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器以及默认的键相等性谓词，并将 `[f, l)` 范围内的元素插入其中。

[ctx: :662]
en: Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求;; `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求。

en: initializer_list Constructor with Allocator
zh_Hans: 带分配器的初始化列表构造函数

en: ```c++ concurrent_flat_map(std::initializer_list<value_type> il, const allocator_type& a); ```
zh_Hans: ```c++ concurrent_flat_map(std::initializer_list<value_type> il, const allocator_type&amp; a); ```</value_type>

en: Constructs an empty table using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
zh_Hans: 使用分配器a以及默认哈希函数、键相等谓词构造空表，并将il中的元素插入表中。

[ctx: :675]
en: Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。

en: initializer_list Constructor with Bucket Count and Allocator
zh_Hans: 带桶数和分配器的初始化列表构造函数

en: ```c++ concurrent_flat_map(std::initializer_list<value_type> il, size_type n, const allocator_type& a); ```
zh_Hans: ```c++ concurrent_flat_map(std::initializer_list<value_type> il, size_type n, const allocator_type&amp; a); ```</value_type>

en: Constructs an empty table with at least `n` buckets, using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
zh_Hans: 构造一个至少包含 n 个桶的空表，使用分配器 a 以及默认哈希函数、键相等谓词，并将 il 中的元素插入表中。

[ctx: :688]
en: Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。

en: initializer_list Constructor with Bucket Count and Hasher and Allocator
zh_Hans: 带桶数、哈希函数和分配器的初始化列表构造函数

en: ```c++ concurrent_flat_map(std::initializer_list<value_type> il, size_type n, const hasher& hf, const allocator_type& a); ```
zh_Hans: ```c++ concurrent_flat_map(std::initializer_list<value_type> il, size_type n, const hasher&amp; hf, const allocator_type&amp; a); ```</value_type>

en: Constructs an empty table with at least `n` buckets, using `hf` as the hash function, `a` as the allocator and default key equality predicate,and inserts the elements from `il` into it.
zh_Hans: 构造一个至少包含 n 个桶的空表，使用 hf 作为哈希函数、a 作为分配器、默认键相等谓词，并将 il 中的元素插入表中。

[ctx: :702]
en: Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
zh_Hans: 要求：key_equal 须满足https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。

en: Destructor
zh_Hans: 析构函数

en: ```c++ ~concurrent_flat_map(); ```
zh_Hans: ```c++

en: Note:;; The destructor is applied to every element, and all memory is deallocated
zh_Hans: 备注：析构函数会作用于所有元素，且所有内存都会被释放。

en: Assignment
zh_Hans: 赋值操作

en: Copy Assignment
zh_Hans: 复制赋值

en: ```c++ concurrent_flat_map& operator=(concurrent_flat_map const& other); ```
zh_Hans: ```c++ concurrent_flat_map&amp; operator=(concurrent_flat_map const&amp; other); ```

en: The assignment operator. Destroys previously existing elements, copy-assigns the hash function and predicate from `other`, copy-assigns the allocator from `other` if `Alloc::propagate_on_container_copy_assignment` exists and `Alloc::propagate_on_container_copy_assignment::value` is `true`, and finally inserts copies of the elements of `other`.
zh_Hans: 赋值运算符。销毁原有的所有元素，从other复制赋值哈希函数与谓词；若Alloc::propagate_on_container_copy_assignment存在且其值为true，则从other复制赋值分配器；最终插入other元素的副本。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this` and `other`.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。并发：阻塞 `*this` 和 `other`。

en: Move Assignment
zh_Hans: 移动赋值

en: ```c++ concurrent_flat_map& operator=(concurrent_flat_map&& other) noexcept((boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) && std::is_same<pointer, value_type*>::value); ``` The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`, and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`. If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to `*this`; otherwise, inserts move-constructed copies of the elements of `other`. If statistics are xref:concurrent_flat_map_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff the final allocator is equal to `other.get_allocator()`, and always calls `other.reset_stats()`.
zh_Hans: ```c++ concurrent_flat_map&amp; operator=(concurrent_flat_map&amp;&amp; other) noexcept((boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_move_assignment::value) &amp;&amp; std::is_same<pointer, value_type*="">::value); ``` 
    移动赋值运算符。销毁当前容器原有的所有元素，交换other的哈希函数与谓词；若Alloc::propagate_on_container_move_assignment存在且其值为true，则从other移动赋值分配器。
    若此时分配器与other.get_allocator()相等，则直接转移other的内部桶数组至当前容器；否则，插入other元素的移动构造副本。
    如果启用了统计功能：
    当且仅当最终分配器与other.get_allocator()相等时，从other转移内部统计信息
    始终调用other.reset_stats()</pointer,></allocator></allocator>

en: Concurrency:;; Blocking on `*this` and `other`.
zh_Hans: 并发：阻塞于 *this 和 other。

en: Initializer List Assignment
zh_Hans: 初始化列表赋值

en: ```c++ concurrent_flat_map& operator=(std::initializer_list<value_type> il); ```
zh_Hans: ```c++ concurrent_flat_map&amp; operator=(std::initializer_list<value_type> il); ```</value_type>

en: Assign from values in initializer list. All previously existing elements are destroyed.
zh_Hans: 并发：阻塞于 *this 和 other。
    从初始化列表赋值。销毁所有先前存在的元素。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this`.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。并发：阻塞 `*this`。

en: Visitation
zh_Hans: 访问操作

en: ```c++ template<class F> size_t visit(const key_type& k, F f); template<class F> size_t visit(const key_type& k, F f) const; template<class F> size_t cvisit(const key_type& k, F f) const; template<class K, class F> size_t visit(const K& k, F f); template<class K, class F> size_t visit(const K& k, F f) const; template<class K, class F> size_t cvisit(const K& k, F f) const; ```
zh_Hans: ```c++ template<class f=""> size_t visit(const key_type&amp; k, F f); template<class f=""> size_t visit(const key_type&amp; k, F f) const; template<class f=""> size_t cvisit(const key_type&amp; k, F f) const; template<class k,="" class="" f=""> size_t visit(const K&amp; k, F f); template<class k,="" class="" f=""> size_t visit(const K&amp; k, F f) const; template<class k,="" class="" f=""> size_t cvisit(const K&amp; k, F f) const; ```</class></class></class></class></class></class>

en: If an element `x` exists with key equivalent to `k`, invokes `f` with a reference to `x`. Such reference is const iff `*this` is const.
zh_Hans: 若存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。
    当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。

en: Returns:;; The number of elements visited (0 or 1). Notes:;; The `template<class K, class F>` overloads only participate 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.
zh_Hans: 返回值：访问过的元素数量（0 或 1）。
    注意：template<class k,="" class="" f=""> 形式的重载仅在 Hash::is_transparent 与 Pred::is_transparent 为合法成员别名时才参与重载决议。
    库假定 Hash 可同时用于 K 类型与 Key 类型，且 Pred 是透明的。
    这支持异构查找，避免了实例化 Key 类型对象带来的开销。</class>

en: Bulk visit
zh_Hans: 批量访问

en: ```c++ template<class FwdIterator, class F> size_t visit(FwdIterator first, FwdIterator last, F f); template<class FwdIterator, class F> size_t visit(FwdIterator first, FwdIterator last, F f) const; template<class FwdIterator, class F> size_t cvisit(FwdIterator first, FwdIterator last, F f) const; ```
zh_Hans: ```c++ template<class fwditerator,="" class="" f=""> size_t visit(FwdIterator first, FwdIterator last, F f); template<class fwditerator,="" class="" f=""> size_t visit(FwdIterator first, FwdIterator last, F f) const; template<class fwditerator,="" class="" f=""> size_t cvisit(FwdIterator first, FwdIterator last, F f) const; ```</class></class></class>

en: For each element `k` in the range [`first`, `last`), if there is an element `x` in the container with key equivalent to `k`, invokes `f` with a reference to `x`. Such reference is const iff `*this` is const.
zh_Hans: 对范围 [first, last) 中的每个键 k：
    如果容器中存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。
    当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。

en: Although functionally equivalent to individually invoking xref:concurrent_flat_map_cvisit[`[c\]visit`] for each key, bulk visitation performs generally faster due to internal streamlining optimizations. It is advisable that `std::distance(first,last)` be at least xref:#concurrent_flat_map_constants[`bulk_visit_size`] to enjoy a performance gain: beyond this size, performance is not expected to increase further.
zh_Hans: 尽管功能上等价于对每个键单独调用 [c]visit，但批量访问因内部流线型优化，通常性能更高。
    建议 std::distance(first,last) 至少达到 bulk_visit_size 阈值时再使用，以获得性能提升；超过该大小后，性能不会进一步提升。

en: Requires:;; `FwdIterator` is a https://en.cppreference.com/w/cpp/named_req/ForwardIterator[LegacyForwardIterator^] ({cpp}11 to {cpp}17), or satisfies https://en.cppreference.com/w/cpp/iterator/forward_iterator[std::forward_iterator^] ({cpp}20 and later). For `K` = `std::iterator_traits<FwdIterator>::value_type`, either `K` is `key_type` or else `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. In the latter case, 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. Returns:;; The number of elements visited.
zh_Hans: 要求：`FwdIterator` 需满足 https://en.cppreference.com/w/cpp/named_req/ForwardIterator[遗留向前迭代器^] 要求（{cpp}11 至 {cpp}17），或满足 https://en.cppreference.com/w/cpp/iterator/forward_iterator[`std::forward_iterator`^] 要求（{cpp}20 及更高版本）。对于 `K = std::iterator_traits<fwditerator>::value_type`，要么 `K` 是 `key_type`，要么 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef。在后一种情况下，库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实例化 `Key` 类型的开销。返回：被访问的元素数量。</fwditerator>

en: ```c++ template<class F> size_t visit_all(F f); template<class F> size_t visit_all(F f) const; template<class F> size_t cvisit_all(F f) const; ```
zh_Hans: ```c++ template<class f=""> size_t visit_all(F f); template<class f=""> size_t visit_all(F f) const; template<class f=""> size_t cvisit_all(F f) const; ```</class></class></class>

en: Successively invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const.
zh_Hans: 依次以表中每个元素的引用调用函数 f。
    当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。

en: Returns:;; The number of elements visited.
zh_Hans: 返回值：访问到的元素数量。

en: Parallel [c]visit_all
zh_Hans: 并行  [c]visit_all

en: ```c++ template<class ExecutionPolicy, class F> void visit_all(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> void visit_all(ExecutionPolicy&& policy, F f) const; template<class ExecutionPolicy, class F> void cvisit_all(ExecutionPolicy&& policy, F f) const; ```
zh_Hans: ```c++ template<class executionpolicy,="" class="" f=""> void visit_all(ExecutionPolicy&amp;&amp; policy, F f); template<class executionpolicy,="" class="" f=""> void visit_all(ExecutionPolicy&amp;&amp; policy, F f) const; template<class executionpolicy,="" class="" f=""> void cvisit_all(ExecutionPolicy&amp;&amp; policy, F f) const; ```</class></class></class>

en: Invokes `f` with references to each of the elements in the table. Such references are const iff `*this` is const. Execution is parallelized according to the semantics of the execution policy specified.
zh_Hans: 以表中每个元素的引用调用函数 f。
    当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。
    执行过程将根据指定的执行策略语义进行并行化。

en: 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. + + These overloads only participate in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `true`. + + Unsequenced execution policies are not allowed.
zh_Hans: 抛出异常：根据所使用执行策略的异常处理机制，如果 f 内部抛出异常，则可能会调用 std::terminate。
    注意：仅在支持 C++17 并行算法的编译器中可用。
    仅当 std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt; 为 true 时，这些重载版本才参与重载决议。
    不允许使用无序执行策略。</std::remove_cvref_t<executionpolicy>

en: ```c++ template<class F> bool visit_while(F f); template<class F> bool visit_while(F f) const; template<class F> bool cvisit_while(F f) const; ```
zh_Hans: ```c++ template<class f=""> bool visit_while(F f); template<class f=""> bool visit_while(F f) const; template<class f=""> bool cvisit_while(F f) const; ```</class></class></class>

en: Successively invokes `f` with references to each of the elements in the table until `f` returns `false` or all the elements are visited. Such references to the elements are const iff `*this` is const.
zh_Hans: 依次以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。
    当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。

en: Returns:;; `false` iff `f` ever returns `false`.
zh_Hans: 返回值：当且仅当 f 曾返回 false 时，整体返回 false。

en: Parallel [c]visit_while
zh_Hans: 并行  [c]visit_while

en: ```c++ template<class ExecutionPolicy, class F> bool visit_while(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> bool visit_while(ExecutionPolicy&& policy, F f) const; template<class ExecutionPolicy, class F> bool cvisit_while(ExecutionPolicy&& policy, F f) const; ```
zh_Hans: ```c++ template<class executionpolicy,="" class="" f=""> bool visit_while(ExecutionPolicy&amp;&amp; policy, F f); template<class executionpolicy,="" class="" f=""> bool visit_while(ExecutionPolicy&amp;&amp; policy, F f) const; template<class executionpolicy,="" class="" f=""> bool cvisit_while(ExecutionPolicy&amp;&amp; policy, F f) const; ```</class></class></class>

en: Invokes `f` with references to each of the elements in the table until `f` returns `false` or all the elements are visited. Such references to the elements are const iff `*this` is const. Execution is parallelized according to the semantics of the execution policy specified.
zh_Hans: 以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。
    当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。
    执行过程将根据指定的执行策略语义进行并行化。

en: Returns:;; `false` iff `f` ever returns `false`. 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. + + These overloads only participate in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `true`. + + Unsequenced execution policies are not allowed. + + Parallelization implies that execution does not necessary finish as soon as `f` returns `false`, and as a result `f` may be invoked with further elements for which the return value is also `false`.
zh_Hans: 返回值：当且仅当 f 曾返回 false 时，整体返回 false。
    抛出异常：根据所使用执行策略的异常处理机制，如果 f 内部抛出异常，则可能会调用 std::terminate。
    注意：
    仅在支持 C++17 并行算法的编译器中可用。
    仅当 std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt; 为 true 时，这些重载版本才参与重载决议。
    不允许使用无序执行策略。
    并行化意味着：即使 f 已返回 false，执行流程也不一定会立即终止；因此，f 可能还会被继续调用以处理后续元素，且这些调用同样可能返回 false。</std::remove_cvref_t<executionpolicy>

en: Size and Capacity
zh_Hans: 大小与容量

en: empty
zh_Hans: 空

en: Returns:;; `size() == 0`
zh_Hans: 返回值：size() == 0

en: size
zh_Hans: 大小

en: Returns:;; The number of elements in the table.
zh_Hans: 返回值：表中的元素数量。

en: Notes:;; In the presence of concurrent insertion operations, the value returned may not accurately reflect the true size of the table right after execution.
zh_Hans: 注意：在存在并发插入操作时，返回的值可能无法准确反映函数执行后容器的真实大小。

en: Returns:;; `size()` of the largest possible table.
zh_Hans: 返回值：容器所能容纳的最大元素数量（最大容量）。

en: Modifiers
zh_Hans: 修改器

en: emplace
zh_Hans: 原地构造

en: ```c++ template<class... Args> bool emplace(Args&&... args); ```
zh_Hans: ```c++ template<class... args=""> bool emplace(Args&amp;&amp;... args); ```</class...>

en: Inserts an object, constructed with the arguments `args`, in the table if and only if there is no element in the table with an equivalent key.
zh_Hans: 当且仅当容器中不存在等价键的元素时，才会使用参数 args 构造对象并插入到容器中。

en: Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + If `args...` is of the form `k,v`, it delays constructing the whole object until it is certain that an element should be inserted, using only the `k` argument to check.
zh_Hans: 要求：`value_type` 可从 `args` 构造。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +若 `args...` 的形式为 `k,v`，则仅在确定应插入元素时才构造整个对象，检查时仅使用 `k` 参数。

en: Copy Insert
zh_Hans: 复制插入

en: ```c++ bool insert(const value_type& obj); bool insert(const init_type& obj); ```
zh_Hans: ```c++ bool insert(const value_type&amp; obj); bool insert(const init_type&amp; obj); ```

[ctx: :971]
en: Inserts `obj` in the table if and only if there is no element in the table with an equivalent key.
zh_Hans: 当且仅当容器中不存在等价键的元素时，才将对象 obj 插入到容器中。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + A call of the form `insert(x)`, where `x` is equally convertible to both `const value_type&` and `const init_type&`, is not ambiguous and selects the `init_type` overload.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +形式为 `insert(x)` 的调用（其中 `x` 可同等转换为 `const value_type&amp;` 和 `const init_type&amp;`）不会产生歧义，并且会选择 `init_type` 重载。

en: Move Insert
zh_Hans: 移动插入

en: ```c++ bool insert(value_type&& obj); bool insert(init_type&& obj); ```
zh_Hans: ```c++ bool insert(value_type&amp;&amp; obj); bool insert(init_type&amp;&amp; obj); ```

[ctx: :989]
en: Inserts `obj` in the table if and only if there is no element in the table with an equivalent key.
zh_Hans: 当且仅当容器中无等价键的元素时，将对象 obj 插入容器。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + A call of the form `insert(x)`, where `x` is equally convertible to both `value_type&&` and `init_type&&`, is not ambiguous and selects the `init_type` overload.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +形式为 `insert(x)` 的调用（其中 `x` 可同等转换为 `value_type&amp;&amp;` 和 `init_type&amp;&amp;`）不会产生歧义，并且会选择 `init_type` 重载。

en: Insert Iterator Range
zh_Hans: 迭代器范围插入

en: ```c++ template<class InputIterator> size_type insert(InputIterator first, InputIterator last); ```
zh_Hans: ```c++ template<class inputiterator=""> size_type insert(InputIterator first, InputIterator last); ```</class>

[ctx: :1006]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等效于 [listing,subs="+macros,+quotes"]

[ctx: :1013]
en: Returns:;; The number of elements inserted.
zh_Hans: 返回值：成功插入的元素数量。

en: Insert Initializer List
zh_Hans: 初始化列表插入

en: ```c++ size_type insert(std::initializer_list<value_type> il); ```
zh_Hans: ```c++ size_type insert(std::initializer_list<value_type> il); ```</value_type>

[ctx: :1022]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等效于 [listing,subs="+macros,+quotes"]

[ctx: :1029]
en: Returns:;; The number of elements inserted.
zh_Hans: 返回值：插入的元素个数。

en: ```c++ template<class... Args, class F> bool emplace_or_visit(Args&&... args, F&& f); template<class... Args, class F> bool emplace_or_cvisit(Args&&... args, F&& f); ```
zh_Hans: ```c++ template<class... args,="" class="" f=""> bool emplace_or_visit(Args&amp;&amp;... args, F&amp;&amp; f); template<class... args,="" class="" f=""> bool emplace_or_cvisit(Args&amp;&amp;... args, F&amp;&amp; f); ```</class...></class...>

en: Inserts an object, constructed with the arguments `args`, in the table if there is no element in the table with an equivalent key. Otherwise, invokes `f` with a reference to the equivalent element; such reference is const iff `emplace_or_cvisit` is used.
zh_Hans: 若容器中无等价键的元素，则使用参数 args 构造对象并插入容器；
    否则，将等价元素的引用传递给函数 f 并调用 —— 若使用的是 emplace_or_cvisit，则该引用为常量引用。

en: Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + The interface is exposition only, as C++ does not allow to declare a parameter `f` after a variadic parameter pack.
zh_Hans: 要求：`value_type` 可从 `args` 构造。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +该接口仅为展示说明，因为 C++ 不允许在变参参数包之后声明参数 `f`。

en: ```c++ template<class F> bool insert_or_visit(const value_type& obj, F f); template<class F> bool insert_or_cvisit(const value_type& obj, F f); template<class F> bool insert_or_visit(const init_type& obj, F f); template<class F> bool insert_or_cvisit(const init_type& obj, F f); ```
zh_Hans: ```c++ template<class f=""> bool insert_or_visit(const value_type&amp; obj, F f); template<class f=""> bool insert_or_cvisit(const value_type&amp; obj, F f); template<class f=""> bool insert_or_visit(const init_type&amp; obj, F f); template<class f=""> bool insert_or_cvisit(const init_type&amp; obj, F f); ```</class></class></class></class>

[ctx: :1060]
en: Inserts `obj` in the table if and only if there is no element in the table with an equivalent key. Otherwise, invokes `f` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
zh_Hans: 当且仅当容器中不存在等价键的元素时，将对象 obj 插入容器；
    否则，将等价元素的引用传入函数 f 并调用 ——若使用的是 *_cvisit 重载版本，该引用为常量引用。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + In a call of the form `insert_or_[c]visit(obj, f)`, the overloads accepting a `const value_type&` argument participate in overload resolution only if `std::remove_cv<std::remove_reference<decltype(obj)>::type>::type` is `value_type`.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +在形式为 `insert_or_[c]visit(obj, f)` 的调用中，接受 `const value_type&amp;` 参数的重载仅当 `std::remove_cv<std::remove_reference<decltype(obj)>::type&gt;::type` 为 `value_type` 时才参与重载决议。</std::remove_reference<decltype(obj)>

en: ```c++ template<class F> bool insert_or_visit(value_type&& obj, F f); template<class F> bool insert_or_cvisit(value_type&& obj, F f); template<class F> bool insert_or_visit(init_type&& obj, F f); template<class F> bool insert_or_cvisit(init_type&& obj, F f); ```
zh_Hans: ```c++ template<class f=""> bool insert_or_visit(value_type&amp;&amp; obj, F f); template<class f=""> bool insert_or_cvisit(value_type&amp;&amp; obj, F f); template<class f=""> bool insert_or_visit(init_type&amp;&amp; obj, F f); template<class f=""> bool insert_or_cvisit(init_type&amp;&amp; obj, F f); ```</class></class></class></class>

[ctx: :1082]
en: Inserts `obj` in the table if and only if there is no element in the table with an equivalent key. Otherwise, invokes `f` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
zh_Hans: 当且仅当容器中无等价键的元素时，插入对象 obj；
    否则，以等价元素的引用调用函数 f ——若使用 *_cvisit 重载版本，该引用为常量引用。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + In a call of the form `insert_or_[c]visit(obj, f)`, the overloads accepting a `value_type&&` argument participate in overload resolution only if `std::remove_reference<decltype(obj)>::type` is `value_type`.
zh_Hans: 要求：value_type 满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 要求。
    返回值：插入成功则返回 true。
    并发：在当前对象 *this 执行重哈希期间阻塞。
    说明：触发重哈希时，会使指向元素的指针和引用失效。
    调用形式为 insert_or_[c]visit(obj, f) 时，仅当 std::remove_reference<decltype(obj)>::type 类型为 value_type，接收 value_type&amp;&amp; 参数的重载函数才会参与重载决议。</decltype(obj)>

en: Insert Iterator Range or Visit
zh_Hans: 迭代器范围插入或访问

en: ```c++ template<class InputIterator,class F> size_type insert_or_visit(InputIterator first, InputIterator last, F f); template<class InputIterator,class F> size_type insert_or_cvisit(InputIterator first, InputIterator last, F f); ```
zh_Hans: ```c++ template<class inputiterator,class="" f=""> size_type insert_or_visit(InputIterator first, InputIterator last, F f); template<class inputiterator,class="" f=""> size_type insert_or_cvisit(InputIterator first, InputIterator last, F f); ```</class></class>

[ctx: :1104]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等效于 [listing,subs="+macros,+quotes"]

[ctx: :1111]
en: Returns:;; The number of elements inserted.
zh_Hans: 返回值：插入的元素数量。

en: Insert Initializer List or Visit
zh_Hans: 初始化列表插入或访问

en: ```c++ template<class F> size_type insert_or_visit(std::initializer_list<value_type> il, F f); template<class F> size_type insert_or_cvisit(std::initializer_list<value_type> il, F f); ```
zh_Hans: ```c++ template<class f=""> size_type insert_or_visit(std::initializer_list<value_type> il, F f); template<class f=""> size_type insert_or_cvisit(std::initializer_list<value_type> il, F f); ```</value_type></class></value_type></class>

[ctx: :1121]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等效于 [listing,subs="+macros,+quotes"]

[ctx: :1128]
en: Returns:;; The number of elements inserted.
zh_Hans: 返回值：插入的元素个数。

en: ```c++ template<class... Args, class F1, class F2> bool emplace_and_visit(Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool emplace_and_cvisit(Args&&... args, F1&& f1, F2&& f2); ```
zh_Hans: ```c++ template<class... args,="" class="" f1,="" f2=""> bool emplace_and_visit(Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class... args,="" class="" f1,="" f2=""> bool emplace_and_cvisit(Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); ```</class...></class...>

en: Inserts an object, constructed with the arguments `args`, in the table if there is no element in the table with an equivalent key, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff `emplace_and_cvisit` is used.
zh_Hans: 若容器中无等价键的元素，则使用参数args构造对象并插入容器，随后以新创建元素的非常量引用调用f1；
    否则，以等价元素的引用调用f2；若使用emplace_and_cvisit，则该引用为常量引用。

en: Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + The interface is exposition only, as C++ does not allow to declare parameters `f1` and `f2` after a variadic parameter pack.
zh_Hans: 要求：`value_type` 可从 `args` 构造。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +该接口仅为展示说明，因为 C++ 不允许在变参参数包之后声明参数 `f1` 和 `f2`。

en: Copy insert_and_[c]visit
zh_Hans: 复制  insert_and_[c]visit

en: ```c++ template<class F1, class F2> bool insert_and_visit(const value_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(const value_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_visit(const init_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(const init_type& obj, F1 f1, F2 f2); ```
zh_Hans: ```c++ template<class f1,="" class="" f2=""> bool insert_and_visit(const value_type&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_cvisit(const value_type&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_visit(const init_type&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_cvisit(const init_type&amp; obj, F1 f1, F2 f2); ```</class></class></class></class>

[ctx: :1162]
en: Inserts `obj` in the table if and only if there is no element in the table with an equivalent key, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
zh_Hans: 当且仅当容器中不存在等价键的元素时，插入obj，随后以新创建元素的非常量引用调用f1；
    否则，以等价元素的引用调用f2；若使用*_cvisit重载版本，则该引用为常量引用。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + In a call of the form `insert_and_[c]visit(obj, f1, f2)`, the overloads accepting a `const value_type&` argument participate in overload resolution only if `std::remove_cv<std::remove_reference<decltype(obj)>::type>::type` is `value_type`.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/CopyInsertable[可复制插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +在形式为 `insert_and_[c]visit(obj, f1, f2)` 的调用中，接受 `const value_type&amp;` 参数的重载仅当 `std::remove_cv<std::remove_reference<decltype(obj)>::type&gt;::type` 为 `value_type` 时才参与重载决议。</std::remove_reference<decltype(obj)>

en: Move insert_and_[c]visit
zh_Hans: 移动 insert_and_[c]visit

en: ```c++ template<class F1, class F2> bool insert_and_visit(value_type&& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(value_type&& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_visit(init_type&& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(init_type&& obj, F1 f1, F2 f2); ```
zh_Hans: ```c++ template<class f1,="" class="" f2=""> bool insert_and_visit(value_type&amp;&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_cvisit(value_type&amp;&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_visit(init_type&amp;&amp; obj, F1 f1, F2 f2); template<class f1,="" class="" f2=""> bool insert_and_cvisit(init_type&amp;&amp; obj, F1 f1, F2 f2); ```</class></class></class></class>

[ctx: :1185]
en: Inserts `obj` in the table if and only if there is no element in the table with an equivalent key, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
zh_Hans: 当且仅当容器中不存在等价键的元素时，插入obj，随后以新创建元素的非常量引用调用f1；
    否则，以等价元素的引用调用f2；若使用*_cvisit重载版本，则该引用为常量引用。

en: Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + In a call of the form `insert_and_[c]visit(obj, f1, f2)`, the overloads accepting a `value_type&&` argument participate in overload resolution only if `std::remove_reference<decltype(obj)>::type` is `value_type`.
zh_Hans: 要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用会失效。+ +在形式为 `insert_and_[c]visit(obj, f1, f2)` 的调用中，接受 `value_type&amp;&amp;` 参数的重载仅当 `std::remove_reference<decltype(obj)>::type` 为 `value_type` 时才参与重载决议。</decltype(obj)>

en: Insert Iterator Range and Visit
zh_Hans: 迭代器范围插入并访问

en: ```c++ template<class InputIterator, class F1, class F2> size_type insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class InputIterator, class F1, class F2> size_type insert_or_cvisit(InputIterator first, InputIterator last, F1 f1, F2 f2); ```
zh_Hans: ```c++ template<class inputiterator,="" class="" f1,="" f2=""> size_type insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class inputiterator,="" class="" f1,="" f2=""> size_type insert_or_cvisit(InputIterator first, InputIterator last, F1 f1, F2 f2); ```</class></class>

[ctx: :1208]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等效于 [listing,subs="+macros,+quotes"]

[ctx: :1215]
en: Returns:;; The number of elements inserted.
zh_Hans: 返回值：插入的元素数量。

en: Insert Initializer List and Visit
zh_Hans: 初始化列表插入并访问

en: ```c++ template<class F1, class F2> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class F1, class F2> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ```
zh_Hans: ```c++ template<class f1,="" class="" f2=""> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class f1,="" class="" f2=""> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ```</value_type></class></value_type></class>

[ctx: :1227]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等效于 [listing,subs="+macros,+quotes"]

[ctx: :1234]
en: Returns:;; The number of elements inserted.
zh_Hans: 返回值：插入的元素数量。

en: ```c++ template<class... Args> bool try_emplace(const key_type& k, Args&&... args); template<class... Args> bool try_emplace(key_type&& k, Args&&... args); template<class K, class... Args> bool try_emplace(K&& k, Args&&... args); ```
zh_Hans: ```c++ template<class... args=""> bool try_emplace(const key_type&amp; k, Args&amp;&amp;... args); template<class... args=""> bool try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args); template<class k,="" class...="" args=""> bool try_emplace(K&amp;&amp; k, Args&amp;&amp;... args); ```</class></class...></class...>

en: Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it.
zh_Hans: 若容器中不存在键为k的元素，则将由k和args构造的元素插入容器。

en: Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; This function is similiar to xref:#concurrent_flat_map_emplace[emplace], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
zh_Hans: 返回值：插入成功则返回true。
    并发：对当前对象*this进行重哈希时阻塞。
    说明：该函数与 xref:#concurrent_flat_map_emplace [emplace] 类似，区别在于若存在等价键的元素，则不会构造value_type；否则，构造形式为：

[ctx: :1256]
en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>

[ctx: :1261]
en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>

en: unlike xref:#concurrent_flat_map_emplace[emplace], which simply forwards all arguments to ``value_type``'s constructor.
zh_Hans: 这与 xref:#concurrent_flat_map_emplace [emplace] 不同，后者仅将所有参数转发给value_type的构造函数。

en: The `template<class K, class\... Args>` 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.
zh_Hans: 若`Hash::is_transparent`与`Pred::is_transparent`为合法的成员类型别名，则`template<class k,="" args="">`重载版本才会参与重载决议。库假定`Hash`可同时接收`K`与`Key`类型参数调用，且`Pred`为透明比较器。该设计支持异构查找，避免了实例化`Key`类型对象的开销。</class>

en: ```c++ template<class... Args, class F> bool try_emplace_or_visit(const key_type& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_cvisit(const key_type& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_visit(key_type&& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_cvisit(key_type&& k, Args&&... args, F&& f); template<class K, class... Args, class F> bool try_emplace_or_visit(K&& k, Args&&... args, F&& f); template<class K, class... Args, class F> bool try_emplace_or_cvisit(K&& k, Args&&... args, F&& f); ```
zh_Hans: ```c++ template<class... args,="" class="" f=""> bool try_emplace_or_visit(const key_type&amp; k, Args&amp;&amp;... args, F&amp;&amp; f); template<class... args,="" class="" f=""> bool try_emplace_or_cvisit(const key_type&amp; k, Args&amp;&amp;... args, F&amp;&amp; f); template<class... args,="" class="" f=""> bool try_emplace_or_visit(key_type&amp;&amp; k, Args&amp;&amp;... args, F&amp;&amp; f); template<class... args,="" class="" f=""> bool try_emplace_or_cvisit(key_type&amp;&amp; k, Args&amp;&amp;... args, F&amp;&amp; f); template<class k,="" class...="" args,="" class="" f=""> bool try_emplace_or_visit(K&amp;&amp; k, Args&amp;&amp;... args, F&amp;&amp; f); template<class k,="" class...="" args,="" class="" f=""> bool try_emplace_or_cvisit(K&amp;&amp; k, Args&amp;&amp;... args, F&amp;&amp; f); ```</class></class></class...></class...></class...></class...>

en: Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it. Otherwise, invokes `f` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
zh_Hans: 若容器中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入容器。否则，以等价元素的引用调用`f`；若使用`*_cvisit`重载版本，则该引用为常量引用。

[ctx: :1296]
en: Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
zh_Hans: 返回值：插入成功则返回true。
    并发：对当前对象*this进行重哈希时阻塞。
    说明：若存在等价键的元素，则不会构造value_type；否则，构造形式为：

[ctx: :1304]
en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>

[ctx: :1309]
en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>

[ctx: :1314]
en: Invalidates pointers and references to elements if a rehashing is issued.
zh_Hans: 若执行重哈希操作，将使指向元素的指针和引用失效。

en: The interface is exposition only, as C++ does not allow to declare a parameter `f` after a variadic parameter pack.
zh_Hans: 该接口仅为说明性用途，因为C++不允许在可变参数包之后声明参数`f`。

en: The `template<class K, class\... Args, class F>` overloads only participate 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.
zh_Hans: 若`Hash::is_transparent`和`Pred::is_transparent`是有效的成员类型别名，则`template<class k,="" args,="" class="" f="">`重载版本才会参与重载决议。库假定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透明的。这支持异构查找，避免了实例化`Key`类型对象的开销。</class>

en: ```c++ template<class... Args, class F1, class F2> bool try_emplace_and_visit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool try_emplace_and_visit(K&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```
zh_Hans: ```c++ template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(const key_type&amp; k, Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(const key_type&amp; k, Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(key_type&amp;&amp; k, Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class... args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(key_type&amp;&amp; k, Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class k,="" class...="" args,="" class="" f1,="" f2=""> bool try_emplace_and_visit(K&amp;&amp; k, Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); template<class k,="" class...="" args,="" class="" f1,="" f2=""> bool try_emplace_and_cvisit(K&amp;&amp; k, Args&amp;&amp;... args, F1&amp;&amp; f1, F2&amp;&amp; f2); ```</class></class></class...></class...></class...></class...>

en: Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
zh_Hans: 若容器中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入容器，随后以新创建元素的非常量引用调用`f1`；
    否则，以等价元素的引用调用`f2`；若使用`*_cvisit`重载版本，则该引用为常量引用。

[ctx: :1345]
en: Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
zh_Hans: 返回值：插入成功则返回true。
    并发：对当前对象*this进行重哈希时阻塞。
    说明：若存在等价键的元素，则不会构造value_type；否则，构造形式为：

[ctx: :1353]
en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>

[ctx: :1358]
en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>

[ctx: :1363]
en: Invalidates pointers and references to elements if a rehashing is issued.
zh_Hans: 若执行重哈希操作，将使指向元素的指针和引用失效。

en: The interface is exposition only, as C++ does not allow to declare parameters `f1` and `f2` after a variadic parameter pack.
zh_Hans: 该接口仅为说明性用途，因为C++不允许在可变参数包之后声明`f1`和`f2`参数。

en: The `template<class K, class\... Args, class F1, class F2>` overloads only participate 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.
zh_Hans: 若`Hash::is_transparent`和`Pred::is_transparent`是有效的成员类型别名，则`template<class k,="" args,="" class="" f1,="" f2="">`重载版本才会参与重载决议。库假定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透明的。这支持异构查找，避免了实例化`Key`类型对象的开销。</class>

en: ```c++ template<class M> bool insert_or_assign(const key_type& k, M&& obj); template<class M> bool insert_or_assign(key_type&& k, M&& obj); template<class K, class M> bool insert_or_assign(K&& k, M&& obj); ```
zh_Hans: ```c++ template<class m=""> bool insert_or_assign(const key_type&amp; k, M&amp;&amp; obj); template<class m=""> bool insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj); template<class k,="" class="" m=""> bool insert_or_assign(K&amp;&amp; k, M&amp;&amp; obj); ```</class></class></class>

en: Inserts a new element into the table or updates an existing one by assigning to the contained value.
zh_Hans: 向容器插入新元素，或通过赋值给容器内已存值来更新现有元素。

en: If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
zh_Hans: 若容器中存在键为`k`的元素，则通过`std::forward<m>(obj)`赋值来更新该元素。</m>

en: If there is no such element, it is added to the table as: ```c++
zh_Hans: 若不存在该元素，则将其以如下形式添加到容器中：

en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>

en: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```
zh_Hans: value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>

en: Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + The `template<class K, class M>` 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.
zh_Hans: 返回值：插入成功时返回`true`。
    并发：执行重哈希操作时会阻塞当前对象`*this`。
    说明：若触发重哈希，将使指向元素的指针和引用失效。
    `template<class k,="" class="" m="">` 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别名时才参与重载决议。库假定`Hash`可同时接受`K`与`Key`类型参数调用，且`Pred`是透明的。这支持异构查找，避免了实例化`Key`类型对象的开销。</class>

en: erase
zh_Hans: 擦除

en: ```c++ size_type erase(const key_type& k); template<class K> size_type erase(const K& k); ```
zh_Hans: ```c++ size_type erase(const key_type&amp; k); template<class k=""> size_type erase(const K&amp; k); ```</class>

en: Erases the element with key equivalent to `k` if it exists.
zh_Hans: 若存在键等价于`k`的元素，则删除该元素。

en: Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. 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.
zh_Hans: 返回值：删除的元素数量（0 或 1）。
    异常：仅当哈希函数`hasher`或键比较函数`key_equal`抛出异常时才会抛出异常。
    说明：仅当`Hash::is_transparent`和`Pred::is_transparent`为有效的成员类型别名时，`template<class k="">`重载版本才参与重载决议。库假定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透明的。该设计支持异构查找，避免了实例化`Key`类型对象的开销。</class>

en: ```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); ```
zh_Hans: ```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>

en: Erases the element `x` with key equivalent to `k` if it exists and `f(x)` is `true`.
zh_Hans: 若存在键与 `k` 等价的元素 `x`，且 `f(x)` 返回 `true`，则删除该元素。

en: Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an exception if it is thrown by `hasher`, `key_equal` or `f`. Notes:;; `f` is passed a non-const reference to `x`. + + The `template<class K, class F>` overload only participates in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `false`. + + The `template<class K, class F>` 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.
zh_Hans: 返回值：删除的元素数量（0 或 1）。
    异常：仅当哈希函数`hasher`、键比较函数`key_equal`或函数`f`抛出异常时才会抛出异常。
    说明：`f`接收元素`x`的非常量引用。
    
    仅当`std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;`为`false`时，`template<class k,="" class="" f="">`重载版本才参与重载决议。
    
    仅当`Hash::is_transparent`和`Pred::is_transparent`为有效的成员类型别名时，`template<class k,="" class="" f="">`重载版本才参与重载决议。库假定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透明的。该设计支持异构查找，避免了实例化`Key`类型对象的开销。</class></class></std::remove_cvref_t<executionpolicy>

en: ```c++ template<class F> size_type erase_if(F f); ```
zh_Hans: ```c++ template<class f=""> size_type erase_if(F f); ```</class>

en: Successively invokes `f` with non-const references to each of the elements in the table, and erases those for which `f` returns `true`.
zh_Hans: 依次以非常量引用为参数，对容器中的每个元素调用`f`，并删除所有`f`返回`true`的元素。

en: Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `f`.
zh_Hans: 返回值：被删除的元素数量。
    异常：仅当函数 `f` 抛出异常时才会抛出异常。

en: Parallel erase_if
zh_Hans: 并行条件擦除

en: ```c++ template<class ExecutionPolicy, class  F> void erase_if(ExecutionPolicy&& policy, F f); ```
zh_Hans: ```c++ template<class executionpolicy,="" class="" f=""> void erase_if(ExecutionPolicy&amp;&amp; policy, F f); ```</class>

en: Invokes `f` with non-const references to each of the elements in the table, and erases those for which `f` returns `true`. Execution is parallelized according to the semantics of the execution policy specified.
zh_Hans: 依次以非常量引用为参数，对容器中的每个元素调用`f`，并删除所有`f`返回`true`的元素。执行过程将根据指定的执行策略语义进行并行化处理。

en: 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.
zh_Hans: 异常：根据所使用执行策略的异常处理机制，若`f`内部抛出异常，可能会调用`std::terminate`终止程序。
    说明：仅在支持C++17并行算法的编译器中可用。
    
    仅当`std::is_execution_policy_v<std::remove_cvref_t<executionpolicy>&gt;`为`true`时，该重载版本参与重载决议。
    
    不允许使用无顺序执行策略。</std::remove_cvref_t<executionpolicy>

en: swap
zh_Hans: 交换

en: ```c++ void swap(concurrent_flat_map& other) noexcept(boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```
zh_Hans: ```c++ void swap(concurrent_flat_map&amp; other) noexcept(boost::allocator_traits<allocator>::is_always_equal::value || boost::allocator_traits<allocator>::propagate_on_container_swap::value); ```</allocator></allocator>

en: Swaps the contents of the table with the parameter.
zh_Hans: 将当前容器的内容与参数容器进行交换。

en: If `Allocator::propagate_on_container_swap` is declared and `Allocator::propagate_on_container_swap::value` is `true` then the tables' allocators are swapped. Otherwise, swapping with unequal allocators results in undefined behavior.
zh_Hans: 若`Allocator::propagate_on_container_swap`已定义且其值为`true`，则交换两个容器的分配器；否则，使用不相等的分配器进行交换会导致未定义行为。

en: Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. Concurrency:;; Blocking on `*this` and `other`.
zh_Hans: 异常：除非`key_equal`或`hasher`在交换时抛出异常，否则不抛出任何异常。并发：会阻塞当前对象`*this`和参数对象`other`。

en: clear
zh_Hans: 清空

en: Erases all elements in the table.
zh_Hans: 清空容器中的所有元素。

en: Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * bucket_count()` Concurrency:;; Blocking on `*this`.
zh_Hans: 后置条件：容器大小 `size() == 0`，且 `max_load() &gt;= max_load_factor() * bucket_count()`
    并发：会阻塞当前对象 `*this`。

en: merge
zh_Hans: 合并

en: ```c++ template<class H2, class P2> size_type merge(concurrent_flat_map<Key, T, H2, P2, Allocator>& source); template<class H2, class P2> size_type merge(concurrent_flat_map<Key, T, H2, P2, Allocator>&& source); ```
zh_Hans: ```c++ template<class h2,="" class="" p2=""> size_type merge(concurrent_flat_map<key, t,="" h2,="" p2,="" allocator="">&amp; source); template<class h2,="" class="" p2=""> size_type merge(concurrent_flat_map<key, t,="" h2,="" p2,="" allocator="">&amp;&amp; source); ```</key,></class></key,></class>

en: Move-inserts all the elements from `source` whose key is not already present in `*this`, and erases them from `source`.
zh_Hans: 将来源容器`source`中所有**键不存在于当前容器`*this`**中的元素**移动插入**到当前容器，并从`source`中擦除这些元素。

en: Returns:;; The number of elements inserted. Concurrency:;; Blocking on `*this` and `source`.
zh_Hans: 返回值：插入的元素数量。
    并发：会阻塞当前对象 `*this` 和源对象 `source`。

en: Observers
zh_Hans: 观察器

en: Returns:;; The table's allocator.
zh_Hans: 返回值：容器的分配器。

en: hash_function
zh_Hans: 哈希函数

en: Returns:;; The table's hash function.
zh_Hans: 返回值：容器的哈希函数。

en: Returns:;; The table's key equality predicate.
zh_Hans: 返回值：容器的键相等性谓词。

en: Map Operations
zh_Hans: 映射操作

en: ```c++ size_type        count(const key_type& k) const; template<class K> size_type      count(const K& k) const; ```
zh_Hans: ```c++ size_type        count(const key_type&amp; k) const; template<class k=""> size_type      count(const K&amp; k) const; ```</class>

en: 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.
zh_Hans: 返回值：匹配键 `k` 的元素数量（0 或 1）。
    说明：仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别名时，`template<class k="">` 重载版本才参与重载决议。库假定哈希函数可同时作用于 `K` 类型与键类型，且相等谓词是透明的，从而支持异构查找，避免实例化键类型带来的开销。
    
    若存在并发插入操作，返回值可能无法精确反映容器执行后的真实状态。</class>

en: contains
zh_Hans: 包含

en: ```c++ bool             contains(const key_type& k) const; template<class K> bool           contains(const K& k) const; ```
zh_Hans: ```c++ bool             contains(const key_type&amp; k) const; template<class k=""> bool           contains(const K&amp; k) const; ```</class>

en: 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.
zh_Hans: 返回值：布尔值，表示容器中是否存在键等于 `k` 的元素。
    说明：仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别名时，`template<class k="">` 重载版本才参与重载决议。库假定哈希函数可同时作用于 `K` 类型与键类型，且相等谓词是透明的，从而支持异构查找，避免实例化键类型带来的开销。
    
    若存在并发插入操作，返回值可能无法精确反映容器执行后的真实状态。</class>

en: Bucket Interface
zh_Hans: 桶接口

en: Returns:;; The size of the bucket array.
zh_Hans: 返回值：桶数组的大小。

en: Hash Policy
zh_Hans: 哈希策略

en: load_factor
zh_Hans: 负载因子

en: Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, or `0` if `bucket_count() == 0`.
zh_Hans: 返回值：`static_cast<float>(size())/static_cast<float>(bucket_count())`；若 `bucket_count() == 0`，则返回 `0`。</float></float>

en: max_load_factor
zh_Hans: max_load_factor（最大负载因子）

en: Returns:;; Returns the table's maximum load factor.
zh_Hans: 返回值：容器的最大负载因子。

en: Set max_load_factor
zh_Hans: 设置最大负载因子

en: Effects:;; Does nothing, as the user is not allowed to change this parameter. Kept for compatibility with `boost::unordered_map`.
zh_Hans: 效果：无任何操作，用户不允许修改此参数。保留该函数是为了与 `boost::unordered_map` 保持兼容。

en: max_load
zh_Hans: max_load（最大负载）

en: 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.
zh_Hans: 返回值：容器在不进行重哈希的前提下可容纳的最大元素数量（假定不会再擦除任何元素）。
    说明：容器在构造、重哈希或清空后，其最大负载量至少为 `max_load_factor() * bucket_count()`。在高负载条件下执行擦除操作时，该数值可能会降低。
    若存在并发插入操作，返回值可能无法精确反映容器执行后的真实状态。

en: rehash
zh_Hans: 重哈希

en: Changes if necessary the size of the bucket array so that there are at least `n` buckets, and so that the load factor is less than or equal to the maximum load factor. When applicable, this will either grow or shrink the `bucket_count()` associated with the table.
zh_Hans: 效果：必要时调整桶数组的大小，使桶数量至少为 `n`，且负载因子小于等于最大负载因子。
    适用场景下，该操作会**增大或缩小**容器的桶数量 `bucket_count()`。

en: When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array.
zh_Hans: 当容器大小 `size() == 0` 时，调用 `rehash(0)` 会**释放底层的桶数组内存**。

[ctx: :1653]
en: Invalidates pointers and references to elements, and changes the order of elements.
zh_Hans: 会使指向元素的指针和引用失效，并改变元素的存储顺序。

en: Throws:;; The function has no effect if an exception is thrown, unless it is thrown by the table's hash function or comparison function. Concurrency:;; Blocking on `*this`. ---
zh_Hans: 异常：若抛出异常，函数无任何效果（由容器的哈希函数或比较函数抛出的异常除外）。
    并发：阻塞当前对象 `*this`。

en: reserve
zh_Hans: 保留

en: Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`.
zh_Hans: 等价于 `a.rehash(ceil(n / a.max_load_factor()))`。

en: Similar to `rehash`, this function can be used to grow or shrink the number of buckets in the table.
zh_Hans: 与 `rehash` 功能类似，该函数可用于**增大或缩小**容器的桶数量。

[ctx: :1669]
en: Invalidates pointers and references to elements, and changes the order of elements.
zh_Hans: 会使指向元素的指针和引用失效，并改变元素的存储顺序。

en: Throws:;; The function has no effect if an exception is thrown, unless it is thrown by the table's hash function or comparison function. Concurrency:;; Blocking on `*this`.
zh_Hans: 异常：若抛出异常，函数无任何效果（由容器的哈希函数或比较函数抛出的异常除外）。
    并发：阻塞当前对象 `*this`。

en: Statistics
zh_Hans: 统计信息

en: Returns:;; A statistical description of the insertion and lookup operations performed by the table so far. Notes:;; Only available if xref:reference/stats.adoc#stats[statistics calculation] is xref:concurrent_flat_map_boost_unordered_enable_stats[enabled].
zh_Hans: 返回值：容器截至目前执行的插入与查找操作的统计描述信息。
    说明：仅当**启用统计计算**时，该函数才可用。

en: Effects:;; Sets to zero the internal statistics kept by the table. Notes:;; Only available if xref:reference/stats.adoc#stats[statistics calculation] is xref:concurrent_flat_map_boost_unordered_enable_stats[enabled].
zh_Hans: 效果：将容器维护的内部统计数据归零。
    说明：仅当**启用统计计算**时，该函数才可用。

en: Deduction Guides
zh_Hans: 推导指引

en: A deduction guide will not participate in overload resolution if any of the following are true:
zh_Hans: 满足以下任一条件时，推导指引不参与重载决议：

en: - It has an `InputIterator` template parameter and a type that does not qualify as an input iterator is deduced for that parameter. - It has an `Allocator` template parameter and a type that does not qualify as an allocator is deduced for that parameter. - It has a `Hash` template parameter and an integral type or a type that qualifies as an allocator is deduced for that parameter. - It has a `Pred` template parameter and a type that qualifies as an allocator is deduced for that parameter.
zh_Hans: - 该推导指引包含 `InputIterator` 模板参数，且为此参数推导出的类型不符合输入迭代器的要求。 - 该推导指引包含 `Allocator` 模板参数，且为该参数推导出的类型不符合分配器要求。 - 该推导指引包含 `Hash` 模板参数，且为该参数推导出的类型为整型或符合分配器要求。 - 该推导指引包含 `Pred` 模板参数，且为该参数推导出的类型符合分配器要求。

en: A `size_­type` parameter type in a deduction guide refers to the `size_­type` member type of the table type deduced by the deduction guide. Its default value coincides with the default value of the constructor selected.
zh_Hans: 推导指引中的 `size++_++type` 参数类型，指向由该推导指引所推导容器类型的 `size++_++type` 成员类型。其默认值与所选构造函数的默认值一致。

en: __iter-value-type__
zh_Hans: _iter-value-type_

en: Equality Comparisons
zh_Hans: 相等性比较

en: ```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator==(const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x, const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y); ```
zh_Hans: ```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator==(const concurrent_flat_map<key, t,="" hash,="" pred,="" alloc="">&amp; x, const concurrent_flat_map<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>

en: Returns `true` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types).
zh_Hans: 若 `x.size() == y.size()`，且对于 `x` 中的每个元素，`y` 中均存在拥有相同键、值相等（使用 `operator==` 比较值类型）的元素，则返回 `true`。

[ctx: :1758]
en: Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if the two tables don't have equivalent equality predicates.
zh_Hans: 并发：阻塞 `x` 和 `y`。
    说明：若两个容器的相等判断谓词不一致，行为未定义。

en: ```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x, const concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y); ```
zh_Hans: ```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> bool operator!=(const concurrent_flat_map<key, t,="" hash,="" pred,="" alloc="">&amp; x, const concurrent_flat_map<key, t,="" hash,="" pred,="" alloc="">&amp; y); ```</key,></key,></class>

en: Returns `false` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types).
zh_Hans: 若`x.size() == y.size()`，且`x`中每个元素在`y`中都存在键相同、值相等（使用`operator==`比较值类型）的元素，则返回`false`。

[ctx: :1773]
en: Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if the two tables don't have equivalent equality predicates.
zh_Hans: 并发：阻塞`x`和`y`。
    说明：若两个容器的相等判定谓词不一致，则行为未定义。

en: Swap
zh_Hans: 交换

en: ```c++ template<class Key, class T, class Hash, class Pred, class Alloc> void swap(concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x, concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap(y))); ```
zh_Hans: ```c++ template<class key,="" class="" t,="" hash,="" pred,="" alloc=""> void swap(concurrent_flat_map<key, t,="" hash,="" pred,="" alloc="">&amp; x, concurrent_flat_map<key, t,="" hash,="" pred,="" alloc="">&amp; y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>

[ctx: :1786]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等价于 [listing,subs="+macros,+quotes"]

en: ```c++ template<class K, class T, class H, class P, class A, class Predicate> typename concurrent_flat_map<K, T, H, P, A>::size_type erase_if(concurrent_flat_map<K, T, H, P, A>& c, Predicate pred); ```
zh_Hans: ```c++ template<class k,="" class="" t,="" h,="" p,="" a,="" predicate=""> typename concurrent_flat_map<k, t,="" h,="" p,="" a="">::size_type erase_if(concurrent_flat_map<k, t,="" h,="" p,="" a="">&amp; c, Predicate pred); ```</k,></k,></class>

[ctx: :1801]
en: Equivalent to [listing,subs="+macros,+quotes"]
zh_Hans: 等价于 [listing,subs="+macros,+quotes"]

en: Serialization
zh_Hans: 序列化

en: ``concurrent_flat_map``s can be archived/retrieved by means of link:../../../../../serialization/index.html[Boost.Serialization^] using the API provided by this library. Both regular and XML archives are supported.
zh_Hans: `concurrent++_++flat++_++map` 可通过本组件库提供的 API，借助 link:../../../../../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归档与 XML 归档两种格式。

en: Saving an concurrent_flat_map to an archive
zh_Hans: 将concurrent++_++flat++_++map保存到归档

en: Saves all the elements of a `concurrent_flat_map` `x` to an archive (XML archive) `ar`.
zh_Hans: 将 `concurrent++_++flat++_++map` 容器 `x` 的所有元素保存到归档（XML归档） `ar` 中。

en: Requires:;; `std::remove_const<key_type>::type` and `std::remove_const<mapped_type>::type` are serializable (XML serializable), and they do support Boost.Serialization `save_construct_data`/`load_construct_data` protocol (automatically suported by https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^] types). Concurrency:;; Blocking on `x`.
zh_Hans: 要求：`std::remove_const<key_type>::type` 和 `std::remove_const<mapped_type>::type` 必须是可序列化的（支持 XML 序列化），并且它们支持 Boost.Serialization 的 `save_construct_data` / `load_construct_data` 协议（https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 类型自动支持该协议）。并发：阻塞 `x`。</mapped_type></key_type>

en: Loading an concurrent_flat_map from an archive
zh_Hans: 从归档加载concurrent++_++flat++_++map

en: Deletes all preexisting elements of a `concurrent_flat_map` `x` and inserts from an archive (XML archive) `ar` restored copies of the elements of the original `concurrent_flat_map` `other` saved to the storage read by `ar`.
zh_Hans: 删除 `concurrent++_++flat++_++map` 容器 `x` 中所有已存在的元素，并从归档（XML 归档） `ar` 中插入原始 `concurrent++_++flat++_++map` 容器 `other` 的元素副本，这些副本是从 `ar` 所读取的存储中恢复的。

en: Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()`. Concurrency:;; Blocking on `x`.
zh_Hans: 要求;; `x.key++_++equal()` 需要在功能上等价于 `other.key++_++equal()` 。 并发性;; 阻塞于 `x` 。
