msgid "" msgstr "" "Project-Id-Version: Chinese (Simplified Han script) (Boost Unordered " "Translation (zh_Hans))\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-06-06 23:57+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: Chinese (Simplified Han script) \n" "Language: zh_Hans\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" "X-Generator: Weblate 2026.5\n" #: :1 #, safe-html, strict-same msgid "[#concurrent_flat_map]" msgstr "[#concurrent_flat_map]" #: :2 #, safe-html, strict-same msgid "Class Template concurrent_flat_map" msgstr "类模板 concurrent_flat_map" #: :4 #, safe-html, strict-same msgid ":idprefix: concurrent_flat_map_" msgstr ":idprefix: concurrent_flat_map_" #: :6 #, safe-html, strict-same msgid "" "`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." msgstr "" "`boost::concurrent_flat_map` — 一种哈希表，将唯一键与对应值关联，并允许在无需" "外部同步机制的情况下进行并发的元素插入、删除、查找和访问。" #: :10 #, safe-html, strict-same msgid "" "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." msgstr "" "尽管它充当容器的角色，boost::concurrent_flat_map 并未遵循标准 C++ 的 https://" "en.cppreference.com/w/cpp/named_req/Container[Container^] 概念。特别地，它不" "提供迭代器及相关操作（例如 begin、end 等）。元素的访问和修改是通过用户提供的 " "访问函数 来完成的，这些函数被传递给 concurrent_flat_map 的操作，并以受控的方" "式在内部执行。这种基于访问的 API 能够实现低竞争并发的使用场景。" #: :17 #, safe-html, strict-same msgid "" "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." msgstr "" "`boost::concurrent++_++flat++_++map` 的内部数据结构与 " "`boost::unordered++_++flat++_++map` 类似。由于采用开放寻址技术， " "`value++_++type` 必须支持移动构造，且在重哈希过程中无法保持指针稳定性。" #: :21 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :329 #, safe-html, strict-same msgctxt ":329" msgid "---" msgstr "---" #: :331 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :333 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :336 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :340 #, safe-html, strict-same msgid "" "`std::pair` 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." msgstr "" "`std::pair` 必须能够从任何可转换为其的 `std::pair` 对" "象出发，在表中进行 https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] 构造，并且也必须可以从表中进行 " "https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] 擦除。" #: :344 #, safe-html, strict-same msgid "_T_" msgstr "_T_" #: :344 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :344 #, safe-html, strict-same msgid "" "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`." msgstr "" "一种一元函数对象类型，用作Key类型的哈希函数。它接受单个Key类型的参数，并返回" "std::size_t类型的值。" #: :344 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :344 #, safe-html, strict-same msgid "" "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`." msgstr "" "一种二元函数对象，用于在Key类型的值上引入等价关系。该对象接收两个Key类型的参" "数，并返回一个bool类型的值。" #: :344 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :344 #, safe-html, strict-same msgid "An allocator whose value type is the same as the table's value type." msgstr "值类型与哈希表值类型相同的分配器。" #: :354 #, safe-html, strict-same msgid "" "Allocators using https://en.cppreference.com/w/cpp/named_req/" "Allocator#Fancy_pointers[fancy pointers] are supported." msgstr "" "支持使用https://en.cppreference.com/w/cpp/named_req/" "Allocator#Fancy_pointers[花式指针] 的分配器。" #: :358 #, safe-html, strict-same msgid "" "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." msgstr "" "容器的元素存储在内部的__桶数组__中。元素根据其哈希码被插入到对应的桶中，但如" "果该桶已被占用（即发生__冲突__），则会使用原始位置附近可用的桶。" #: :362 #, safe-html, strict-same msgid "" "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." msgstr "" "桶数组的大小可通过调用 `insert` / `emplace` 自动增加，也可通过调用 " "`rehash` / `reserve` 进行调整。容器的__负载因子__（元素数量与桶数量的比值）永" "远不会超过 `max++_++load++_++factor()` ，但在小规模数据情况下，实现可能允许更" "高的负载因子。" #: :367 #, safe-html, strict-same msgid "" "If `link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]::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." msgstr "" "若 link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanchinghash[`hash++_++is++_++avalanching`]`++<++Hash++>++::value` " "为 `true` ，则直接使用哈希函数；否则，会添加一个位混合后处理阶段以提高哈希质" "量，但会牺牲额外的计算成本。" #: :371 #, safe-html, strict-same msgctxt ":371" msgid "---" msgstr "---" #: :373 #, safe-html, strict-same msgid "Concurrency Requirements and Guarantees" msgstr "并发要求与保证" #: :375 #, safe-html, strict-same msgid "" "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:" msgstr "" "要求对同一 `Hash` 或 `Pred` 常量实例并发调用 `operator()` 时不得引入数据竞争" "。对于 `Alloc` （即 `Allocator` 或其重绑定后的任意分配器类型），在同一实例 " "`al` 上并发调用以下操作时不得引入数据竞争：" #: :380 #, safe-html, strict-same msgid "Copy construction from `al` of an allocator rebound from `Alloc`" msgstr "从Alloc重新绑定后的分配器的al进行拷贝构造" #: :381 #, safe-html, strict-same msgid "`std::allocator_traits::allocate`" msgstr "`std::allocator_traits::allocate`" #: :382 #, safe-html, strict-same msgid "`std::allocator_traits::deallocate`" msgstr "`std::allocator_traits::deallocate`" #: :383 #, safe-html, strict-same msgid "`std::allocator_traits::construct`" msgstr "`std::allocator_traits::construct`" #: :384 #, safe-html, strict-same msgid "`std::allocator_traits::destroy`" msgstr "`std::allocator_traits::destroy`" #: :386 #, safe-html, strict-same msgid "" "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." msgstr "" "通常而言，若 `Hash` 、 `Pred` 和 `Allocator` 这些类型不包含状态，或其操作仅涉" "及对内部数据成员的常量访问，即可满足上述要求。" #: :389 #, safe-html, strict-same msgid "" "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." msgstr "" "除了析构操作外，在同一个 `concurrent_flat_map` 实例上并发调用任何操作都不会引" "入数据竞争——即这些操作是线程安全的。" #: :392 #, safe-html, strict-same msgid "" "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." msgstr "" "若某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 为 " "`boost::concurrent_flat_map` 实例），则先前对 `x` 的阻塞操作将与 *op* 同步。" "因此，在多线程场景中，对同一 `concurrent_flat_map` 的阻塞操作将按顺序执行。" #: :396 #, safe-html, strict-same msgid "" "An operation is said to be _blocking on rehashing of_ ``__x__`` if it blocks " "on `x` only when an internal rehashing is issued." msgstr "" "若某个操作仅在触发内部重哈希时才会阻塞于 _`x`_，则称该操作阻塞于 _`x`_ 的重哈" "希过程。" #: :399 #, safe-html, strict-same msgid "" "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:" msgstr "" "当由 `boost::concurrent_flat_map` 内部执行时，用户提供的访问函数对传入元素执" "行以下操作不会引入数据竞争：" #: :402 #, safe-html, strict-same msgid "Read access to the element." msgstr "对元素的读取访问。" #: :403 #, safe-html, strict-same msgid "Non-mutable modification of the element." msgstr "对元素的非可变修改。" #: :404 #, safe-html, strict-same msgid "Mutable modification of the element:" msgstr "对元素的可变修改：" #: :405 #, safe-html, strict-same msgid "" "** 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." msgstr "" "** 在容器接受两个访问函数的操作中，此条件始终适用于第一个访问函数。 ** 在名称" "不包含 `cvisit` 的非常量容器函数中，此条件适用于最后一个（或唯一一个）访问函" "数。" #: :408 #, safe-html, strict-same msgid "" "Any `boost::concurrent_flat_map operation` that inserts or modifies an " "element `e` synchronizes with the internal invocation of a visitation " "function on `e`." msgstr "" "任何插入或修改元素 `e` 的 `boost::concurrent_flat_map operation` 操作，都会与" "针对 `e` 的内部访问函数调用同步。" #: :411 #, safe-html, strict-same msgid "" "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." msgstr "" "由 `boost::concurrent_flat_map` 容器 `x` 执行的访问函数不得调用 `x` 上的任何" "操作；仅当对另一 `boost::concurrent_flat_map` 实例 `y` 的并发的未完成操作不直" "接或间接访问 `x` 时，才允许调用实例 `y` 上的操作。" #: :415 #, safe-html, strict-same msgctxt ":415" msgid "---" msgstr "---" #: :417 #, safe-html, strict-same msgid "Configuration Macros" msgstr "配置宏" #: :419 #, safe-html, strict-same msgid "`BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK`" msgstr "`BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK`" #: :421 #, safe-html, strict-same msgid "" "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." msgstr "" "在调试版本中（更准确地说，当未定义 link:../../../../../assert/doc/html/" "assert.html#boost_assert_is_void[`BOOST_ASSERT_IS_VOID`] 时），系统会检测__容" "器重入__行为（即在访问 `m` 元素的函数内部非法调用 `m` 上的操作），并通过 " "`BOOST_ASSERT_MSG` 发出信号。若需关注运行时速度，可通过全局定义此宏来禁用该功" "能。" #: :428 #, safe-html, strict-same msgctxt ":428" msgid "---" msgstr "---" #: :430 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_STATS`" msgstr "`BOOST_UNORDERED_ENABLE_STATS`" #: :432 #, safe-html, strict-same msgid "" "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." msgstr "" "全局定义此宏以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请注" "意，此选项会降低多数操作的总体性能。" #: :435 #, safe-html, strict-same msgctxt ":435" msgid "---" msgstr "---" #: :437 #, safe-html, strict-same msgid "Constants" msgstr "常量" #: :439 #, safe-html, strict-same msgid "```cpp static constexpr size_type bulk_visit_size; ```" msgstr "```cpp static constexpr size_type bulk_visit_size; ```" #: :443 #, safe-html, strict-same msgid "" "Chunk size internally used in xref:concurrent_flat_map_bulk_visit[bulk " "visit] operations." msgstr "xref:concurrent_flat_map_bulk_visit [批量访问] 操作内部使用的块大小。" #: :445 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :447 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :448 #, safe-html, strict-same msgid "```c++ concurrent_flat_map(); ```" msgstr "```c++ concurrent_flat_map(); ```" #: :452 #, safe-html, strict-same msgid "" "Constructs an empty table using `hasher()` as the hash function, `key_equal()" "` as the key equality predicate and `allocator_type()` as the allocator." msgstr "" "使用hasher()作为哈希函数、key_equal()作为键相等谓词、allocator_type()作为分配" "器，构造一个空表。" #: :456 #, safe-html, strict-same msgctxt ":456" msgid "" "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^]." msgstr "" "后置条件：size() == 0\n" "要求：若使用默认构造方式，则hasher、key_equal和allocator_type必须满足https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。" #: :459 #, safe-html, strict-same msgctxt ":459" msgid "---" msgstr "---" #: :461 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :462 #, safe-html, strict-same msgid "" "```c++ explicit concurrent_flat_map(size_type n, const hasher& hf = hasher()" ", const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" msgstr "" "```c++ explicit concurrent_flat_map(size_type n, const hasher& hf = " "hasher(), const key_equal& eql = key_equal(), const allocator_type& " "a = allocator_type()); ```" #: :469 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含n个桶的空表，使用hf作为哈希函数、eql作为键相等谓词、a作为分配" "器。" #: :473 #, safe-html, strict-same msgctxt ":473" msgid "" "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^]." msgstr "" "后置条件：size() == 0\n" "要求：若使用默认参数，则hasher、key_equal和allocator_type必须满足https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[默认可构造]要求。" #: :476 #, safe-html, strict-same msgctxt ":476" msgid "---" msgstr "---" #: :478 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :489 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、 `a` 作为分配器，并将 `[f, l)` 范围内的元素插入其中。" #: :492 #, safe-html, strict-same msgctxt ":492" msgid "" "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^]." msgstr "" "要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` " "需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默" "认构造] 要求。" #: :494 #, safe-html, strict-same msgctxt ":494" msgid "---" msgstr "---" #: :496 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :497 #, safe-html, strict-same msgid "```c++ concurrent_flat_map(concurrent_flat_map const& other); ```" msgstr "```c++ concurrent_flat_map(concurrent_flat_map const& other); ```" #: :501 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate and allocator." msgstr "拷贝构造函数。复制容器内的元素、哈希函数、谓词以及分配器。" #: :503 #, safe-html, strict-same msgid "" "If `Allocator::select_on_container_copy_construction` exists and has the " "right signature, the allocator will be constructed from its result." msgstr "" "若Allocator::select_on_container_copy_construction存在且签名正确，则分配器将" "根据其返回值构造。" #: :506 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on " "`other`." msgstr "要求：value_type 支持复制构造。 并发特性：阻塞于 other" #: :509 #, safe-html, strict-same msgctxt ":509" msgid "---" msgstr "---" #: :511 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :512 #, safe-html, strict-same msgid "```c++ concurrent_flat_map(concurrent_flat_map&& other); ```" msgstr "```c++ concurrent_flat_map(concurrent_flat_map&& other); ```" #: :516 #, safe-html, strict-same msgid "" "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()`." msgstr "" "移动构造函数。other 的内部桶数组会直接转移到新表中。哈希函数、谓词和分配器均" "从 other 移动构造而来。如果启用了 " "xref:concurrent_flat_map_boost_unordered_enable_stats [统计功能]，则从 other " "转移内部统计信息，并调用 other.reset_stats()。" #: :522 #, safe-html, strict-same msgctxt ":522" msgid "Concurrency:;; Blocking on `other`." msgstr "并发特性：阻塞于 other" #: :524 #, safe-html, strict-same msgctxt ":524" msgid "---" msgstr "---" #: :526 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器范围构造函数" #: :527 #, safe-html, strict-same msgid "" "```c++ template concurrent_flat_map(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template concurrent_flat_map(InputIterator " "f, InputIterator l, const allocator_type& a); ```" #: :532 #, safe-html, strict-same msgid "" "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." msgstr "" "以a作为分配器，使用默认哈希函数与键相等谓词构造空表，并将[f, l)范围内的元素插" "入其中。" #: :535 #, safe-html, strict-same msgctxt ":535" msgid "" "Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/" "cpp/named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求：hasher、key_equal 必须满足https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[默认可构造]要求。" #: :537 #, safe-html, strict-same msgctxt ":537" msgid "---" msgstr "---" #: :539 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :540 #, safe-html, strict-same msgid "```c++ explicit concurrent_flat_map(Allocator const& a); ```" msgstr "```c++ explicit concurrent_flat_map(Allocator const& a); ```" #: :544 #, safe-html, strict-same msgid "Constructs an empty table, using allocator `a`." msgstr "使用分配器a构造一个空表。" #: :546 #, safe-html, strict-same msgctxt ":546" msgid "---" msgstr "---" #: :548 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :549 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(concurrent_flat_map const& other, Allocator " "const& a); ```" msgstr "" "```c++ concurrent_flat_map(concurrent_flat_map const& other, Allocator " "const& a); ```" #: :553 #, safe-html, strict-same msgid "" "Constructs a table, copying ``other``'s contained elements, hash function, " "and predicate, but using allocator `a`." msgstr "构造一个表，复制other的容器元素、哈希函数和谓词，但使用分配器a。" #: :556 #, safe-html, strict-same msgctxt ":556" msgid "Concurrency:;; Blocking on `other`." msgstr "并发特性：阻塞于 other" #: :558 #, safe-html, strict-same msgctxt ":558" msgid "---" msgstr "---" #: :560 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :561 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(concurrent_flat_map&& other, Allocator const& a); " "```" msgstr "" "```c++ concurrent_flat_map(concurrent_flat_map&& other, Allocator " "const& a); ```" #: :565 #, safe-html, strict-same msgid "" "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()`." msgstr "" "若a == other.get_allocator()，则other的元素会直接转移到新表中；否则，元素从" "other移动构造而来。\n" "哈希函数与谓词从other移动构造，分配器从a拷贝构造。\n" "如果启用了 xref:concurrent_flat_map_boost_unordered_enable_stats [统计功" "能]：\n" "当且仅当a == other.get_allocator()时，从other转移内部统计信息\n" "始终调用other.reset_stats()" #: :573 #, safe-html, strict-same msgctxt ":573" msgid "Concurrency:;; Blocking on `other`." msgstr "并发特性：阻塞于 other" #: :575 #, safe-html, strict-same msgctxt ":575" msgid "---" msgstr "---" #: :577 #, safe-html, strict-same msgid "Move Constructor from unordered_flat_map" msgstr "从 unordered_flat_map 的移动构造函数" #: :579 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(unordered_flat_map" "&& other); ```" msgstr "" "```c++ concurrent_flat_map(unordered_flat_map&& other); ```" #: :583 #, safe-html, strict-same msgid "" "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()`." msgstr "" "从 xref:#unordered_flat_map [unordered_flat_map] 进行移动构造。other的内部桶" "数组会直接转移到新容器中。哈希函数、谓词和分配器均从other移动构造而来。如果启" "用了 xref:concurrent_flat_map_boost_unordered_enable_stats [统计功能]，则从" "other转移内部统计信息，并调用other.reset_stats()。" #: :590 #, safe-html, strict-same msgid "Complexity:;; O(`bucket_count()`)" msgstr "复杂度：O (`bucket_count()`)" #: :592 #, safe-html, strict-same msgctxt ":592" msgid "---" msgstr "---" #: :594 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :604 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、 `a` 作为分配器，并 `il` 中的元素插入其中。" #: :607 #, safe-html, strict-same msgctxt ":607" msgid "" "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^]." msgstr "" "要求;; 若使用默认值，则 `hasher` 、 `key++_++equal` 和 `allocator++_++type` " "需满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默" "认构造] 要求。" #: :609 #, safe-html, strict-same msgctxt ":609" msgid "---" msgstr "---" #: :611 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :612 #, safe-html, strict-same msgid "```c++ concurrent_flat_map(size_type n, allocator_type const& a); ```" msgstr "" "```c++ concurrent_flat_map(size_type n, allocator_type const& a); ```" #: :616 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 n 个桶的空表，使用 hf 作为哈希函数、默认的键相等谓词，并以 " "a 作为分配器。" #: :619 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to " "be https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：size() == 0\n" "要求：hasher 和 key_equal 必须满足https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[默认可构造]要求。" #: :622 #, safe-html, strict-same msgctxt ":622" msgid "---" msgstr "---" #: :624 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :625 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" msgstr "" "```c++ concurrent_flat_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :629 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 n 个桶的空表，使用 hf 作为哈希函数、默认键相等谓词，并以 a " "作为分配器。" #: :632 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：size() == 0\n" "要求：key_equal 必须满足https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[默认可构造]。" #: :635 #, safe-html, strict-same msgctxt ":635" msgid "---" msgstr "---" #: :637 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :644 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器以及默认的哈希函数和键" "相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。" #: :647 #, safe-html, strict-same msgctxt ":647" msgid "" "Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/" "cpp/named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求;; `hasher` 和 `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[可默认构造] 要求。" #: :649 #, safe-html, strict-same msgctxt ":649" msgid "---" msgstr "---" #: :651 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :659 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器以" "及默认的键相等性谓词，并将 `[f, l)` 范围内的元素插入其中。" #: :662 #, safe-html, strict-same msgctxt ":662" msgid "" "Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求;; `key++_++equal` 需满足 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[可默认构造] 要求。" #: :664 #, safe-html, strict-same msgctxt ":664" msgid "---" msgstr "---" #: :666 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :668 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ concurrent_flat_map(std::initializer_list il, const " "allocator_type& a); ```" #: :672 #, safe-html, strict-same msgid "" "Constructs an empty table using `a` and default hash function and key " "equality predicate, and inserts the elements from `il` into it." msgstr "使用分配器a以及默认哈希函数、键相等谓词构造空表，并将il中的元素插入表中。" #: :675 #, safe-html, strict-same msgctxt ":675" msgid "" "Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/" "w/cpp/named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[可默认构造^] 要求。" #: :677 #, safe-html, strict-same msgctxt ":677" msgid "---" msgstr "---" #: :679 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :681 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(std::initializer_list il, size_type " "n, const allocator_type& a); ```" msgstr "" "```c++ concurrent_flat_map(std::initializer_list il, size_type " "n, const allocator_type& a); ```" #: :685 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 n 个桶的空表，使用分配器 a 以及默认哈希函数、键相等谓词，并" "将 il 中的元素插入表中。" #: :688 #, safe-html, strict-same msgctxt ":688" msgid "" "Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/" "w/cpp/named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[可默认构造^] 要求。" #: :690 #, safe-html, strict-same msgctxt ":690" msgid "---" msgstr "---" #: :692 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :694 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map(std::initializer_list il, size_type " "n, const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ concurrent_flat_map(std::initializer_list il, size_type " "n, const hasher& hf, const allocator_type& a); ```" #: :699 #, safe-html, strict-same msgid "" "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." msgstr "" "构造一个至少包含 n 个桶的空表，使用 hf 作为哈希函数、a 作为分配器、默认键相等" "谓词，并将 il 中的元素插入表中。" #: :702 #, safe-html, strict-same msgctxt ":702" msgid "" "Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求：key_equal 须满足https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[默认可构造]要求。" #: :704 #, safe-html, strict-same msgctxt ":704" msgid "---" msgstr "---" #: :706 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :708 #, safe-html, strict-same msgid "```c++ ~concurrent_flat_map(); ```" msgstr "```c++" #: :713 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "备注：析构函数会作用于所有元素，且所有内存都会被释放。" #: :715 #, safe-html, strict-same msgctxt ":715" msgid "---" msgstr "---" #: :717 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :719 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :721 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map& operator=(concurrent_flat_map const& other); ```" msgstr "" "```c++ concurrent_flat_map& operator=(concurrent_flat_map const& " "other); ```" #: :725 #, safe-html, strict-same msgid "" "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`." msgstr "" "赋值运算符。销毁原有的所有元素，从other复制赋值哈希函数与谓词；若" "Alloc::propagate_on_container_copy_assignment存在且其值为true，则从other复制" "赋值分配器；最终插入other元素的副本。" #: :730 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this` and " "`other`." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。并发：阻塞 `*this` 和 `other`。" #: :733 #, safe-html, strict-same msgctxt ":733" msgid "---" msgstr "---" #: :735 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :736 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map& operator=(concurrent_flat_map&& other) noexcept(" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && std::is_same::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()`." msgstr "" "```c++ concurrent_flat_map& operator=(concurrent_flat_map&& " "other) noexcept((boost::allocator_traits::is_always_equal::value " "|| boost::allocator_traits" "::propagate_on_container_move_assignment::value) && " "std::is_same::value); ``` \n" "移动赋值运算符。销毁当前容器原有的所有元素，交换other的哈希函数与谓词；若" "Alloc::propagate_on_container_move_assignment存在且其值为true，则从other移动" "赋值分配器。\n" "若此时分配器与other.get_allocator()相等，则直接转移other的内部桶数组至当前容" "器；否则，插入other元素的移动构造副本。\n" "如果启用了统计功能：\n" "当且仅当最终分配器与other.get_allocator()相等时，从other转移内部统计信息\n" "始终调用other.reset_stats()" #: :751 #, safe-html, strict-same msgid "Concurrency:;; Blocking on `*this` and `other`." msgstr "并发：阻塞于 *this 和 other。" #: :753 #, safe-html, strict-same msgctxt ":753" msgid "---" msgstr "---" #: :755 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :756 #, safe-html, strict-same msgid "" "```c++ concurrent_flat_map& operator=(std::initializer_list il); " "```" msgstr "" "```c++ concurrent_flat_map& operator=(std::initializer_list " "il); ```" #: :760 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All previously existing elements are " "destroyed." msgstr "" "并发：阻塞于 *this 和 other。\n" "从初始化列表赋值。销毁所有先前存在的元素。" #: :763 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this`." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。并发：阻塞 `*this`。" #: :766 #, safe-html, strict-same msgctxt ":766" msgid "---" msgstr "---" #: :768 #, safe-html, strict-same msgid "Visitation" msgstr "访问操作" #: :770 #, safe-html, strict-same msgid "[c]visit" msgstr "[c]visit" #: :772 #, safe-html, strict-same msgid "" "```c++ template size_t visit(const key_type& k, F f); " "template size_t visit(const key_type& k, F f) const; template size_t cvisit(const key_type& k, F f) const; template " "size_t visit(const K& k, F f); template size_t visit(const " "K& k, F f) const; template size_t cvisit(const K& k, F f) " "const; ```" msgstr "" "```c++ template size_t visit(const key_type& k, F f); " "template size_t visit(const key_type& k, F f) const; " "template size_t cvisit(const key_type& k, F f) const; " "template size_t visit(const K& k, F f); " "template size_t visit(const K& k, F f) " "const; template size_t cvisit(const K& " "k, F f) const; ```" #: :781 #, safe-html, strict-same msgid "" "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." msgstr "" "若存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。\n" "当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。" #: :785 #, safe-html, strict-same msgid "" "Returns:;; The number of elements visited (0 or 1). Notes:;; The " "`template` 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." msgstr "" "返回值：访问过的元素数量（0 或 1）。\n" "注意：template 形式的重载仅在 " "Hash::is_transparent 与 Pred::is_transparent 为合法成员别名时才参与重载决议" "。\n" "库假定 Hash 可同时用于 K 类型与 Key 类型，且 Pred 是透明的。\n" "这支持异构查找，避免了实例化 Key 类型对象带来的开销。" #: :788 #, safe-html, strict-same msgctxt ":788" msgid "---" msgstr "---" #: :790 #, safe-html, strict-same msgid "Bulk visit" msgstr "批量访问" #: :792 #, safe-html, strict-same msgid "" "```c++ template size_t visit(FwdIterator first, " "FwdIterator last, F f); template size_t visit" "(FwdIterator first, FwdIterator last, F f) const; template size_t cvisit(FwdIterator first, FwdIterator last, F " "f) const; ```" msgstr "" "```c++ template size_t visit" "(FwdIterator first, FwdIterator last, F f); template size_t visit(FwdIterator first, FwdIterator last, F f) " "const; template size_t cvisit" "(FwdIterator first, FwdIterator last, F f) const; ```" #: :801 #, safe-html, strict-same msgid "" "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." msgstr "" "对范围 [first, last) 中的每个键 k：\n" "如果容器中存在键与 k 等价的元素 x，则以 x 的引用调用函数 f。\n" "当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。" #: :806 #, safe-html, strict-same msgid "" "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." msgstr "" "尽管功能上等价于对每个键单独调用 [c]visit，但批量访问因内部流线型优化，通常性" "能更高。\n" "建议 std::distance(first,last) 至少达到 bulk_visit_size 阈值时再使用，以获得" "性能提升；超过该大小后，性能不会进一步提升。" #: :815 #, safe-html, strict-same msgid "" "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::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." msgstr "" "要求：`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::value_type`，要么 `K` 是 `key_type`，" "要么 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef。" "在后一种情况下，库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的" "。该机制支持异构查找，从而避免实例化 `Key` 类型的开销。返回：被访问的元素数量" "。" #: :824 #, safe-html, strict-same msgctxt ":824" msgid "---" msgstr "---" #: :826 #, safe-html, strict-same msgid "[c]visit_all" msgstr "[c]visit_all" #: :828 #, safe-html, strict-same msgid "" "```c++ template size_t visit_all(F f); template size_t " "visit_all(F f) const; template size_t cvisit_all(F f) const; ```" msgstr "" "```c++ template size_t visit_all(F f); template " "size_t visit_all(F f) const; template size_t cvisit_all(F f) " "const; ```" #: :834 #, safe-html, strict-same msgid "" "Successively invokes `f` with references to each of the elements in the " "table. Such references are const iff `*this` is const." msgstr "" "依次以表中每个元素的引用调用函数 f。\n" "当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。" #: :838 #, safe-html, strict-same msgid "Returns:;; The number of elements visited." msgstr "返回值：访问到的元素数量。" #: :840 #, safe-html, strict-same msgctxt ":840" msgid "---" msgstr "---" #: :842 #, safe-html, strict-same msgid "Parallel [c]visit_all" msgstr "并行 [c]visit_all" #: :844 #, safe-html, strict-same msgid "" "```c++ template void visit_all" "(ExecutionPolicy&& policy, F f); template " "void visit_all(ExecutionPolicy&& policy, F f) const; template void cvisit_all(ExecutionPolicy&& policy, F f) " "const; ```" msgstr "" "```c++ template void visit_all" "(ExecutionPolicy&& policy, F f); template void visit_all" "(ExecutionPolicy&& policy, F f) const; template void cvisit_all" "(ExecutionPolicy&& policy, F f) const; ```" #: :850 #, safe-html, strict-same msgid "" "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." msgstr "" "以表中每个元素的引用调用函数 f。\n" "当且仅当当前容器 *this 为常量（const）时，该引用为常量引用。\n" "执行过程将根据指定的执行策略语义进行并行化。" #: :854 #, safe-html, strict-same msgid "" "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>` is " "`true`. + + Unsequenced execution policies are not allowed." msgstr "" "抛出异常：根据所使用执行策略的异常处理机制，如果 f 内部抛出异常，则可能会调" "用 std::terminate。\n" "注意：仅在支持 C++17 并行算法的编译器中可用。\n" "仅当 std::is_execution_policy_v> 为 " "true 时，这些重载版本才参与重载决议。\n" "不允许使用无序执行策略。" #: :861 #, safe-html, strict-same msgctxt ":861" msgid "---" msgstr "---" #: :863 #, safe-html, strict-same msgid "[c]visit_while" msgstr "[c]visit_while" #: :865 #, safe-html, strict-same msgid "" "```c++ template bool visit_while(F f); template bool " "visit_while(F f) const; template bool cvisit_while(F f) const; ```" msgstr "" "```c++ template bool visit_while(F f); template " "bool visit_while(F f) const; template bool cvisit_while(F f) " "const; ```" #: :871 #, safe-html, strict-same msgid "" "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." msgstr "" "依次以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。\n" "当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。" #: :876 #, safe-html, strict-same msgid "Returns:;; `false` iff `f` ever returns `false`." msgstr "返回值：当且仅当 f 曾返回 false 时，整体返回 false。" #: :878 #, safe-html, strict-same msgctxt ":878" msgid "---" msgstr "---" #: :880 #, safe-html, strict-same msgid "Parallel [c]visit_while" msgstr "并行 [c]visit_while" #: :882 #, safe-html, strict-same msgid "" "```c++ template bool visit_while" "(ExecutionPolicy&& policy, F f); template " "bool visit_while(ExecutionPolicy&& policy, F f) const; template bool cvisit_while(ExecutionPolicy&& policy, F f) " "const; ```" msgstr "" "```c++ template bool " "visit_while(ExecutionPolicy&& policy, F f); template bool visit_while" "(ExecutionPolicy&& policy, F f) const; template bool cvisit_while" "(ExecutionPolicy&& policy, F f) const; ```" #: :888 #, safe-html, strict-same msgid "" "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." msgstr "" "以表中每个元素的引用调用函数 f，直到 f 返回 false 或遍历完所有元素。\n" "当且仅当当前容器 *this 为常量（const）时，该元素引用为常量引用。\n" "执行过程将根据指定的执行策略语义进行并行化。" #: :894 #, safe-html, strict-same msgid "" "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>` 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`." msgstr "" "返回值：当且仅当 f 曾返回 false 时，整体返回 false。\n" "抛出异常：根据所使用执行策略的异常处理机制，如果 f 内部抛出异常，则可能会调" "用 std::terminate。\n" "注意：\n" "仅在支持 C++17 并行算法的编译器中可用。\n" "仅当 std::is_execution_policy_v> 为 " "true 时，这些重载版本才参与重载决议。\n" "不允许使用无序执行策略。\n" "并行化意味着：即使 f 已返回 false，执行流程也不一定会立即终止；因此，f 可能还" "会被继续调用以处理后续元素，且这些调用同样可能返回 false。" #: :905 #, safe-html, strict-same msgctxt ":905" msgid "---" msgstr "---" #: :907 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :909 #, safe-html, strict-same msgid "empty" msgstr "空" #: :911 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :916 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "返回值：size() == 0" #: :918 #, safe-html, strict-same msgctxt ":918" msgid "---" msgstr "---" #: :920 #, safe-html, strict-same msgid "size" msgstr "大小" #: :922 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :927 #, safe-html, strict-same msgid "Returns:;; The number of elements in the table." msgstr "返回值：表中的元素数量。" #: :930 #, safe-html, strict-same msgid "" "Notes:;; In the presence of concurrent insertion operations, the value " "returned may not accurately reflect the true size of the table right after " "execution." msgstr "" "注意：在存在并发插入操作时，返回的值可能无法准确反映函数执行后容器的真实大小" "。" #: :933 #, safe-html, strict-same msgctxt ":933" msgid "---" msgstr "---" #: :935 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :937 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :942 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible table." msgstr "返回值：容器所能容纳的最大元素数量（最大容量）。" #: :944 #, safe-html, strict-same msgctxt ":944" msgid "---" msgstr "---" #: :946 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :948 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :949 #, safe-html, strict-same msgid "```c++ template bool emplace(Args&&... args); ```" msgstr "" "```c++ template bool emplace(Args&&... args); " "```" #: :953 #, safe-html, strict-same msgid "" "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." msgstr "" "当且仅当容器中不存在等价键的元素时，才会使用参数 args 构造对象并插入到容器中" "。" #: :956 #, safe-html, strict-same msgid "" "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." msgstr "" "要求：`value_type` 可从 `args` 构造。返回：若执行了插入则返回 `true`。并发：" "在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和" "引用会失效。+ +若 `args...` 的形式为 `k,v`，则仅在确定应插入元素时才构造整个" "对象，检查时仅使用 `k` 参数。" #: :963 #, safe-html, strict-same msgctxt ":963" msgid "---" msgstr "---" #: :965 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :966 #, safe-html, strict-same msgid "" "```c++ bool insert(const value_type& obj); bool insert(const init_type& obj)" "; ```" msgstr "" "```c++ bool insert(const value_type& obj); bool insert(const " "init_type& obj); ```" #: :971 #, safe-html, strict-same msgctxt ":971" msgid "" "Inserts `obj` in the table if and only if there is no element in the table " "with an equivalent key." msgstr "当且仅当容器中不存在等价键的元素时，才将对象 obj 插入到容器中。" #: :974 #, safe-html, strict-same msgid "" "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." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 " "`*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用" "会失效。+ +形式为 `insert(x)` 的调用（其中 `x` 可同等转换为 `const " "value_type&` 和 `const init_type&`）不会产生歧义，并且会选择 " "`init_type` 重载。" #: :981 #, safe-html, strict-same msgctxt ":981" msgid "---" msgstr "---" #: :983 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :984 #, safe-html, strict-same msgid "```c++ bool insert(value_type&& obj); bool insert(init_type&& obj); ```" msgstr "" "```c++ bool insert(value_type&& obj); bool insert" "(init_type&& obj); ```" #: :989 #, safe-html, strict-same msgctxt ":989" msgid "" "Inserts `obj` in the table if and only if there is no element in the table " "with an equivalent key." msgstr "当且仅当容器中无等价键的元素时，将对象 obj 插入容器。" #: :992 #, safe-html, strict-same msgid "" "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." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 " "`*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用" "会失效。+ +形式为 `insert(x)` 的调用（其中 `x` 可同等转换为 " "`value_type&&` 和 `init_type&&`）不会产生歧义，并且会选择 " "`init_type` 重载。" #: :999 #, safe-html, strict-same msgctxt ":999" msgid "---" msgstr "---" #: :1001 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :1002 #, safe-html, strict-same msgid "" "```c++ template size_type insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template size_type insert(InputIterator " "first, InputIterator last); ```" #: :1006 #, safe-html, strict-same msgctxt ":1006" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等效于 [listing,subs=\"+macros,+quotes\"]" #: :1013 #, safe-html, strict-same msgctxt ":1013" msgid "Returns:;; The number of elements inserted." msgstr "返回值：成功插入的元素数量。" #: :1015 #, safe-html, strict-same msgctxt ":1015" msgid "---" msgstr "---" #: :1017 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :1018 #, safe-html, strict-same msgid "```c++ size_type insert(std::initializer_list il); ```" msgstr "" "```c++ size_type insert(std::initializer_list il); ```" #: :1022 #, safe-html, strict-same msgctxt ":1022" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等效于 [listing,subs=\"+macros,+quotes\"]" #: :1029 #, safe-html, strict-same msgctxt ":1029" msgid "Returns:;; The number of elements inserted." msgstr "返回值：插入的元素个数。" #: :1031 #, safe-html, strict-same msgctxt ":1031" msgid "---" msgstr "---" #: :1033 #, safe-html, strict-same msgid "emplace_or_[c]visit" msgstr "emplace_or_[c]visit" #: :1034 #, safe-html, strict-same msgid "" "```c++ template bool emplace_or_visit(Args&&... " "args, F&& f); template bool emplace_or_cvisit" "(Args&&... args, F&& f); ```" msgstr "" "```c++ template bool emplace_or_visit" "(Args&&... args, F&& f); template bool emplace_or_cvisit(Args&&... args, " "F&& f); ```" #: :1039 #, safe-html, strict-same msgid "" "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." msgstr "" "若容器中无等价键的元素，则使用参数 args 构造对象并插入容器；\n" "否则，将等价元素的引用传递给函数 f 并调用 —— 若使用的是 emplace_or_cvisit，则" "该引用为常量引用。" #: :1043 #, safe-html, strict-same msgid "" "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." msgstr "" "要求：`value_type` 可从 `args` 构造。返回：若执行了插入则返回 `true`。并发：" "在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和" "引用会失效。+ +该接口仅为展示说明，因为 C++ 不允许在变参参数包之后声明参数 " "`f`。" #: :1050 #, safe-html, strict-same msgctxt ":1050" msgid "---" msgstr "---" #: :1052 #, safe-html, strict-same msgid "Copy insert_or_[c]visit" msgstr "Copy insert_or_[c]visit" #: :1053 #, safe-html, strict-same msgid "" "```c++ template bool insert_or_visit(const value_type& obj, F f); " "template bool insert_or_cvisit(const value_type& obj, F f); " "template bool insert_or_visit(const init_type& obj, F f); " "template bool insert_or_cvisit(const init_type& obj, F f); ```" msgstr "" "```c++ template bool insert_or_visit(const value_type& " "obj, F f); template bool insert_or_cvisit(const " "value_type& obj, F f); template bool insert_or_visit(const " "init_type& obj, F f); template bool insert_or_cvisit(const " "init_type& obj, F f); ```" #: :1060 #, safe-html, strict-same msgctxt ":1060" msgid "" "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." msgstr "" "当且仅当容器中不存在等价键的元素时，将对象 obj 插入容器；\n" "否则，将等价元素的引用传入函数 f 并调用 ——若使用的是 *_cvisit 重载版本，该引" "用为常量引用。" #: :1064 #, safe-html, strict-same msgid "" "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::type>::type` is " "`value_type`." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 " "`*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用" "会失效。+ +在形式为 `insert_or_[c]visit(obj, f)` 的调用中，接受 `const " "value_type&` 参数的重载仅当 " "`std::remove_cv::type>::type` 为 " "`value_type` 时才参与重载决议。" #: :1072 #, safe-html, strict-same msgctxt ":1072" msgid "---" msgstr "---" #: :1074 #, safe-html, strict-same msgid "Move insert_or_[c]visit" msgstr "Move insert_or_[c]visit" #: :1075 #, safe-html, strict-same msgid "" "```c++ template bool insert_or_visit(value_type&& obj, F f); " "template bool insert_or_cvisit(value_type&& obj, F f); " "template bool insert_or_visit(init_type&& obj, F f); template bool insert_or_cvisit(init_type&& obj, F f); ```" msgstr "" "```c++ template bool insert_or_visit(value_type&& obj, " "F f); template bool insert_or_cvisit(value_type&& obj, " "F f); template bool insert_or_visit(init_type&& obj, F " "f); template bool insert_or_cvisit(init_type&& obj, F " "f); ```" #: :1082 #, safe-html, strict-same msgctxt ":1082" msgid "" "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." msgstr "" "当且仅当容器中无等价键的元素时，插入对象 obj；\n" "否则，以等价元素的引用调用函数 f ——若使用 *_cvisit 重载版本，该引用为常量引用" "。" #: :1086 #, safe-html, strict-same msgid "" "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::type` is `value_type`." msgstr "" "要求：value_type 满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入] 要求。\n" "返回值：插入成功则返回 true。\n" "并发：在当前对象 *this 执行重哈希期间阻塞。\n" "说明：触发重哈希时，会使指向元素的指针和引用失效。\n" "调用形式为 insert_or_[c]visit(obj, f) 时，仅当 std::remove_reference::type 类型为 value_type，接收 value_type&& 参数的重载函数才会" "参与重载决议。" #: :1094 #, safe-html, strict-same msgctxt ":1094" msgid "---" msgstr "---" #: :1096 #, safe-html, strict-same msgid "Insert Iterator Range or Visit" msgstr "迭代器范围插入或访问" #: :1097 #, safe-html, strict-same msgid "" "```c++ template size_type insert_or_visit" "(InputIterator first, InputIterator last, F f); template size_type insert_or_cvisit(InputIterator first, " "InputIterator last, F f); ```" msgstr "" "```c++ template size_type " "insert_or_visit(InputIterator first, InputIterator last, F f); " "template size_type insert_or_cvisit" "(InputIterator first, InputIterator last, F f); ```" #: :1104 #, safe-html, strict-same msgctxt ":1104" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等效于 [listing,subs=\"+macros,+quotes\"]" #: :1111 #, safe-html, strict-same msgctxt ":1111" msgid "Returns:;; The number of elements inserted." msgstr "返回值：插入的元素数量。" #: :1113 #, safe-html, strict-same msgctxt ":1113" msgid "---" msgstr "---" #: :1115 #, safe-html, strict-same msgid "Insert Initializer List or Visit" msgstr "初始化列表插入或访问" #: :1116 #, safe-html, strict-same msgid "" "```c++ template size_type insert_or_visit" "(std::initializer_list il, F f); template size_type " "insert_or_cvisit(std::initializer_list il, F f); ```" msgstr "" "```c++ template size_type insert_or_visit" "(std::initializer_list il, F f); template " "size_type insert_or_cvisit(std::initializer_list il, F f); ```" #: :1121 #, safe-html, strict-same msgctxt ":1121" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等效于 [listing,subs=\"+macros,+quotes\"]" #: :1128 #, safe-html, strict-same msgctxt ":1128" msgid "Returns:;; The number of elements inserted." msgstr "返回值：插入的元素个数。" #: :1130 #, safe-html, strict-same msgctxt ":1130" msgid "---" msgstr "---" #: :1132 #, safe-html, strict-same msgid "emplace_and_[c]visit" msgstr "emplace_and_[c]visit" #: :1133 #, safe-html, strict-same msgid "" "```c++ template bool emplace_and_visit" "(Args&&... args, F1&& f1, F2&& f2); template bool emplace_and_cvisit(Args&&... args, F1&& f1, F2&& f2); ```" msgstr "" "```c++ template bool " "emplace_and_visit(Args&&... args, F1&& f1, F2&& f2); " "template bool " "emplace_and_cvisit(Args&&... args, F1&& f1, F2&& f2)" "; ```" #: :1140 #, safe-html, strict-same msgid "" "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." msgstr "" "若容器中无等价键的元素，则使用参数args构造对象并插入容器，随后以新创建元素的" "非常量引用调用f1；\n" "否则，以等价元素的引用调用f2；若使用emplace_and_cvisit，则该引用为常量引用。" #: :1145 #, safe-html, strict-same msgid "" "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." msgstr "" "要求：`value_type` 可从 `args` 构造。返回：若执行了插入则返回 `true`。并发：" "在 `*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和" "引用会失效。+ +该接口仅为展示说明，因为 C++ 不允许在变参参数包之后声明参数 " "`f1` 和 `f2`。" #: :1152 #, safe-html, strict-same msgctxt ":1152" msgid "---" msgstr "---" #: :1154 #, safe-html, strict-same msgid "Copy insert_and_[c]visit" msgstr "复制 insert_and_[c]visit" #: :1155 #, safe-html, strict-same msgid "" "```c++ template bool insert_and_visit(const value_type& " "obj, F1 f1, F2 f2); template bool insert_and_cvisit" "(const value_type& obj, F1 f1, F2 f2); template bool " "insert_and_visit(const init_type& obj, F1 f1, F2 f2); template bool insert_and_cvisit(const init_type& obj, F1 f1, F2 f2); ```" msgstr "" "```c++ template bool insert_and_visit" "(const value_type& obj, F1 f1, F2 f2); template bool insert_and_cvisit(const value_type& obj, F1 f1, " "F2 f2); template bool insert_and_visit" "(const init_type& obj, F1 f1, F2 f2); template bool insert_and_cvisit(const init_type& obj, F1 f1, F2 f2); " "```" #: :1162 #, safe-html, strict-same msgctxt ":1162" msgid "" "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." msgstr "" "当且仅当容器中不存在等价键的元素时，插入obj，随后以新创建元素的非常量引用调用" "f1；\n" "否则，以等价元素的引用调用f2；若使用*_cvisit重载版本，则该引用为常量引用。" #: :1167 #, safe-html, strict-same msgid "" "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::type>::type` is " "`value_type`." msgstr "" "要求：`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&` 参数的重载仅当 " "`std::remove_cv::type>::type` 为 " "`value_type` 时才参与重载决议。" #: :1175 #, safe-html, strict-same msgctxt ":1175" msgid "---" msgstr "---" #: :1177 #, safe-html, strict-same msgid "Move insert_and_[c]visit" msgstr "移动 insert_and_[c]visit" #: :1178 #, safe-html, strict-same msgid "" "```c++ template bool insert_and_visit(value_type&& obj, " "F1 f1, F2 f2); template bool insert_and_cvisit" "(value_type&& obj, F1 f1, F2 f2); template bool " "insert_and_visit(init_type&& obj, F1 f1, F2 f2); template bool insert_and_cvisit(init_type&& obj, F1 f1, F2 f2); ```" msgstr "" "```c++ template bool insert_and_visit" "(value_type&& obj, F1 f1, F2 f2); template bool insert_and_cvisit(value_type&& obj, F1 f1, F2 f2); " "template bool insert_and_visit" "(init_type&& obj, F1 f1, F2 f2); template bool insert_and_cvisit(init_type&& obj, F1 f1, F2 f2); ```" #: :1185 #, safe-html, strict-same msgctxt ":1185" msgid "" "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." msgstr "" "当且仅当容器中不存在等价键的元素时，插入obj，随后以新创建元素的非常量引用调用" "f1；\n" "否则，以等价元素的引用调用f2；若使用*_cvisit重载版本，则该引用为常量引用。" #: :1190 #, safe-html, strict-same msgid "" "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::type` is `value_type`." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^] 要求。返回：若执行了插入则返回 `true`。并发：在 " "`*this` 的 rehash 操作上阻塞。注意：如果执行了 rehash，则指向元素的指针和引用" "会失效。+ +在形式为 `insert_and_[c]visit(obj, f1, f2)` 的调用中，接受 " "`value_type&&` 参数的重载仅当 `std::remove_reference" "::type` 为 `value_type` 时才参与重载决议。" #: :1198 #, safe-html, strict-same msgctxt ":1198" msgid "---" msgstr "---" #: :1200 #, safe-html, strict-same msgid "Insert Iterator Range and Visit" msgstr "迭代器范围插入并访问" #: :1201 #, safe-html, strict-same msgid "" "```c++ template size_type " "insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); " "template size_type insert_or_cvisit" "(InputIterator first, InputIterator last, F1 f1, F2 f2); ```" msgstr "" "```c++ template " "size_type insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 " "f2); template " "size_type insert_or_cvisit(InputIterator first, InputIterator last, F1 f1, " "F2 f2); ```" #: :1208 #, safe-html, strict-same msgctxt ":1208" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等效于 [listing,subs=\"+macros,+quotes\"]" #: :1215 #, safe-html, strict-same msgctxt ":1215" msgid "Returns:;; The number of elements inserted." msgstr "返回值：插入的元素数量。" #: :1217 #, safe-html, strict-same msgctxt ":1217" msgid "---" msgstr "---" #: :1219 #, safe-html, strict-same msgid "Insert Initializer List and Visit" msgstr "初始化列表插入并访问" #: :1220 #, safe-html, strict-same msgid "" "```c++ template size_type insert_and_visit" "(std::initializer_list il, F1 f1, F2 f2); template size_type insert_and_cvisit(std::initializer_list il, " "F1 f1, F2 f2); ```" msgstr "" "```c++ template size_type insert_and_visit" "(std::initializer_list il, F1 f1, F2 f2); template size_type insert_and_cvisit" "(std::initializer_list il, F1 f1, F2 f2); ```" #: :1227 #, safe-html, strict-same msgctxt ":1227" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等效于 [listing,subs=\"+macros,+quotes\"]" #: :1234 #, safe-html, strict-same msgctxt ":1234" msgid "Returns:;; The number of elements inserted." msgstr "返回值：插入的元素数量。" #: :1236 #, safe-html, strict-same msgctxt ":1236" msgid "---" msgstr "---" #: :1238 #, safe-html, strict-same msgid "try_emplace" msgstr "try_emplace" #: :1239 #, safe-html, strict-same msgid "" "```c++ template bool try_emplace(const key_type& k, Args&&... " "args); template bool try_emplace(key_type&& k, Args&&... args)" "; template bool try_emplace(K&& k, Args&&... args); " "```" msgstr "" "```c++ template bool try_emplace(const key_type& k, " "Args&&... args); template bool try_emplace" "(key_type&& k, Args&&... args); template bool try_emplace(K&& k, Args&&... " "args); ```" #: :1245 #, safe-html, strict-same msgid "" "Inserts an element constructed from `k` and `args` into the table if there " "is no existing element with key `k` contained within it." msgstr "若容器中不存在键为k的元素，则将由k和args构造的元素插入容器。" #: :1248 #, safe-html, strict-same msgid "" "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++" msgstr "" "返回值：插入成功则返回true。\n" "并发：对当前对象*this进行重哈希时阻塞。\n" "说明：该函数与 xref:#concurrent_flat_map_emplace [emplace] 类似，区别在于若存" "在等价键的元素，则不会构造value_type；否则，构造形式为：" #: :1256 #, safe-html, strict-same msgctxt ":1256" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" #: :1261 #, safe-html, strict-same msgctxt ":1261" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" #: :1266 #, safe-html, strict-same msgid "" "unlike xref:#concurrent_flat_map_emplace[emplace], which simply forwards all " "arguments to ``value_type``'s constructor." msgstr "" "这与 xref:#concurrent_flat_map_emplace [emplace] 不同，后者仅将所有参数转发给" "value_type的构造函数。" #: :1268 #, safe-html, strict-same msgctxt ":1268" msgid "" "Invalidates pointers and references to elements if a rehashing is issued." msgstr "" "Invalidates pointers and references to elements if a rehashing is issued." #: :1270 #, safe-html, strict-same msgid "" "The `template` 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." msgstr "" "若`Hash::is_transparent`与`Pred::is_transparent`为合法的成员类型别名，" "则`template`重载版本才会参与重载决议。库假定`Hash`可" "同时接收`K`与`Key`类型参数调用，且`Pred`为透明比较器。该设计支持异构查找，避" "免了实例化`Key`类型对象的开销。" #: :1272 #, safe-html, strict-same msgctxt ":1272" msgid "--" msgstr "--" #: :1274 #, safe-html, strict-same msgctxt ":1274" msgid "---" msgstr "---" #: :1276 #, safe-html, strict-same msgid "try_emplace_or_[c]visit" msgstr "try_emplace_or_[c]visit" #: :1277 #, safe-html, strict-same msgid "" "```c++ template bool try_emplace_or_visit(const " "key_type& k, Args&&... args, F&& f); template bool " "try_emplace_or_cvisit(const key_type& k, Args&&... args, F&& f); " "template bool try_emplace_or_visit(key_type&& k, " "Args&&... args, F&& f); template bool " "try_emplace_or_cvisit(key_type&& k, Args&&... args, F&& f); template bool try_emplace_or_visit(K&& k, Args&&... args, " "F&& f); template bool try_emplace_or_cvisit" "(K&& k, Args&&... args, F&& f); ```" msgstr "" "```c++ template bool " "try_emplace_or_visit(const key_type& k, Args&&... args, " "F&& f); template bool " "try_emplace_or_cvisit(const key_type& k, Args&&... args, " "F&& f); template bool " "try_emplace_or_visit(key_type&& k, Args&&... args, " "F&& f); template bool " "try_emplace_or_cvisit(key_type&& k, Args&&... args, " "F&& f); template bool try_emplace_or_visit(K&& k, Args&&... args, " "F&& f); template bool try_emplace_or_cvisit(K&& k, Args&&... args, " "F&& f); ```" #: :1292 #, safe-html, strict-same msgid "" "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." msgstr "" "若容器中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入容器。否则，以等" "价元素的引用调用`f`；若使用`*_cvisit`重载版本，则该引用为常量引用。" #: :1296 #, safe-html, strict-same msgctxt ":1296" msgid "" "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++" msgstr "" "返回值：插入成功则返回true。\n" "并发：对当前对象*this进行重哈希时阻塞。\n" "说明：若存在等价键的元素，则不会构造value_type；否则，构造形式为：" #: :1304 #, safe-html, strict-same msgctxt ":1304" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" #: :1309 #, safe-html, strict-same msgctxt ":1309" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" #: :1314 #, safe-html, strict-same msgctxt ":1314" msgid "" "Invalidates pointers and references to elements if a rehashing is issued." msgstr "若执行重哈希操作，将使指向元素的指针和引用失效。" #: :1316 #, safe-html, strict-same msgid "" "The interface is exposition only, as C++ does not allow to declare a " "parameter `f` after a variadic parameter pack." msgstr "该接口仅为说明性用途，因为C++不允许在可变参数包之后声明参数`f`。" #: :1318 #, safe-html, strict-same msgid "" "The `template` 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." msgstr "" "若`Hash::is_transparent`和`Pred::is_transparent`是有效的成员类型别名，" "则`template`重载版本才会参与重载" "决议。库假定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透明的。这支" "持异构查找，避免了实例化`Key`类型对象的开销。" #: :1320 #, safe-html, strict-same msgctxt ":1320" msgid "--" msgstr "--" #: :1322 #, safe-html, strict-same msgctxt ":1322" msgid "---" msgstr "---" #: :1324 #, safe-html, strict-same msgid "try_emplace_and_[c]visit" msgstr "try_emplace_and_[c]visit" #: :1325 #, safe-html, strict-same msgid "" "```c++ template bool try_emplace_and_visit" "(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template bool try_emplace_and_cvisit(const key_type& k, " "Args&&... args, F1&& f1, F2&& f2); template bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& " "f2); template bool try_emplace_and_cvisit" "(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template bool try_emplace_and_visit(K&& k, Args&&... args, " "F1&& f1, F2&& f2); template bool " "try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```" msgstr "" "```c++ template bool " "try_emplace_and_visit(const key_type& k, Args&&... args, " "F1&& f1, F2&& f2); template bool try_emplace_and_cvisit(const key_type& k, " "Args&&... args, F1&& f1, F2&& f2); template bool try_emplace_and_visit" "(key_type&& k, Args&&... args, F1&& f1, F2&& " "f2); template bool " "try_emplace_and_cvisit(key_type&& k, Args&&... args, " "F1&& f1, F2&& f2); template bool try_emplace_and_visit" "(K&& k, Args&&... args, F1&& f1, F2&& f2); " "template " "bool try_emplace_and_cvisit(K&& k, Args&&... args, " "F1&& f1, F2&& f2); ```" "" #: :1340 #, safe-html, strict-same msgid "" "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." msgstr "" "若容器中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入容器，随后以新创" "建元素的非常量引用调用`f1`；\n" "否则，以等价元素的引用调用`f2`；若使用`*_cvisit`重载版本，则该引用为常量引用" "。" #: :1345 #, safe-html, strict-same msgctxt ":1345" msgid "" "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++" msgstr "" "返回值：插入成功则返回true。\n" "并发：对当前对象*this进行重哈希时阻塞。\n" "说明：若存在等价键的元素，则不会构造value_type；否则，构造形式为：" #: :1353 #, safe-html, strict-same msgctxt ":1353" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" #: :1358 #, safe-html, strict-same msgctxt ":1358" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" #: :1363 #, safe-html, strict-same msgctxt ":1363" msgid "" "Invalidates pointers and references to elements if a rehashing is issued." msgstr "若执行重哈希操作，将使指向元素的指针和引用失效。" #: :1365 #, safe-html, strict-same msgid "" "The interface is exposition only, as C++ does not allow to declare " "parameters `f1` and `f2` after a variadic parameter pack." msgstr "该接口仅为说明性用途，因为C++不允许在可变参数包之后声明`f1`和`f2`参数。" #: :1367 #, safe-html, strict-same msgid "" "The `template` 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." msgstr "" "若`Hash::is_transparent`和`Pred::is_transparent`是有效的成员类型别名，" "则`template`重载版本才" "会参与重载决议。库假定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透" "明的。这支持异构查找，避免了实例化`Key`类型对象的开销。" #: :1369 #, safe-html, strict-same msgctxt ":1369" msgid "--" msgstr "--" #: :1371 #, safe-html, strict-same msgctxt ":1371" msgid "---" msgstr "---" #: :1373 #, safe-html, strict-same msgid "insert_or_assign" msgstr "insert_or_assign" #: :1374 #, safe-html, strict-same msgid "" "```c++ template bool insert_or_assign(const key_type& k, M&& obj); " "template bool insert_or_assign(key_type&& k, M&& obj); " "template bool insert_or_assign(K&& k, M&& obj); ```" msgstr "" "```c++ template bool insert_or_assign(const key_type& k, " "M&& obj); template bool insert_or_assign" "(key_type&& k, M&& obj); template bool insert_or_assign(K&& k, M&& obj); ```" #: :1380 #, safe-html, strict-same msgid "" "Inserts a new element into the table or updates an existing one by assigning " "to the contained value." msgstr "向容器插入新元素，或通过赋值给容器内已存值来更新现有元素。" #: :1382 #, safe-html, strict-same msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "若容器中存在键为`k`的元素，则通过`std::forward(obj)`赋值来更新该元素。" #: :1384 #, safe-html, strict-same msgid "If there is no such element, it is added to the table as: ```c++" msgstr "若不存在该元素，则将其以如下形式添加到容器中：" #: :1387 #, safe-html, strict-same msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" #: :1392 #, safe-html, strict-same msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj))) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj))) ```" #: :1398 #, safe-html, strict-same msgid "" "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` 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." msgstr "" "返回值：插入成功时返回`true`。\n" "并发：执行重哈希操作时会阻塞当前对象`*this`。\n" "说明：若触发重哈希，将使指向元素的指针和引用失效。\n" "`template` 仅当 `Hash::is_transparent` 和 " "`Pred::is_transparent` 为有效成员类型别名时才参与重载决议。库假定`Hash`可同时" "接受`K`与`Key`类型参数调用，且`Pred`是透明的。这支持异构查找，避免了实例" "化`Key`类型对象的开销。" #: :1404 #, safe-html, strict-same msgctxt ":1404" msgid "---" msgstr "---" #: :1406 #, safe-html, strict-same msgid "erase" msgstr "擦除" #: :1407 #, safe-html, strict-same msgid "" "```c++ size_type erase(const key_type& k); template size_type erase" "(const K& k); ```" msgstr "" "```c++ size_type erase(const key_type& k); template " "size_type erase(const K& k); ```" #: :1412 #, safe-html, strict-same msgid "Erases the element with key equivalent to `k` if it exists." msgstr "若存在键等价于`k`的元素，则删除该元素。" #: :1415 #, safe-html, strict-same msgid "" "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` 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." msgstr "" "返回值：删除的元素数量（0 或 1）。\n" "异常：仅当哈希函数`hasher`或键比较函数`key_equal`抛出异常时才会抛出异常。\n" "说明：仅当`Hash::is_transparent`和`Pred::is_transparent`为有效的成员类型别名" "时，`template`重载版本才参与重载决议。库假定`Hash`可同时接" "受`K`与`Key`类型的参数调用，且`Pred`是透明的。该设计支持异构查找，避免了实例" "化`Key`类型对象的开销。" #: :1419 #, safe-html, strict-same msgctxt ":1419" msgid "---" msgstr "---" #: :1421 #, safe-html, strict-same msgid "erase_if by Key" msgstr "erase_if by Key" #: :1422 #, safe-html, strict-same msgid "" "```c++ template size_type erase_if(const key_type& k, F f); " "template size_type erase_if(const K& k, F f); ```" msgstr "" "```c++ template size_type erase_if(const key_type& k, F f)" "; template size_type erase_if(const K& " "k, F f); ```" #: :1427 #, safe-html, strict-same msgid "" "Erases the element `x` with key equivalent to `k` if it exists and `f(x)` is " "`true`." msgstr "若存在键与 `k` 等价的元素 `x`，且 `f(x)` 返回 `true`，则删除该元素。" #: :1430 #, safe-html, strict-same msgid "" "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` " "overload only participates in overload resolution if " "`std::is_execution_policy_v>` is " "`false`. + + The `template` 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." msgstr "" "返回值：删除的元素数量（0 或 1）。\n" "异常：仅当哈希函数`hasher`、键比较函数`key_equal`或函数`f`抛出异常时才会抛出" "异常。\n" "说明：`f`接收元素`x`的非常量引用。\n" "\n" "仅当`std::is_execution_policy_v" ">`为`false`时，`template`重载版本才参与重" "载决议。\n" "\n" "仅当`Hash::is_transparent`和`Pred::is_transparent`为有效的成员类型别名时" "，`template`重载版本才参与重载决议。库假" "定`Hash`可同时接受`K`与`Key`类型的参数调用，且`Pred`是透明的。该设计支持异构" "查找，避免了实例化`Key`类型对象的开销。" #: :1438 #, safe-html, strict-same msgctxt ":1438" msgid "---" msgstr "---" #: :1440 #, safe-html, strict-same msgctxt ":1440" msgid "erase_if" msgstr "erase_if" #: :1441 #, safe-html, strict-same msgid "```c++ template size_type erase_if(F f); ```" msgstr "```c++ template size_type erase_if(F f); ```" #: :1445 #, safe-html, strict-same msgid "" "Successively invokes `f` with non-const references to each of the elements " "in the table, and erases those for which `f` returns `true`." msgstr "" "依次以非常量引用为参数，对容器中的每个元素调用`f`，并删除所有`f`返回`true`的" "元素。" #: :1448 #, safe-html, strict-same msgid "" "Returns:;; The number of elements erased. Throws:;; Only throws an exception " "if it is thrown by `f`." msgstr "" "返回值：被删除的元素数量。\n" "异常：仅当函数 `f` 抛出异常时才会抛出异常。" #: :1451 #, safe-html, strict-same msgctxt ":1451" msgid "---" msgstr "---" #: :1453 #, safe-html, strict-same msgid "Parallel erase_if" msgstr "并行条件擦除" #: :1454 #, safe-html, strict-same msgid "" "```c++ template void erase_if" "(ExecutionPolicy&& policy, F f); ```" msgstr "" "```c++ template void erase_if" "(ExecutionPolicy&& policy, F f); ```" #: :1458 #, safe-html, strict-same msgid "" "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." msgstr "" "依次以非常量引用为参数，对容器中的每个元素调用`f`，并删除所有`f`返回`true`的" "元素。执行过程将根据指定的执行策略语义进行并行化处理。" #: :1462 #, safe-html, strict-same msgid "" "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>` is " "`true`. + + Unsequenced execution policies are not allowed." msgstr "" "异常：根据所使用执行策略的异常处理机制，若`f`内部抛出异常，可能会调" "用`std::terminate`终止程序。\n" "说明：仅在支持C++17并行算法的编译器中可用。\n" "\n" "仅当`std::is_execution_policy_v" ">`为`true`时，该重载版本参与重载决议。\n" "\n" "不允许使用无顺序执行策略。" #: :1469 #, safe-html, strict-same msgctxt ":1469" msgid "---" msgstr "---" #: :1471 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :1472 #, safe-html, strict-same msgid "" "```c++ void swap(concurrent_flat_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); ```" msgstr "" "```c++ void swap(concurrent_flat_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); " "```" #: :1478 #, safe-html, strict-same msgid "Swaps the contents of the table with the parameter." msgstr "将当前容器的内容与参数容器进行交换。" #: :1480 #, safe-html, strict-same msgid "" "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." msgstr "" "若`Allocator::propagate_on_container_swap`已定义且其值为`true`，则交换两个容" "器的分配器；否则，使用不相等的分配器进行交换会导致未定义行为。" #: :1483 #, safe-html, strict-same msgid "" "Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. " "Concurrency:;; Blocking on `*this` and `other`." msgstr "" "异常：除非`key_equal`或`hasher`在交换时抛出异常，否则不抛出任何异常。并发：会" "阻塞当前对象`*this`和参数对象`other`。" #: :1486 #, safe-html, strict-same msgctxt ":1486" msgid "---" msgstr "---" #: :1488 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1489 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :1493 #, safe-html, strict-same msgid "Erases all elements in the table." msgstr "清空容器中的所有元素。" #: :1496 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * " "bucket_count()` Concurrency:;; Blocking on `*this`." msgstr "" "后置条件：容器大小 `size() == 0`，且 `max_load() >= max_load_factor() * " "bucket_count()`\n" "并发：会阻塞当前对象 `*this`。" #: :1499 #, safe-html, strict-same msgctxt ":1499" msgid "---" msgstr "---" #: :1501 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1502 #, safe-html, strict-same msgid "" "```c++ template size_type merge(concurrent_flat_map& source); template size_type merge" "(concurrent_flat_map&& source); ```" msgstr "" "```c++ template size_type merge" "(concurrent_flat_map& " "source); template size_type merge" "(concurrent_flat_map" "&& source); ```" #: :1509 #, safe-html, strict-same msgid "" "Move-inserts all the elements from `source` whose key is not already present " "in `*this`, and erases them from `source`." msgstr "" "将来源容器`source`中所有**键不存在于当前容器`*this`**中的元素**移动插入**到当" "前容器，并从`source`中擦除这些元素。" #: :1512 #, safe-html, strict-same msgid "" "Returns:;; The number of elements inserted. Concurrency:;; Blocking on " "`*this` and `source`." msgstr "" "返回值：插入的元素数量。\n" "并发：会阻塞当前对象 `*this` 和源对象 `source`。" #: :1515 #, safe-html, strict-same msgctxt ":1515" msgid "---" msgstr "---" #: :1517 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1519 #, safe-html, strict-same msgid "get_allocator" msgstr "get_allocator" #: :1520 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const noexcept; ```" msgstr "``` allocator_type get_allocator() const noexcept; ```" #: :1525 #, safe-html, strict-same msgid "Returns:;; The table's allocator." msgstr "返回值：容器的分配器。" #: :1527 #, safe-html, strict-same msgctxt ":1527" msgid "---" msgstr "---" #: :1529 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1530 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :1535 #, safe-html, strict-same msgid "Returns:;; The table's hash function." msgstr "返回值：容器的哈希函数。" #: :1537 #, safe-html, strict-same msgctxt ":1537" msgid "---" msgstr "---" #: :1539 #, safe-html, strict-same msgid "key_eq" msgstr "key_eq" #: :1540 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1545 #, safe-html, strict-same msgid "Returns:;; The table's key equality predicate." msgstr "返回值：容器的键相等性谓词。" #: :1547 #, safe-html, strict-same msgctxt ":1547" msgid "---" msgstr "---" #: :1549 #, safe-html, strict-same msgid "Map Operations" msgstr "映射操作" #: :1551 #, safe-html, strict-same msgid "count" msgstr "count" #: :1552 #, safe-html, strict-same msgid "" "```c++ size_type count(const key_type& k) const; template " "size_type count(const K& k) const; ```" msgstr "" "```c++ size_type count(const key_type& k) const; template size_type count(const K& k) const; ```" #: :1559 #, safe-html, strict-same msgid "" "Returns:;; The number of elements with key equivalent to `k` (0 or 1). " "Notes:;; The `template` 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." msgstr "" "返回值：匹配键 `k` 的元素数量（0 或 1）。\n" "说明：仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别" "名时，`template` 重载版本才参与重载决议。库假定哈希函数可同时作" "用于 `K` 类型与键类型，且相等谓词是透明的，从而支持异构查找，避免实例化键类型" "带来的开销。\n" "\n" "若存在并发插入操作，返回值可能无法精确反映容器执行后的真实状态。" #: :1565 #, safe-html, strict-same msgctxt ":1565" msgid "---" msgstr "---" #: :1567 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1568 #, safe-html, strict-same msgid "" "```c++ bool contains(const key_type& k) const; template " "bool contains(const K& k) const; ```" msgstr "" "```c++ bool contains(const key_type& k) const; " "template bool contains(const K& k) const; ```" #: :1575 #, safe-html, strict-same msgid "" "Returns:;; A boolean indicating whether or not there is an element with key " "equal to `k` in the table. Notes:;; The `template` 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." msgstr "" "返回值：布尔值，表示容器中是否存在键等于 `k` 的元素。\n" "说明：仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为有效成员类型别" "名时，`template` 重载版本才参与重载决议。库假定哈希函数可同时作" "用于 `K` 类型与键类型，且相等谓词是透明的，从而支持异构查找，避免实例化键类型" "带来的开销。\n" "\n" "若存在并发插入操作，返回值可能无法精确反映容器执行后的真实状态。" #: :1581 #, safe-html, strict-same msgctxt ":1581" msgid "---" msgstr "---" #: :1582 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1584 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1585 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1590 #, safe-html, strict-same msgid "Returns:;; The size of the bucket array." msgstr "返回值：桶数组的大小。" #: :1592 #, safe-html, strict-same msgctxt ":1592" msgid "---" msgstr "---" #: :1594 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1596 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1597 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1602 #, safe-html, strict-same msgid "" "Returns:;; `static_cast(size())/static_cast(bucket_count())`, " "or `0` if `bucket_count() == 0`." msgstr "" "返回值：`static_cast(size())/static_cast(bucket_count())`；若 " "`bucket_count() == 0`，则返回 `0`。" #: :1604 #, safe-html, strict-same msgctxt ":1604" msgid "---" msgstr "---" #: :1606 #, safe-html, strict-same msgid "max_load_factor" msgstr "max_load_factor（最大负载因子）" #: :1608 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1613 #, safe-html, strict-same msgid "Returns:;; Returns the table's maximum load factor." msgstr "返回值：容器的最大负载因子。" #: :1615 #, safe-html, strict-same msgctxt ":1615" msgid "---" msgstr "---" #: :1617 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1618 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1623 #, safe-html, strict-same msgid "" "Effects:;; Does nothing, as the user is not allowed to change this " "parameter. Kept for compatibility with `boost::unordered_map`." msgstr "" "效果：无任何操作，用户不允许修改此参数。保留该函数是为了与 " "`boost::unordered_map` 保持兼容。" #: :1625 #, safe-html, strict-same msgctxt ":1625" msgid "---" msgstr "---" #: :1628 #, safe-html, strict-same msgid "max_load" msgstr "max_load（最大负载）" #: :1630 #, safe-html, strict-same msgid "```c++ size_type max_load() const noexcept; ```" msgstr "```c++ size_type max_load() const noexcept; ```" #: :1635 #, safe-html, strict-same msgid "" "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." msgstr "" "返回值：容器在不进行重哈希的前提下可容纳的最大元素数量（假定不会再擦除任何元" "素）。\n" "说明：容器在构造、重哈希或清空后，其最大负载量至少为 `max_load_factor() * " "bucket_count()`。在高负载条件下执行擦除操作时，该数值可能会降低。\n" "若存在并发插入操作，返回值可能无法精确反映容器执行后的真实状态。" #: :1642 #, safe-html, strict-same msgctxt ":1642" msgid "---" msgstr "---" #: :1644 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1645 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1649 #, safe-html, strict-same msgid "" "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." msgstr "" "效果：必要时调整桶数组的大小，使桶数量至少为 `n`，且负载因子小于等于最大负载" "因子。\n" "适用场景下，该操作会**增大或缩小**容器的桶数量 `bucket_count()`。" #: :1651 #, safe-html, strict-same msgid "" "When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array." msgstr "当容器大小 `size() == 0` 时，调用 `rehash(0)` 会**释放底层的桶数组内存**。" #: :1653 #, safe-html, strict-same msgctxt ":1653" msgid "" "Invalidates pointers and references to elements, and changes the order of " "elements." msgstr "会使指向元素的指针和引用失效，并改变元素的存储顺序。" #: :1656 #, safe-html, strict-same msgid "" "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`. ---" msgstr "" "异常：若抛出异常，函数无任何效果（由容器的哈希函数或比较函数抛出的异常除外）" "。\n" "并发：阻塞当前对象 `*this`。" #: :1660 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1661 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1665 #, safe-html, strict-same msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`." msgstr "等价于 `a.rehash(ceil(n / a.max_load_factor()))`。" #: :1667 #, safe-html, strict-same msgid "" "Similar to `rehash`, this function can be used to grow or shrink the number " "of buckets in the table." msgstr "与 `rehash` 功能类似，该函数可用于**增大或缩小**容器的桶数量。" #: :1669 #, safe-html, strict-same msgctxt ":1669" msgid "" "Invalidates pointers and references to elements, and changes the order of " "elements." msgstr "会使指向元素的指针和引用失效，并改变元素的存储顺序。" #: :1672 #, safe-html, strict-same msgid "" "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`." msgstr "" "异常：若抛出异常，函数无任何效果（由容器的哈希函数或比较函数抛出的异常除外）" "。\n" "并发：阻塞当前对象 `*this`。" #: :1675 #, safe-html, strict-same msgctxt ":1675" msgid "---" msgstr "---" #: :1677 #, safe-html, strict-same msgid "Statistics" msgstr "统计信息" #: :1679 #, safe-html, strict-same msgid "get_stats" msgstr "get_stats" #: :1680 #, safe-html, strict-same msgid "```c++ stats get_stats() const; ```" msgstr "```c++ stats get_stats() const; ```" #: :1685 #, safe-html, strict-same msgid "" "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]." msgstr "" "返回值：容器截至目前执行的插入与查找操作的统计描述信息。\n" "说明：仅当**启用统计计算**时，该函数才可用。" #: :1688 #, safe-html, strict-same msgctxt ":1688" msgid "---" msgstr "---" #: :1690 #, safe-html, strict-same msgid "reset_stats" msgstr "reset_stats" #: :1691 #, safe-html, strict-same msgid "```c++ void reset_stats() noexcept; ```" msgstr "```c++ void reset_stats() noexcept; ```" #: :1696 #, safe-html, strict-same msgid "" "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]." msgstr "" "效果：将容器维护的内部统计数据归零。\n" "说明：仅当**启用统计计算**时，该函数才可用。" #: :1699 #, safe-html, strict-same msgctxt ":1699" msgid "---" msgstr "---" #: :1701 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1702 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "满足以下任一条件时，推导指引不参与重载决议：" #: :1704 #, safe-html, strict-same msgid "" "- 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." msgstr "" "- 该推导指引包含 `InputIterator` 模板参数，且为此参数推导出的类型不符合输入迭" "代器的要求。 - 该推导指引包含 `Allocator` 模板参数，且为该参数推导出的类型不" "符合分配器要求。 - 该推导指引包含 `Hash` 模板参数，且为该参数推导出的类型为整" "型或符合分配器要求。 - 该推导指引包含 `Pred` 模板参数，且为该参数推导出的类型" "符合分配器要求。" #: :1709 #, safe-html, strict-same msgid "" "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." msgstr "" "推导指引中的 `size++_++type` 参数类型，指向由该推导指引所推导容器类型的 " "`size++_++type` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1713 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "_iter-value-type_" #: :1721 #, safe-html, strict-same msgid "__iter-key-type__" msgstr "__iter-key-type__" #: :1729 #, safe-html, strict-same msgid "__iter-mapped-type__" msgstr "__iter-mapped-type__" #: :1737 #, safe-html, strict-same msgid "__iter-to-alloc-type__" msgstr "__iter-to-alloc-type__" #: :1746 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1748 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1749 #, safe-html, strict-same msgid "" "```c++ template " "bool operator==(const concurrent_flat_map& x, " "const concurrent_flat_map& y); ```" msgstr "" "```c++ template bool operator==(const concurrent_flat_map& x, const concurrent_flat_map& y); ```" #: :1755 #, safe-html, strict-same msgid "" "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)." msgstr "" "若 `x.size() == y.size()`，且对于 `x` 中的每个元素，`y` 中均存在拥有相同键、" "值相等（使用 `operator==` 比较值类型）的元素，则返回 `true`。" #: :1758 #, safe-html, strict-same msgctxt ":1758" msgid "" "Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if " "the two tables don't have equivalent equality predicates." msgstr "" "并发：阻塞 `x` 和 `y`。\n" "说明：若两个容器的相等判断谓词不一致，行为未定义。" #: :1761 #, safe-html, strict-same msgctxt ":1761" msgid "---" msgstr "---" #: :1763 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1764 #, safe-html, strict-same msgid "" "```c++ template " "bool operator!=(const concurrent_flat_map& x, " "const concurrent_flat_map& y); ```" msgstr "" "```c++ template bool operator!=(const concurrent_flat_map& x, const concurrent_flat_map& y); ```" #: :1770 #, safe-html, strict-same msgid "" "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)." msgstr "" "若`x.size() == y.size()`，且`x`中每个元素在`y`中都存在键相同、值相等（使" "用`operator==`比较值类型）的元素，则返回`false`。" #: :1773 #, safe-html, strict-same msgctxt ":1773" msgid "" "Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if " "the two tables don't have equivalent equality predicates." msgstr "" "并发：阻塞`x`和`y`。\n" "说明：若两个容器的相等判定谓词不一致，则行为未定义。" #: :1776 #, safe-html, strict-same msgctxt ":1776" msgid "---" msgstr "---" #: :1778 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1779 #, safe-html, strict-same msgid "" "```c++ template " "void swap(concurrent_flat_map& x, " "concurrent_flat_map& y) noexcept(noexcept(x.swap" "(y))); ```" msgstr "" "```c++ template void swap(concurrent_flat_map& x, concurrent_flat_map& y) noexcept(noexcept(x.swap(y))); ```" #: :1786 #, safe-html, strict-same msgctxt ":1786" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1792 #, safe-html, strict-same msgctxt ":1792" msgid "---" msgstr "---" #: :1794 #, safe-html, strict-same msgctxt ":1794" msgid "erase_if" msgstr "erase_if" #: :1795 #, safe-html, strict-same msgid "" "```c++ template typename concurrent_flat_map::size_type erase_if" "(concurrent_flat_map& c, Predicate pred); ```" msgstr "" "```c++ template typename concurrent_flat_map::size_type erase_if(concurrent_flat_map& c, Predicate pred); ```" #: :1801 #, safe-html, strict-same msgctxt ":1801" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1807 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1809 #, safe-html, strict-same msgid "" "``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." msgstr "" "`concurrent++_++flat++_++map` 可通过本组件库提供的 API，借助 link:../../../" "../../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归" "档与 XML 归档两种格式。" #: :1813 #, safe-html, strict-same msgid "Saving an concurrent_flat_map to an archive" msgstr "将concurrent++_++flat++_++map保存到归档" #: :1815 #, safe-html, strict-same msgid "" "Saves all the elements of a `concurrent_flat_map` `x` to an archive (XML " "archive) `ar`." msgstr "" "将 `concurrent++_++flat++_++map` 容器 `x` 的所有元素保存到归档（XML归档） " "`ar` 中。" #: :1818 #, safe-html, strict-same msgid "" "Requires:;; `std::remove_const::type` and " "`std::remove_const::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`." msgstr "" "要求：`std::remove_const::type` 和 `std::remove_const" "::type` 必须是可序列化的（支持 XML 序列化），并且它们支持 " "Boost.Serialization 的 `save_construct_data` / `load_construct_data` 协议（" "https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构" "造^] 类型自动支持该协议）。并发：阻塞 `x`。" #: :1825 #, safe-html, strict-same msgctxt ":1825" msgid "---" msgstr "---" #: :1827 #, safe-html, strict-same msgid "Loading an concurrent_flat_map from an archive" msgstr "从归档加载concurrent++_++flat++_++map" #: :1829 #, safe-html, strict-same msgid "" "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`." msgstr "" "删除 `concurrent++_++flat++_++map` 容器 `x` 中所有已存在的元素，并从归档（" "XML 归档） `ar` 中插入原始 `concurrent++_++flat++_++map` 容器 `other` 的元素" "副本，这些副本是从 `ar` 所读取的存储中恢复的。" #: :1834 #, safe-html, strict-same msgid "" "Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()" "`. Concurrency:;; Blocking on `x`." msgstr "" "要求;; `x.key++_++equal()` 需要在功能上等价于 `other.key++_++equal()` 。 并发" "性;; 阻塞于 `x` 。"