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-07 04:08+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_node_set]" msgstr "[#concurrent_node_set]" #: :2 #, safe-html, strict-same msgid "Class Template concurrent_node_set" msgstr "类模板 concurrent++_++node++_++set" #: :4 #, safe-html, strict-same msgid ":idprefix: concurrent_node_set_" msgstr ":idprefix: concurrent_node_set_" #: :6 #, safe-html, strict-same msgid "" "`boost::concurrent_node_set` — A node-based hash table that stores unique " "values and allows for concurrent element insertion, erasure, lookup and " "access without external synchronization mechanisms." msgstr "" "`boost::concurrent++_++node++_++set` —— 一种基于节点的哈希表，用于存储唯一值" "，并允许在无外部同步机制的情况下并发执行元素插入、擦除、查找和访问操作。" #: :10 #, safe-html, strict-same msgid "" "Even though it acts as a container, `boost::concurrent_node_set` 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 is done " "through user-provided _visitation functions_ that are passed to " "`concurrent_node_set` operations where they are executed internally in a " "controlled fashion. Such visitation-based API allows for low-contention " "concurrent usage scenarios." msgstr "" "尽管 `boost::concurrent++_++node++_++set` 的行为类似于容器，但它并不符合标准 " "C{plus}{plus} https://en.cppreference.com/w/cpp/named_req/Container[容器] 概" "念。具体而言，它不提供迭代器及相关操作（如 `begin` 、 `end` 等）。元素的访问" "通过用户提供的 _访问函数_ 实现，这些函数被传递至 " "`concurrent++_++node++_++set` 的内部操作，并以受控方式执行。这种基于访问的 " "API 设计支持低竞争度的并发使用场景。" #: :17 #, safe-html, strict-same msgid "" "The internal data structure of `boost::concurrent_node_set` is similar to " "that of `boost::unordered_node_set`. Unlike `boost::concurrent_flat_set`, " "pointer stability and node handling functionalities are provided, at the " "expense of potentially lower performance." msgstr "" "`boost::concurrent++_++node++_++set` 的内部数据结构与 " "`boost::unordered++_++node++_++set` 类似。与 " "`boost::concurrent++_++flat++_++set` 不同，它提供了指针稳定性和节点处理功能，" "但可能以性能降低为代价。" #: :21 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :296 #, safe-html, strict-same msgctxt ":296" msgid "---" msgstr "---" #: :298 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :300 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :303 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :303 #, safe-html, strict-same msgid "" "`Key` must be https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^] into the container" msgstr "`Key` 必须满足可移动插入要求，即能够被" #: :307 #, safe-html, strict-same msgid "" "and https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the " "container." msgstr "" "https://en.cppreference.com/w/cpp/named_req/MoveInsertable[可移动插入] 到容器" "中的要求，且需满足从容器中 https://en.cppreference.com/w/cpp/named_req/" "Erasable[可擦除] 的要求。" #: :309 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :309 #, 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`" #: :309 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :309 #, 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类型的值。" #: :309 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :309 #, safe-html, strict-same msgid "An allocator whose value type is the same as the table's value type." msgstr "值类型与该表的值类型相同的分配器。" #: :317 #, safe-html, strict-same msgid "" "`std::allocator_traits::pointer` and " "`std::allocator_traits::const_pointer` must be convertible to/" "from `value_type*` and `const value_type*`, respectively." msgstr "" "`std::allocator_traits::pointer` 与 " "`std::allocator_traits::const_pointer` 必须分别可与 `value_type*` " "和 `const value_type*` 相互转换。" #: :322 #, safe-html, strict-same msgid "" "The element nodes of the table are held into an internal _bucket array_. An " "node is inserted into a bucket determined by the hash code of its element, " "but if the bucket is already occupied (a _collision_), an available one in " "the vicinity of the original position is used." msgstr "" "该表的元素节点存储于内部**桶数组**中。节点会根据其元素的哈希值插入到对应的桶" "内；若该桶已被占用（即发生**哈希冲突**），则使用原位置附近的可用桶进行存储。" #: :326 #, 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" "()`，仅在容器尺寸极小时，实现可能允许负载因子略高于该值。" #: :331 #, 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]::value` 为 " "`true`，则直接使用原哈希函数；否则会添加一个位混合后置处理阶段，以额外计算开" "销为代价提升哈希质量。" #: :335 #, safe-html, strict-same msgctxt ":335" msgid "---" msgstr "---" #: :337 #, safe-html, strict-same msgid "Concurrency Requirements and Guarantees" msgstr "并发要求与保证" #: :339 #, 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` 上并发调用以下操作时不得引入数据竞争：" #: :344 #, safe-html, strict-same msgid "Copy construction from `al` of an allocator rebound from `Alloc`" msgstr "从 `al` 复制构造重新绑定的分配器" #: :345 #, safe-html, strict-same msgid "`std::allocator_traits::allocate`" msgstr "`std::allocator++_++traits++<++Alloc++>++::allocate`" #: :346 #, safe-html, strict-same msgid "`std::allocator_traits::deallocate`" msgstr "`std::allocator++_++traits++<++Alloc++>++::deallocate`" #: :347 #, safe-html, strict-same msgid "`std::allocator_traits::construct`" msgstr "`std::allocator++_++traits++<++Alloc++>++::construct`" #: :348 #, safe-html, strict-same msgid "`std::allocator_traits::destroy`" msgstr "`std::allocator++_++traits++<++Alloc++>++::destroy`" #: :350 #, 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` 这些类型不包含状态，或其操作仅涉" "及对内部数据成员的常量访问，即可满足上述要求。" #: :353 #, safe-html, strict-same msgid "" "With the exception of destruction, concurrent invocations of any operation " "on the same instance of a `concurrent_node_set` do not introduce data races " "— that is, they are thread-safe." msgstr "" "除析构操作外，对同一 `concurrent++_++node++_++set` 实例并发调用任何操作均不会" "引入数据竞争——即这些操作是线程安全的。" #: :356 #, 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_node_set`, prior blocking " "operations on `x` synchronize with *op*. So, blocking operations on the same " "`concurrent_node_set` execute sequentially in a multithreaded scenario." msgstr "" "若某个操作 *op* 被显式指定为__阻塞于__ `x` （其中 `x` 为 " "`boost::concurrent++_++node++_++set` 实例），则先前对 `x` 的阻塞操作将与 " "*op* 同步。因此，在多线程场景中，对同一 `concurrent++_++node++_++set` 的阻塞" "操作将按顺序执行。" #: :360 #, 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`_ 的重" "哈希过程__。" #: :363 #, safe-html, strict-same msgid "" "When executed internally by a `boost::concurrent_node_set`, the following " "operations by a user-provided visitation function on the element passed do " "not introduce data races:" msgstr "" "当由 `boost::concurrent++_++node++_++set` 内部执行时，用户提供的访问函数对传" "递的元素执行以下操作不会引入数据竞争：" #: :366 #, safe-html, strict-same msgid "Read access to the element." msgstr "对元素的读取访问。" #: :367 #, safe-html, strict-same msgid "Non-mutable modification of the element." msgstr "对元素的非可变修改。" #: :368 #, safe-html, strict-same msgid "Mutable modification of the element:" msgstr "对元素的可变修改：" #: :369 #, 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` 的非常量容器函数中，此条件适用于最后一个（或唯一一个）访问函" "数。" #: :372 #, safe-html, strict-same msgid "" "Any `boost::concurrent_node_set operation` that inserts or modifies an " "element `e` synchronizes with the internal invocation of a visitation " "function on `e`." msgstr "" "任何插入或修改元素 `e` 的 `boost::concurrent++_++node++_++set` 操作均与在 " "`e` 上内部调用的访问函数同步。" #: :375 #, safe-html, strict-same msgid "" "Visitation functions executed by a `boost::concurrent_node_set` `x` are not " "allowed to invoke any operation on `x`; invoking operations on a different " "`boost::concurrent_node_set` instance `y` is allowed only if concurrent " "outstanding operations on `y` do not access `x` directly or indirectly." msgstr "" "由 `boost::concurrent++_++node++_++set` `x` 执行的访问函数不得调用 `x` 上的任" "何操作；仅当对另一 `boost::concurrent++_++node++_++set` 实例 `y` 的并发未完成" "操作不直接或间接访问 `x` 时，才允许调用 `y` 上的操作。" #: :379 #, safe-html, strict-same msgctxt ":379" msgid "---" msgstr "---" #: :381 #, safe-html, strict-same msgid "Configuration Macros" msgstr "配置宏" #: :383 #, safe-html, strict-same msgid "`BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK`" msgstr "`BOOST++_++UNORDERED++_++DISABLE++_++REENTRANCY++_++CHECK`" #: :385 #, 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` 发出信号。若需关注运行时速度，可通过全局" "定义此宏来禁用该功能。" #: :392 #, safe-html, strict-same msgctxt ":392" msgid "---" msgstr "---" #: :394 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_STATS`" msgstr "`BOOST++_++UNORDERED++_++ENABLE++_++STATS`" #: :396 #, 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[统计计算] 功能。请注" "意，此选项会降低多数操作的总体性能。" #: :399 #, safe-html, strict-same msgctxt ":399" msgid "---" msgstr "---" #: :401 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :408 #, safe-html, strict-same msgid "" "A class for holding extracted table elements, modelling https://" "en.cppreference.com/w/cpp/container/node_handle[NodeHandle]." msgstr "" "用于保存提取的表元素的类，建模为 https://en.cppreference.com/w/cpp/container/" "node_handle[NodeHandle] 。" #: :411 #, safe-html, strict-same msgctxt ":411" msgid "---" msgstr "---" #: :418 #, safe-html, strict-same msgid "A specialization of an internal class template:" msgstr "内部类模板的特化：" #: :430 #, safe-html, strict-same msgid "with `NodeType` = `node_type`." msgstr "其中 `NodeType` = `node++_++type` 。" #: :432 #, safe-html, strict-same msgctxt ":432" msgid "---" msgstr "---" #: :434 #, safe-html, strict-same msgid "Constants" msgstr "常量" #: :436 #, safe-html, strict-same msgid "```cpp static constexpr size_type bulk_visit_size; ```" msgstr "```cpp static constexpr size_type bulk_visit_size; ```" #: :440 #, safe-html, strict-same msgid "" "Chunk size internally used in xref:concurrent_node_set_bulk_visit[bulk " "visit] operations." msgstr "xref:concurrent_node_set_bulk_visit[批量遍历]操作内部使用的块大小。" #: :442 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :444 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :445 #, safe-html, strict-same msgid "```c++ concurrent_node_set(); ```" msgstr "```c++ concurrent_node_set(); ```" #: :449 #, 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()` 作为分配器。" #: :453 #, safe-html, strict-same msgctxt ":453" 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[DefaultConstructible^]。" #: :456 #, safe-html, strict-same msgctxt ":456" msgid "---" msgstr "---" #: :458 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :459 #, safe-html, strict-same msgid "" "```c++ explicit concurrent_node_set(size_type n, const hasher& hf = hasher()" ", const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" msgstr "" "```c++ explicit concurrent_node_set(size_type n, const hasher& hf = " "hasher(), const key_equal& eql = key_equal(), const allocator_type& " "a = allocator_type()); ```" #: :466 #, 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` 作为分配器。" #: :470 #, safe-html, strict-same msgctxt ":470" 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[DefaultConstructible^]。" #: :473 #, safe-html, strict-same msgctxt ":473" msgid "---" msgstr "---" #: :475 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :486 #, 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)` 范围内的元素插入其中。" #: :489 #, safe-html, strict-same msgctxt ":489" 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[可默" "认构造] 要求。" #: :491 #, safe-html, strict-same msgctxt ":491" msgid "---" msgstr "---" #: :493 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :494 #, safe-html, strict-same msgid "```c++ concurrent_node_set(concurrent_node_set const& other); ```" msgstr "```c++ concurrent_node_set(concurrent_node_set const& other); ```" #: :498 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate and allocator." msgstr "复制构造函数。复制容器内的元素、哈希函数、谓词以及分配器。" #: :500 #, 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` 存在且签名正确，则分配" "器将由其返回值构造。" #: :503 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on " "`other`." msgstr "" "要求：;; `value_type` 是可复制构造的\n" "并发特性：;; 阻塞 `other`" #: :506 #, safe-html, strict-same msgctxt ":506" msgid "---" msgstr "---" #: :508 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :509 #, safe-html, strict-same msgid "```c++ concurrent_node_set(concurrent_node_set&& other); ```" msgstr "```c++ concurrent_node_set(concurrent_node_set&& other); ```" #: :513 #, 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_node_set_boost_unordered_enable_stats[enabled], transfers " "the internal statistical information from `other` and calls " "`other.reset_stats()`." msgstr "" "移动构造函数。`other` 的内部桶数组会直接转移到新容器中。哈希函数、谓词和分配" "器均从 `other` 移动构造而来。若启用了统计功能，会从 `other` 转移内部统计信息" "，并调用 `other.reset_stats()`。" #: :519 #, safe-html, strict-same msgctxt ":519" msgid "Concurrency:;; Blocking on `other`." msgstr "并发特性：;; 阻塞 `other`" #: :521 #, safe-html, strict-same msgctxt ":521" msgid "---" msgstr "---" #: :523 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器范围构造函数" #: :524 #, safe-html, strict-same msgid "" "```c++ template concurrent_node_set(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template concurrent_node_set(InputIterator " "f, InputIterator l, const allocator_type& a); ```" #: :529 #, 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)` 范围内的元素插入其中。" #: :532 #, safe-html, strict-same msgctxt ":532" 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[DefaultConstructible^]。" #: :534 #, safe-html, strict-same msgctxt ":534" msgid "---" msgstr "---" #: :536 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :537 #, safe-html, strict-same msgid "```c++ explicit concurrent_node_set(Allocator const& a); ```" msgstr "```c++ explicit concurrent_node_set(Allocator const& a); ```" #: :541 #, safe-html, strict-same msgid "Constructs an empty table, using allocator `a`." msgstr "构造一个空容器，使用分配器 `a`。" #: :543 #, safe-html, strict-same msgctxt ":543" msgid "---" msgstr "---" #: :545 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :546 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(concurrent_node_set const& other, Allocator " "const& a); ```" msgstr "" "```c++ concurrent_node_set(concurrent_node_set const& other, Allocator " "const& a); ```" #: :550 #, safe-html, strict-same msgid "" "Constructs a table, copying ``other``'s contained elements, hash function, " "and predicate, but using allocator `a`." msgstr "构造一个容器，复制 `other` 中的元素、哈希函数和谓词，但使用分配器 `a`。" #: :553 #, safe-html, strict-same msgctxt ":553" msgid "Concurrency:;; Blocking on `other`." msgstr "并发特性：;; 阻塞 `other`" #: :555 #, safe-html, strict-same msgctxt ":555" msgid "---" msgstr "---" #: :557 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :558 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(concurrent_node_set&& other, Allocator const& a); " "```" msgstr "" "```c++ concurrent_node_set(concurrent_node_set&& other, Allocator " "const& a); ```" #: :562 #, 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_node_set_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" "若启用了统计功能：仅当 `a == other.get_allocator()` 时，从 `other` 转移内部统" "计信息；**始终调用** `other.reset_stats()`。" #: :570 #, safe-html, strict-same msgctxt ":570" msgid "Concurrency:;; Blocking on `other`." msgstr "并发特性：;; 阻塞 `other`" #: :572 #, safe-html, strict-same msgctxt ":572" msgid "---" msgstr "---" #: :574 #, safe-html, strict-same msgid "Move Constructor from unordered_node_set" msgstr "从 unordered++_++node++_++set 的移动构造函数" #: :576 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(unordered_node_set&& " "other); ```" msgstr "" "```c++ concurrent_node_set(unordered_node_set&& other); ```" #: :580 #, safe-html, strict-same msgid "" "Move construction from a xref:#unordered_node_set[`unordered_node_set`]. 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_node_set_boost_unordered_enable_stats[enabled], transfers " "the internal statistical information from `other` and calls " "`other.reset_stats()`." msgstr "" "从xref:#unordered_node_set[`unordered_node_set`]执行移动构造。`other`的内部桶" "数组直接转移至新容器。哈希函数、谓词及分配器均从`other`移动构造。若启用" "xref:concurrent_node_set_boost_unordered_enable_stats[统计功能]，则" "从`other`转移内部统计信息，并调用`other.reset_stats()`。" #: :587 #, safe-html, strict-same msgid "Complexity:;; O(`bucket_count()`)" msgstr "复杂度：;; O(`bucket_count()`)" #: :589 #, safe-html, strict-same msgctxt ":589" msgid "---" msgstr "---" #: :591 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :601 #, 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` 中的元素插入其中。" #: :604 #, safe-html, strict-same msgctxt ":604" 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[可默" "认构造] 要求。" #: :606 #, safe-html, strict-same msgctxt ":606" msgid "---" msgstr "---" #: :608 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :609 #, safe-html, strict-same msgid "```c++ concurrent_node_set(size_type n, allocator_type const& a); ```" msgstr "" "```c++ concurrent_node_set(size_type n, allocator_type const& a); ```" #: :613 #, 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` 作为分配器。" #: :616 #, 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[DefaultConstructible^]。" #: :619 #, safe-html, strict-same msgctxt ":619" msgid "---" msgstr "---" #: :621 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :622 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(size_type n, hasher const& hf, allocator_type " "const& a); ```" msgstr "" "```c++ concurrent_node_set(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :626 #, 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` 作为分配器。" #: :629 #, 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[DefaultConstructible^]。" #: :632 #, safe-html, strict-same msgctxt ":632" msgid "---" msgstr "---" #: :634 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :641 #, 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)` 范围内的元素插入其中。" #: :644 #, safe-html, strict-same msgctxt ":644" 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[可默认构造] 要求。" #: :646 #, safe-html, strict-same msgctxt ":646" msgid "---" msgstr "---" #: :648 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :656 #, 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)` 范围内的元素插入其中。" #: :659 #, safe-html, strict-same msgctxt ":659" 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[可默认构造] 要求。" #: :661 #, safe-html, strict-same msgctxt ":661" msgid "---" msgstr "---" #: :663 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :665 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ concurrent_node_set(std::initializer_list il, const " "allocator_type& a); ```" #: :669 #, 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`中的元素插" "入其中。" #: :672 #, safe-html, strict-same msgctxt ":672" 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[DefaultConstructible^]。" #: :674 #, safe-html, strict-same msgctxt ":674" msgid "---" msgstr "---" #: :676 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :678 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(std::initializer_list il, size_type " "n, const allocator_type& a); ```" msgstr "" "```c++ concurrent_node_set(std::initializer_list il, size_type " "n, const allocator_type& a); ```" #: :682 #, 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` 中的元素插入其中。" #: :685 #, safe-html, strict-same msgctxt ":685" 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[DefaultConstructible^]。" #: :687 #, safe-html, strict-same msgctxt ":687" msgid "---" msgstr "---" #: :689 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :691 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set(std::initializer_list il, size_type " "n, const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ concurrent_node_set(std::initializer_list il, size_type " "n, const hasher& hf, const allocator_type& a); ```" #: :696 #, 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` 中的元素插入其中。" #: :699 #, safe-html, strict-same msgctxt ":699" 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[DefaultConstructible^]。" #: :701 #, safe-html, strict-same msgctxt ":701" msgid "---" msgstr "---" #: :703 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :705 #, safe-html, strict-same msgid "```c++ ~concurrent_node_set(); ```" msgstr "```c++ ~concurrent_node_set(); ```" #: :710 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：;; 析构函数会作用于所有元素，且所有内存都会被释放" #: :712 #, safe-html, strict-same msgctxt ":712" msgid "---" msgstr "---" #: :714 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :716 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :718 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set& operator=(concurrent_node_set const& other); ```" msgstr "" "```c++ concurrent_node_set& operator=(concurrent_node_set const& " "other); ```" #: :722 #, 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`存在" "且`Alloc::propagate_on_container_copy_assignment::value`为`true`，则" "从`other`复制赋值分配器；最后插入`other`元素的副本。" #: :727 #, 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[CopyInsertable^]\n" "并发：;; 阻塞于 `*this` 和 `other`。" #: :730 #, safe-html, strict-same msgctxt ":730" msgid "---" msgstr "---" #: :732 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :733 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set& operator=(concurrent_node_set&& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::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_node_set_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_node_set& operator=(concurrent_node_set&& " "other) noexcept(boost::allocator_traits::is_always_equal::value " "|| boost::allocator_traits" "::propagate_on_container_move_assignment::value); ```\n" "移动赋值运算符。销毁先前存在的元素，交换other的哈希函数与谓词；若" "Alloc::propagate_on_container_move_assignment存在且" "Alloc::propagate_on_container_move_assignment::value为true，则移动赋值other的" "分配器。若此时分配器与other.get_allocator()相等，直接将other的内部桶数组转移" "至*this；否则插入other元素的移动构造副本。若启用 " "xref:concurrent_node_set_boost_unordered_enable_stats [统计功能]，当且仅当最" "终分配器与other.get_allocator()相等时，从other转移内部统计信息，且始终调用" "other.reset_stats()。" #: :747 #, safe-html, strict-same msgid "Concurrency:;; Blocking on `*this` and `other`." msgstr "并发：;; 阻塞于 `*this` 和 `other`。" #: :749 #, safe-html, strict-same msgctxt ":749" msgid "---" msgstr "---" #: :751 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :752 #, safe-html, strict-same msgid "" "```c++ concurrent_node_set& operator=(std::initializer_list il); " "```" msgstr "" "```c++ concurrent_node_set& operator=(std::initializer_list " "il); ```" #: :756 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All previously existing elements are " "destroyed." msgstr "通过初始化列表中的值赋值。所有先前存在的元素都会被销毁。" #: :759 #, 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[CopyInsertable^]\n" "并发：;; 阻塞于 `*this`。" #: :762 #, safe-html, strict-same msgctxt ":762" msgid "---" msgstr "---" #: :764 #, safe-html, strict-same msgid "Visitation" msgstr "访问操作" #: :766 #, safe-html, strict-same msgid "[c]visit" msgstr "[c]visit" #: :768 #, 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; ```" #: :777 #, safe-html, strict-same msgid "" "If an element `x` exists with key equivalent to `k`, invokes `f` with a " "const reference to `x`." msgstr "若存在键与 `k` 等价的元素 `x`，则使用指向 `x` 的常量引用调用 `f`。" #: :780 #, 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" "注意：;; 仅当 `Hash::is_transparent` 与 `Pred::is_transparent` 为合法成员别名" "时，`template` 重载版本才会参与重载决议。库" "假定 `Hash` 可同时用于 `K` 与 `Key` 类型，且 `Pred` 是透明的。这支持异构查找" "，避免了实例化 `Key` 类型对象的开销。" #: :783 #, safe-html, strict-same msgctxt ":783" msgid "---" msgstr "---" #: :785 #, safe-html, strict-same msgid "Bulk visit" msgstr "批量访问" #: :787 #, 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; ```" #: :796 #, 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 const " "reference to `x`." msgstr "" "对范围 ++[++`first`, `last`) 内的每个元素 `k` ，若容器中存在键等价于 `k` 的元" "素 `x` ，则使用指向 `x` 的常量引用调用 `f` 。" #: :800 #, safe-html, strict-same msgid "" "Although functionally equivalent to individually invoking " "xref:concurrent_node_set_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_node_set_constants[`bulk_visit_size`] to enjoy a " "performance gain: beyond this size, performance is not expected to increase " "further." msgstr "" "尽管功能上等同于对每个键单独调用 `[c]visit`，但批量访问因内部优化通常性能更高" "。建议 `std::distance(first,last)` 至少达到 `bulk_visit_size` 以获得性能提升" "；超过该大小后，性能预计不会进一步提升。" #: :809 #, 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` 是传统前向迭代器（C++11 至 C++17），或满足 " "`std::forward_iterator` 概念（C++20 及更高版本）。对于 `K = " "std::iterator_traits::value_type`，要么 `K` 是 `key_type`，要么 " "`Hash::is_transparent` 和 `Pred::is_transparent` 是合法的成员别名。在后一种情" "况下，库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，且 `Pred` 是透明的。这" "支持异构查找，避免了实例化 `Key` 类型对象的开销。返回值：;; 被访问的元素数量" "。" #: :818 #, safe-html, strict-same msgctxt ":818" msgid "---" msgstr "---" #: :820 #, safe-html, strict-same msgid "[c]visit_all" msgstr "[c]visit_all" #: :822 #, 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; ```" #: :828 #, safe-html, strict-same msgid "" "Successively invokes `f` with const references to each of the elements in " "the table." msgstr "依次以表中每个元素的常量引用调用 `f`。" #: :831 #, safe-html, strict-same msgid "Returns:;; The number of elements visited." msgstr "返回值：;; 被访问的元素数量。" #: :833 #, safe-html, strict-same msgctxt ":833" msgid "---" msgstr "---" #: :835 #, safe-html, strict-same msgid "Parallel [c]visit_all" msgstr "并行 ++[++c++]++visit++_++all" #: :837 #, 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; ```" #: :843 #, safe-html, strict-same msgid "" "Invokes `f` with const references to each of the elements in the table. " "Execution is parallelized according to the semantics of the execution policy " "specified." msgstr "" "以表中每个元素的常量引用调用 `f`。执行过程会根据指定执行策略的语义进行并行化" "。" #: :847 #, 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" "不允许使用无顺序执行策略。" #: :854 #, safe-html, strict-same msgctxt ":854" msgid "---" msgstr "---" #: :856 #, safe-html, strict-same msgid "[c]visit_while" msgstr "[c]visit_while" #: :858 #, 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; ```" #: :864 #, safe-html, strict-same msgid "" "Successively invokes `f` with const references to each of the elements in " "the table until `f` returns `false` or all the elements are visited." msgstr "" "依次以表中每个元素的常量引用调用 `f`，直到 `f` 返回 `false` 或遍历完所有元素" "。" #: :868 #, safe-html, strict-same msgid "Returns:;; `false` iff `f` ever returns `false`." msgstr "返回值：;; 当且仅当 `f` 返回过 `false` 时，返回 `false`。" #: :870 #, safe-html, strict-same msgctxt ":870" msgid "---" msgstr "---" #: :872 #, safe-html, strict-same msgid "Parallel [c]visit_while" msgstr "并行 ++[++c++]++visit++_++while" #: :874 #, 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; ```" #: :880 #, safe-html, strict-same msgid "" "Invokes `f` with const references to each of the elements in the table until " "`f` returns `false` or all the elements are visited. Execution is " "parallelized according to the semantics of the execution policy specified." msgstr "" "以表中每个元素的常量引用调用 `f`，直到 `f` 返回 `false` 或遍历完所有元素。执" "行过程会根据指定执行策略的语义进行并行化。" #: :885 #, 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" "注意：;; 仅在支持 C++17 并行算法的编译器中可用。\n" "仅当 `std::is_execution_policy_v>` " "为 `true` 时，这些重载版本才参与重载决议。\n" "不允许使用无顺序执行策略。\n" "并行化意味着执行流程不会在 `f` 返回 `false` 时立即终止，因此 `f` 可能会继续被" "后续元素调用，且这些调用的返回值同样可能为 `false`。" #: :896 #, safe-html, strict-same msgctxt ":896" msgid "---" msgstr "---" #: :898 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :900 #, safe-html, strict-same msgid "empty" msgstr "空" #: :902 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :907 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "返回值：;; `size() == 0`" #: :909 #, safe-html, strict-same msgctxt ":909" msgid "---" msgstr "---" #: :911 #, safe-html, strict-same msgid "size" msgstr "大小" #: :913 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :918 #, safe-html, strict-same msgid "Returns:;; The number of elements in the table." msgstr "返回值：;; 哈希表中的元素数量。" #: :921 #, 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 "" "注意：;; 当存在并发插入操作时，返回的值可能无法精确反映函数执行后哈希表的真实" "大小。" #: :924 #, safe-html, strict-same msgctxt ":924" msgid "---" msgstr "---" #: :926 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :928 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :933 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible table." msgstr "返回值：;; 哈希表支持的最大元素数量。" #: :935 #, safe-html, strict-same msgctxt ":935" msgid "---" msgstr "---" #: :937 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :939 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :940 #, safe-html, strict-same msgid "```c++ template bool emplace(Args&&... args); ```" msgstr "" "```c++ template bool emplace(Args&&... args); " "```" #: :944 #, 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` 构造对象并插入到哈希" "表中。" #: :947 #, 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`." msgstr "" "要求：;; `value_type` 可由 `args` 构造。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。" #: :951 #, safe-html, strict-same msgctxt ":951" msgid "---" msgstr "---" #: :953 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :954 #, safe-html, strict-same msgid "```c++ bool insert(const value_type& obj); ```" msgstr "```c++ bool insert(const value_type& obj); ```" #: :958 #, safe-html, strict-same msgctxt ":958" msgid "" "Inserts `obj` in the table if and only if there is no element in the table " "with an equivalent key." msgstr "当且仅当哈希表中不存在键等价的元素时，才将 `obj` 插入到哈希表中。" #: :961 #, safe-html, strict-same msgctxt ":961" 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`." msgstr "" "要求：;; `value_type` 支持拷贝插入。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。" #: :965 #, safe-html, strict-same msgctxt ":965" msgid "---" msgstr "---" #: :967 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :968 #, safe-html, strict-same msgid "```c++ bool insert(value_type&& obj); ```" msgstr "```c++ bool insert(value_type&& obj); ```" #: :972 #, safe-html, strict-same msgctxt ":972" msgid "" "Inserts `obj` in the table if and only if there is no element in the table " "with an equivalent key." msgstr "当且仅当哈希表中不存在键等价的元素时，才将 `obj` 插入到哈希表中。" #: :975 #, 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`." msgstr "" "要求：;; `value_type` 支持移动插入。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。" #: :979 #, safe-html, strict-same msgctxt ":979" msgid "---" msgstr "---" #: :981 #, safe-html, strict-same msgid "Transparent Insert" msgstr "透明插入" #: :982 #, safe-html, strict-same msgid "```c++ template bool insert(K&& k); ```" msgstr "```c++ template bool insert(K&& k); ```" #: :986 #, safe-html, strict-same msgid "" "Inserts an element constructed from `std::forward(k)` in the container if " "and only if there is no element in the container with an equivalent key." msgstr "" "当且仅当容器中不存在键等价的元素时，才使用 `std::forward(k)` 构造元素并插" "入到容器中。" #: :989 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if " "an insert took place. Concurrency:;; Blocking on rehashing of `*this`. " "Notes:;; This 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 "" "要求：;; `value_type` 可通过 `k` 原位构造。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。\n" "注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员别名" "时，该重载版本参与重载决议。库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，" "且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。" #: :994 #, safe-html, strict-same msgctxt ":994" msgid "---" msgstr "---" #: :996 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :997 #, safe-html, strict-same msgid "" "```c++ template size_type insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template size_type insert(InputIterator " "first, InputIterator last); ```" #: :1001 #, safe-html, strict-same msgctxt ":1001" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1008 #, safe-html, strict-same msgctxt ":1008" msgid "Returns:;; The number of elements inserted." msgstr "返回值：;; 成功插入的元素数量。" #: :1010 #, safe-html, strict-same msgctxt ":1010" msgid "---" msgstr "---" #: :1012 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :1013 #, safe-html, strict-same msgid "```c++ size_type insert(std::initializer_list il); ```" msgstr "" "```c++ size_type insert(std::initializer_list il); ```" #: :1017 #, safe-html, strict-same msgctxt ":1017" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1024 #, safe-html, strict-same msgctxt ":1024" msgid "Returns:;; The number of elements inserted." msgstr "返回值：;; 成功插入的元素个数。" #: :1026 #, safe-html, strict-same msgctxt ":1026" msgid "---" msgstr "---" #: :1028 #, safe-html, strict-same msgid "Insert Node" msgstr "节点插入" #: :1029 #, safe-html, strict-same msgid "```c++ insert_return_type insert(node_type&& nh); ```" msgstr "```c++ insert_return_type insert(node_type&& nh); ```" #: :1033 #, safe-html, strict-same msgid "" "If `nh` is not empty, inserts the associated element in the table if and " "only if there is no element in the table with a key equivalent to `nh.value()" "`. `nh` is empty when the function returns." msgstr "" "若 `nh` 非空，则当且仅当哈希表中不存在与 `nh.value()` 键等价的元素时，将其关" "联元素插入哈希表。函数返回时 `nh` 变为空。" #: :1037 #, safe-html, strict-same msgctxt ":1037" msgid "" "Returns:;; An `insert_return_type` object constructed from `inserted` and " "`node`: +" msgstr "返回值：;; 由 `inserted` 和 `node` 构造的 `insert_return_type` 对象。" #: :1038 #, safe-html, strict-same msgctxt ":1038" msgid "If `nh` is empty, `inserted` is `false` and `node` is empty." msgstr "若 `nh` 为空，则 `inserted` 为 `false` 且 `node` 为空。" #: :1039 #, safe-html, strict-same msgctxt ":1039" msgid "" "Otherwise if the insertion took place, `inserted` is true and `node` is " "empty." msgstr "若插入操作成功，则 `inserted` 为 true， 且 `node` 为空。" #: :1040 #, safe-html, strict-same msgctxt ":1040" msgid "" "If the insertion failed, `inserted` is false and `node` has the previous " "value of `nh`." msgstr "若插入操作失败，则 `inserted` 为 false ，且 `node` 保留 `nh` 的原值。" #: :1041 #, safe-html, strict-same msgid "" "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` the function has no effect. Concurrency:;; Blocking on rehashing of " "`*this`. Notes:;; Behavior is undefined if `nh` is not empty and the " "allocators of `nh` and the container are not equal." msgstr "" "若 `nh` 非空，则当且仅当容器中不存在与 `nh.value()` 等效的键时，插入其关联的" "元素。函数返回时 `nh` 为空。" #: :1045 #, safe-html, strict-same msgctxt ":1045" msgid "---" msgstr "---" #: :1047 #, safe-html, strict-same msgid "emplace_or_[c]visit" msgstr "emplace_or_[c]visit" #: :1048 #, 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); ```" #: :1053 #, 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 const reference to the equivalent element." msgstr "" "若哈希表中不存在键等价的元素，则使用参数 `args` 构造对象并插入表中；否则，以" "该等价元素的常量引用为参数调用函数 `f`。" #: :1057 #, 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:;; The interface is exposition only, as C++ does not allow to declare " "a parameter `f` after a variadic parameter pack." msgstr "" "要求：;; `value_type` 可由 `args` 构造。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。\n" "注意：;; 该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明参数 `f`。" #: :1062 #, safe-html, strict-same msgctxt ":1062" msgid "---" msgstr "---" #: :1064 #, safe-html, strict-same msgid "Copy insert_or_[c]visit" msgstr "复制 insert++_++or++_[++c++]++visit" #: :1065 #, 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); ```" msgstr "" "```c++ template bool insert_or_visit(const value_type& " "obj, F f); template bool insert_or_cvisit(const " "value_type& obj, F f); ```" #: :1070 #, safe-html, strict-same msgctxt ":1070" 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 const reference to the " "equivalent element." msgstr "" "当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中；否则，以该等价元素的" "常量引用为参数调用函数 `f`。" #: :1074 #, safe-html, strict-same msgctxt ":1074" 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`." msgstr "" "要求：;; `value_type` 支持拷贝插入。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。" #: :1078 #, safe-html, strict-same msgctxt ":1078" msgid "---" msgstr "---" #: :1080 #, safe-html, strict-same msgid "Move insert_or_[c]visit" msgstr "移动 insert++_++or++_[++c++]++visit" #: :1081 #, 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); ```" msgstr "" "```c++ template bool insert_or_visit(value_type&& obj, " "F f); template bool insert_or_cvisit(value_type&& obj, " "F f); ```" #: :1086 #, safe-html, strict-same msgctxt ":1086" 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 const reference to the " "equivalent element." msgstr "" "当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中；否则，以该等价元素的" "常量引用为参数调用函数 `f`。" #: :1090 #, safe-html, strict-same msgctxt ":1090" 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`." msgstr "" "要求：;; `value_type` 支持移动插入。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。" #: :1094 #, safe-html, strict-same msgctxt ":1094" msgid "---" msgstr "---" #: :1096 #, safe-html, strict-same msgid "Transparent insert_or_[c]visit" msgstr "透明 insert++_++or++_[++c++]++visit" #: :1097 #, safe-html, strict-same msgid "" "```c++ template bool insert_or_visit(K&& k, F f); " "template bool insert_or_cvisit(K&& k, F f); ```" msgstr "" "```c++ template bool insert_or_visit" "(K&& k, F f); template bool " "insert_or_cvisit(K&& k, F f); ```" #: :1102 #, safe-html, strict-same msgid "" "Inserts an element constructed from `std::forward(k)` in the container if " "and only if there is no element in the container with an equivalent key. " "Otherwise, invokes `f` with a const reference to the equivalent element." msgstr "" "当且仅当容器中不存在键等价的元素时，使用 `std::forward(k)` 构造元素并插入" "容器；否则，以该等价元素的常量引用为参数调用函数 `f`。" #: :1106 #, safe-html, strict-same msgctxt ":1106" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if " "an insert took place. Concurrency:;; Blocking on rehashing of `*this`. " "Notes:;; These 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 "" "要求：;; `value_type` 可从 `k` 原位构造。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象 `*this` 的扩容重哈希操作。\n" "注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员别名" "时，该重载版本参与重载决议。库假定 `Hash` 可同时接收 `K` 与 `Key` 类型调用，" "且 `Pred` 是透明的。这支持异构查找，避免了实例化 `Key` 类型对象的开销。" #: :1111 #, safe-html, strict-same msgctxt ":1111" msgid "---" msgstr "---" #: :1113 #, safe-html, strict-same msgid "Insert Iterator Range or Visit" msgstr "迭代器范围插入或访问" #: :1114 #, 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); ```" #: :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 "Insert Initializer List or Visit" msgstr "初始化列表插入或访问" #: :1133 #, 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); ```" #: :1138 #, safe-html, strict-same msgctxt ":1138" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1145 #, safe-html, strict-same msgctxt ":1145" msgid "Returns:;; The number of elements inserted." msgstr "返回值：;; 成功插入的元素个数。" #: :1147 #, safe-html, strict-same msgctxt ":1147" msgid "---" msgstr "---" #: :1149 #, safe-html, strict-same msgid "Insert Node or Visit" msgstr "节点插入或访问" #: :1150 #, safe-html, strict-same msgid "" "```c++ template insert_return_type insert_or_visit(node_type&& nh, " "F f); template insert_return_type insert_or_cvisit(node_type&& nh, " "F f); ```" msgstr "" "```c++ template insert_return_type insert_or_visit" "(node_type&& nh, F f); template insert_return_type " "insert_or_cvisit(node_type&& nh, F f); ```" #: :1155 #, safe-html, strict-same msgid "" "If `nh` is empty, does nothing. Otherwise, inserts the associated element in " "the table if and only if there is no element in the table with a key " "equivalent to `nh.value()`. Otherwise, invokes `f` with a const reference to " "the equivalent element." msgstr "" "若 `nh` 为空，则不执行任何操作。否则，当且仅当哈希表中不存在与 `nh.value()` " "键等价的元素时，将其关联元素插入表中；否则，以该等价元素的常量引用为参数调用" "函数 `f`。" #: :1160 #, safe-html, strict-same msgctxt ":1160" msgid "" "Returns:;; An `insert_return_type` object constructed from `inserted` and " "`node`: +" msgstr "返回值：;; 由 `inserted` 和 `node` 构造的 `insert_return_type` 对象。" #: :1161 #, safe-html, strict-same msgctxt ":1161" msgid "If `nh` is empty, `inserted` is `false` and `node` is empty." msgstr "若 `nh` 为空，则 `inserted` 为 `false` 且 `node` 为空。" #: :1162 #, safe-html, strict-same msgctxt ":1162" msgid "" "Otherwise if the insertion took place, `inserted` is true and `node` is " "empty." msgstr "若插入操作成功，则 `inserted` 为 true， 且 `node` 为空。" #: :1163 #, safe-html, strict-same msgctxt ":1163" msgid "" "If the insertion failed, `inserted` is false and `node` has the previous " "value of `nh`." msgstr "若插入操作失败，则 `inserted` 为 false ，且 `node` 保留 `nh` 的原值。" #: :1164 #, safe-html, strict-same msgid "" "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` or call to `f`, the function has no effect. Concurrency:;; Blocking " "on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is not empty " "and the allocators of `nh` and the container are not equal." msgstr "" "若 `nh` 为空，则不执行任何操作；否则，当且仅当容器中不存在与 `nh.value()` 等" "效的键时，插入其关联的元素；否则，使用指向等效元素的常量引用调用 `f` 。" #: :1168 #, safe-html, strict-same msgctxt ":1168" msgid "---" msgstr "---" #: :1170 #, safe-html, strict-same msgid "emplace_and_[c]visit" msgstr "emplace_and_[c]visit" #: :1171 #, safe-html, strict-same msgid "" "```c++ template bool emplace_or_visit" "(Args&&... args, F1&& f1, F2&& f2); template bool emplace_or_cvisit(Args&&... args, F1&& f1, F2&& f2); ```" msgstr "" "```c++ template bool " "emplace_or_visit(Args&&... args, F1&& f1, F2&& f2); " "template bool " "emplace_or_cvisit(Args&&... args, F1&& f1, F2&& f2); " "```" #: :1178 #, 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 const reference to the newly created element. Otherwise, invokes " "`f2` with a const reference to the equivalent element." msgstr "" "若哈希表中不存在键等价的元素，则使用参数 `args` 构造对象并插入表中，随后以新" "建元素的常量引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函" "数 `f2`。" #: :1183 #, 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:;; 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` 构造。\n" "返回值：;; 若成功插入元素则返回 `true`。\n" "并发特性：;; 会阻塞当前对象的重哈希操作。\n" "注意：;; 该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明 `f1` 和 " "`f2` 参数。" #: :1188 #, safe-html, strict-same msgctxt ":1188" msgid "---" msgstr "---" #: :1190 #, safe-html, strict-same msgid "Copy insert_and_[c]visit" msgstr "复制 insert++_++and++_[++c++]++visit" #: :1191 #, 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 f2, 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 f2, " "F2 f2); ```" #: :1196 #, safe-html, strict-same 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 const reference to the " "newly created element. Otherwise, invokes `f` with a const reference to the " "equivalent element." msgstr "" "当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中，随后以新建元素的常量" "引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函数 `f`。" #: :1201 #, safe-html, strict-same msgctxt ":1201" 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`." msgstr "" "要求：`value_type` 支持拷贝插入。\n" "返回值：若成功插入元素则返回 `true`。\n" "并发特性：会阻塞当前对象的重哈希操作。" #: :1205 #, safe-html, strict-same msgctxt ":1205" msgid "---" msgstr "---" #: :1207 #, safe-html, strict-same msgid "Move insert_and_[c]visit" msgstr "移动 insert++_++and++_[++c++]++visit" #: :1208 #, 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); ```" 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); " "```" #: :1213 #, safe-html, strict-same 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 const reference to the " "newly created element. Otherwise, invokes `f2` with a const reference to the " "equivalent element." msgstr "" "当且仅当哈希表中不存在键等价的元素时，将 `obj` 插入表中，随后以新建元素的常量" "引用为参数调用函数 `f1`；否则，以该等价元素的常量引用为参数调用函数 `f2`。\n" "要求：`value_type` 支持拷贝插入。\n" "返回值：若成功插入元素则返回 `true`。\n" "并发特性：会阻塞当前对象的重哈希操作。" #: :1218 #, safe-html, strict-same msgctxt ":1218" 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`." msgstr "" "要求：;; `value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]。\n" "返回值：;; 插入成功则返回 `true`。\n" "并发特性：;; 会阻塞 `*this` 的重哈希操作。" #: :1222 #, safe-html, strict-same msgctxt ":1222" msgid "---" msgstr "---" #: :1224 #, safe-html, strict-same msgid "Transparent insert_and_[c]visit" msgstr "透明 insert++_++and++_[++c++]++visit（透明插入并 ++[++c++]++ 访问）" #: :1225 #, safe-html, strict-same msgid "" "```c++ template bool insert_and_visit(K&& k, F1 " "f1, F2 f2); template bool insert_and_cvisit(K&& " "k, F1 f1, F2 f2); ```" msgstr "" "```c++ template bool " "insert_and_visit(K&& k, F1 f1, F2 f2); template bool insert_and_cvisit(K&& k, F1 f1, F2 " "f2); ```" #: :1230 #, safe-html, strict-same msgid "" "Inserts an element constructed from `std::forward(k)` in the container if " "and only if there is no element in the container with an equivalent key, and " "then invokes `f1` with a const reference to the newly created element. " "Otherwise, invokes `f2` with a const reference to the equivalent element." msgstr "" "当且仅当容器中不存在键等价的元素时，通过`std::forward(k)`构造元素并插入容" "器，随后使用新建元素的常量引用调用`f1`。若存在等价键元素，则使用该元素的常量" "引用调用`f2`。" #: :1235 #, safe-html, strict-same msgctxt ":1235" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if " "an insert took place. Concurrency:;; Blocking on rehashing of `*this`. " "Notes:;; These 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 "" "要求：;; `value_type` 可基于 `k` 满足 https://en.cppreference.com/w/cpp/" "named_req/EmplaceConstructible[EmplaceConstructible^]。\n" "返回值：;; 插入成功则返回 `true`。\n" "并发特性：;; 会阻塞 `*this` 的重哈希操作。\n" "注意：;; 仅当 `Hash::is_transparent` 与 `Pred::is_transparent` 为合法成员类型" "别名时，此类重载函数才参与重载决议。本库假定 `Hash` 可接收 `K` 与 `Key` 两种" "类型进行调用，且 `Pred` 具备透明特性。该特性支持异构查找，省去了实例化 `Key` " "类型对象的开销。" #: :1240 #, safe-html, strict-same msgctxt ":1240" msgid "---" msgstr "---" #: :1242 #, safe-html, strict-same msgid "Insert Iterator Range and Visit" msgstr "迭代器范围插入并访问" #: :1243 #, safe-html, strict-same msgid "" "```c++ template size_type " "insert_and_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); " "template size_type insert_and_cvisit" "(InputIterator first, InputIterator last, F1 f1, F2 f2); ```" msgstr "" "```c++ template " "size_type insert_and_visit(InputIterator first, InputIterator last, F1 f1, " "F2 f2); template " "size_type insert_and_cvisit(InputIterator first, InputIterator last, F1 f1, " "F2 f2); ```" #: :1250 #, safe-html, strict-same msgctxt ":1250" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1257 #, safe-html, strict-same msgctxt ":1257" msgid "Returns:;; The number of elements inserted." msgstr "返回值：;; 成功插入的元素数量。" #: :1259 #, safe-html, strict-same msgctxt ":1259" msgid "---" msgstr "---" #: :1261 #, safe-html, strict-same msgid "Insert Initializer List and Visit" msgstr "初始化列表插入并访问" #: :1262 #, 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); ```" #: :1269 #, safe-html, strict-same msgctxt ":1269" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1276 #, safe-html, strict-same msgctxt ":1276" msgid "Returns:;; The number of elements inserted." msgstr "返回值：;; 已插入的元素数量。" #: :1278 #, safe-html, strict-same msgctxt ":1278" msgid "---" msgstr "---" #: :1280 #, safe-html, strict-same msgid "Insert Node and Visit" msgstr "节点插入并访问" #: :1281 #, safe-html, strict-same msgid "" "```c++ template insert_return_type insert_and_visit" "(node_type&& nh, F1 f1, F2 f2); template " "insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ```" msgstr "" "```c++ template insert_return_type " "insert_and_visit(node_type&& nh, F1 f1, F2 f2); template insert_return_type insert_and_cvisit" "(node_type&& nh, F1 f1, F2 f2); ```" #: :1288 #, safe-html, strict-same msgid "" "If `nh` is empty, does nothing. Otherwise, inserts the associated element in " "the table if and only if there is no element in the table with a key " "equivalent to `nh.value()`, and then invokes `f1` with a const reference to " "the newly inserted element. Otherwise, invokes `f2` with a const reference " "to the equivalent element." msgstr "" "若 `nh` 为空，则不执行任何操作。否则，当且仅当表中不存在与 `nh.value()` 键等" "价的元素时，将关联元素插入表中，随后以新插入元素的常量引用调用 `f1`；否则，以" "等价元素的常量引用调用 `f2`。" #: :1294 #, safe-html, strict-same msgctxt ":1294" msgid "" "Returns:;; An `insert_return_type` object constructed from `inserted` and " "`node`: +" msgstr "返回值：;; 由 `inserted` 和 `node` 构造的 `insert_return_type` 对象：+" #: :1295 #, safe-html, strict-same msgctxt ":1295" msgid "If `nh` is empty, `inserted` is `false` and `node` is empty." msgstr "若 `nh` 为空，则 `inserted` 为 `false` 且 `node` 为空。" #: :1296 #, safe-html, strict-same msgctxt ":1296" msgid "" "Otherwise if the insertion took place, `inserted` is true and `node` is " "empty." msgstr "若插入操作成功，则 `inserted` 为 true， 且 `node` 为空。" #: :1297 #, safe-html, strict-same msgctxt ":1297" msgid "" "If the insertion failed, `inserted` is false and `node` has the previous " "value of `nh`." msgstr "若插入操作失败，则 `inserted` 为 false ，且 `node` 保留 `nh` 的原值。" #: :1298 #, safe-html, strict-same msgid "" "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` or call to `f1` or `f2`, the function has no effect. Concurrency:;; " "Blocking on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is " "not empty and the allocators of `nh` and the container are not equal." msgstr "" "若 `nh` 为空，则不执行任何操作；否则，当且仅当容器中不存在与 `nh.value()` 等" "效的键时，插入其关联的元素，并使用指向新插入元素的常量引用调用 `f1` ；否则，" "使用指向等效元素的常量引用调用 `f2` 。" #: :1302 #, safe-html, strict-same msgctxt ":1302" msgid "---" msgstr "---" #: :1304 #, safe-html, strict-same msgid "erase" msgstr "擦除" #: :1305 #, 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); ```" #: :1310 #, safe-html, strict-same msgid "Erases the element with key equivalent to `k` if it exists." msgstr "删除键与 `k` 等价的元素（若该元素存在）。" #: :1313 #, 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` 类型对象的开销。" #: :1317 #, safe-html, strict-same msgctxt ":1317" msgid "---" msgstr "---" #: :1319 #, safe-html, strict-same msgid "erase_if by Key" msgstr "通过键进行条件擦除" #: :1320 #, 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); ```" #: :1325 #, 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`，则删除该元素。" #: :1328 #, 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:;; 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" "注意：;; 仅当 " "`std::is_execution_policy_v>` 为 " "`false` 时，`template` 重载才参与重载决议" "。\n" "注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型" "别名时，`template` 重载才参与重载决议。标准" "库假定 `Hash` 可同时接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机" "制支持异构查找，避免了实例化 `Key` 类型对象的开销。" #: :1334 #, safe-html, strict-same msgctxt ":1334" msgid "---" msgstr "---" #: :1336 #, safe-html, strict-same msgctxt ":1336" msgid "erase_if" msgstr "erase_if" #: :1337 #, safe-html, strict-same msgid "```c++ template size_type erase_if(F f); ```" msgstr "```c++ template size_type erase_if(F f); ```" #: :1341 #, safe-html, strict-same msgid "" "Successively invokes `f` with references to each of the elements in the " "table, and erases those for which `f` returns `true`." msgstr "依次以表中每个元素的引用调用 `f`，并删除所有 `f` 返回 `true` 的元素。" #: :1344 #, 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` 抛出异常时才会抛出异常。" #: :1347 #, safe-html, strict-same msgctxt ":1347" msgid "---" msgstr "---" #: :1349 #, safe-html, strict-same msgid "Parallel erase_if" msgstr "并行条件擦除" #: :1350 #, safe-html, strict-same msgid "" "```c++ template void erase_if" "(ExecutionPolicy&& policy, F f); ```" msgstr "" "```c++ template void erase_if" "(ExecutionPolicy&& policy, F f); ```" #: :1354 #, safe-html, strict-same msgid "" "Invokes `f` with 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` 的元素。执行过程将根" "据指定执行策略的语义进行并行化处理。" #: :1358 #, 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" "注意：;; 仅当 " "`std::is_execution_policy_v>` 为 " "`true` 时，该重载才参与重载决议。\n" "注意：;; 不允许使用无序执行策略。" #: :1365 #, safe-html, strict-same msgctxt ":1365" msgid "---" msgstr "---" #: :1367 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :1368 #, safe-html, strict-same msgid "" "```c++ void swap(concurrent_node_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); ```" msgstr "" "```c++ void swap(concurrent_node_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); " "```" #: :1374 #, safe-html, strict-same msgid "Swaps the contents of the table with the parameter." msgstr "将当前表与参数对象的内容进行交换。" #: :1376 #, 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` 已声明且 " "`Allocator::propagate_on_container_swap::value` 为 `true`，则交换两个表的分配" "器。否则，使用不相等的分配器进行交换会导致未定义行为。" #: :1379 #, 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` 在交换时抛出异常，否则不抛出任何异常" "。\n" "并发：;; 阻塞 `*this` 和 `other`。" #: :1382 #, safe-html, strict-same msgctxt ":1382" msgid "---" msgstr "---" #: :1384 #, safe-html, strict-same msgid "extract" msgstr "extract" #: :1385 #, safe-html, strict-same msgid "" "```c++ node_type extract(const key_type& k); template node_type " "extract(K&& k); ```" msgstr "" "```c++ node_type extract(const key_type& k); template " "node_type extract(K&& k); ```" #: :1390 #, safe-html, strict-same msgid "Extracts the element with key equivalent to `k`, if it exists." msgstr "返回值：;; 提取键与 `k` 等价的元素（若该元素存在）。" #: :1393 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` object holding the extracted element, or empty if " "no element was extracted. 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 "" "返回值：;; 存储提取元素的 `node_type` 对象，若未提取任何元素则为空。\n" "异常：;; 仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。\n" "注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型" "别名时，`template` 重载才参与重载决议。标准库假定 `Hash` 可同时" "接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免" "了实例化 `Key` 类型对象的开销。" #: :1397 #, safe-html, strict-same msgctxt ":1397" msgid "---" msgstr "---" #: :1399 #, safe-html, strict-same msgid "extract_if" msgstr "条件提取" #: :1400 #, safe-html, strict-same msgid "" "```c++ template node_type extract_if(const key_type& k, F f); " "template node_type extract_if(K&& k, F f); ```" msgstr "" "```c++ template node_type extract_if(const key_type& k, F " "f); template node_type extract_if" "(K&& k, F f); ```" #: :1405 #, safe-html, strict-same msgid "" "Extracts the element `x` with key equivalent to `k`, if it exists and `f(x)` " "is `true`." msgstr "若键与 `k` 等价的元素 `x` 存在且 `f(x)` 为 `true`，则提取该元素。" #: :1408 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` object holding the extracted element, or empty if " "no element was extracted. Throws:;; Only throws an exception if it is thrown " "by `hasher` or `key_equal` or `f`. 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 "" "返回值：;; 存储被提取元素的 `node_type` 对象，若未提取任何元素则为空。\n" "异常：;; 仅当 `hasher`、`key_equal` 或 `f` 抛出异常时才会抛出异常。\n" "注意：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 为合法成员类型" "别名时，`template` 重载才参与重载决议。标准库假定 `Hash` 可同时" "接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免" "了实例化 `Key` 类型对象的开销。" #: :1412 #, safe-html, strict-same msgctxt ":1412" msgid "---" msgstr "---" #: :1414 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1415 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :1419 #, safe-html, strict-same msgid "Erases all elements in the table." msgstr "删除表中的所有元素。" #: :1422 #, 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`。" #: :1425 #, safe-html, strict-same msgctxt ":1425" msgid "---" msgstr "---" #: :1427 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1428 #, safe-html, strict-same msgid "" "```c++ template size_type merge(concurrent_node_set& source); template size_type merge" "(concurrent_node_set&& source); ```" msgstr "" "```c++ template size_type merge" "(concurrent_node_set& source); " "template size_type merge" "(concurrent_node_set&& source)" "; ```" #: :1435 #, 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` 中删除" "这些元素。" #: :1438 #, safe-html, strict-same msgid "" "Returns:;; The number of elements inserted. Concurrency:;; Blocking on " "`*this` and `source`." msgstr "" "返回值：;; 插入的元素数量。\n" "并发：;; 阻塞 `*this` 和 `source`。" #: :1441 #, safe-html, strict-same msgctxt ":1441" msgid "---" msgstr "---" #: :1443 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1445 #, safe-html, strict-same msgid "get_allocator" msgstr "get_allocator" #: :1446 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const noexcept; ```" msgstr "``` allocator_type get_allocator() const noexcept; ```" #: :1451 #, safe-html, strict-same msgid "Returns:;; The table's allocator." msgstr "返回值：;; 表的分配器。" #: :1453 #, safe-html, strict-same msgctxt ":1453" msgid "---" msgstr "---" #: :1455 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1456 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :1461 #, safe-html, strict-same msgid "Returns:;; The table's hash function." msgstr "返回值：;; 表的哈希函数。" #: :1463 #, safe-html, strict-same msgctxt ":1463" msgid "---" msgstr "---" #: :1465 #, safe-html, strict-same msgid "key_eq" msgstr "key_eq" #: :1466 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1471 #, safe-html, strict-same msgid "Returns:;; The table's key equality predicate." msgstr "返回值：;; 表的键相等性断言。" #: :1473 #, safe-html, strict-same msgctxt ":1473" msgid "---" msgstr "---" #: :1475 #, safe-html, strict-same msgid "Set Operations" msgstr "集合操作" #: :1477 #, safe-html, strict-same msgid "count" msgstr "count" #: :1478 #, 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; ```" #: :1485 #, 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` 重载才参与重载决议。标准库假定 `Hash` 可同时" "接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免" "了实例化 `Key` 类型对象的开销。\n" "注意：;; 若存在并发插入操作，返回值可能无法精确反映执行后表的真实状态。" #: :1491 #, safe-html, strict-same msgctxt ":1491" msgid "---" msgstr "---" #: :1493 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1494 #, 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; ```" #: :1501 #, 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` 重载才参与重载决议。标准库假定 `Hash` 可同时" "接收 `K` 与 `Key` 类型参数调用，且 `Pred` 是透明的。该机制支持异构查找，避免" "了实例化 `Key` 类型对象的开销。\n" "注意：;; 若存在并发插入操作，返回值可能无法精确反映执行后表的真实状态。" #: :1507 #, safe-html, strict-same msgctxt ":1507" msgid "---" msgstr "---" #: :1508 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1510 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1511 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1516 #, safe-html, strict-same msgid "Returns:;; The size of the bucket array." msgstr "返回值：;; 桶数组的大小。" #: :1518 #, safe-html, strict-same msgctxt ":1518" msgid "---" msgstr "---" #: :1520 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1522 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1523 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1528 #, 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`。" #: :1530 #, safe-html, strict-same msgctxt ":1530" msgid "---" msgstr "---" #: :1532 #, safe-html, strict-same msgid "max_load_factor" msgstr "max_load_factor" #: :1534 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1539 #, safe-html, strict-same msgid "Returns:;; Returns the table's maximum load factor." msgstr "返回值：;; 表的最大负载因子。" #: :1541 #, safe-html, strict-same msgctxt ":1541" msgid "---" msgstr "---" #: :1543 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1544 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1549 #, safe-html, strict-same msgid "" "Effects:;; Does nothing, as the user is not allowed to change this " "parameter. Kept for compatibility with `boost::unordered_set`." msgstr "" "效果：;; 不执行任何操作，因为不允许用户修改此参数。保留该函数是为了与 " "`boost::unordered_set` 保持兼容。" #: :1551 #, safe-html, strict-same msgctxt ":1551" msgid "---" msgstr "---" #: :1554 #, safe-html, strict-same msgid "max_load" msgstr "max++_++load（最大负载）" #: :1556 #, safe-html, strict-same msgid "```c++ size_type max_load() const noexcept; ```" msgstr "```c++ size_type max_load() const noexcept; ```" #: :1561 #, 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" "注意：;; 若存在并发插入操作，返回值可能无法精确反映执行后表的真实状态。" #: :1568 #, safe-html, strict-same msgctxt ":1568" msgid "---" msgstr "---" #: :1570 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1571 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1575 #, 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`，且负载因子小于等于最大负" "载因子。适用时，会增大或缩小表关联的桶数量 `bucket_count()`。" #: :1577 #, safe-html, strict-same msgid "" "When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array." msgstr "效果：;; 当 `size() == 0` 时，调用 `rehash(0)` 会释放底层桶数组的内存。" #: :1580 #, 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` 个桶，并确保负载因子小于或等于" "最大负载因子。此操作将根据情况增加或减少容器的 `bucket++_++count()` 。" #: :1584 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1585 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1589 #, safe-html, strict-same msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`." msgstr "效果：;; 等价于 `a.rehash(ceil(n / a.max_load_factor()))`。" #: :1591 #, 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` 功能类似，该函数可用于增大或缩小表中的桶数量。" #: :1594 #, 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`。" #: :1597 #, safe-html, strict-same msgctxt ":1597" msgid "---" msgstr "---" #: :1599 #, safe-html, strict-same msgid "Statistics" msgstr "统计信息" #: :1601 #, safe-html, strict-same msgid "get_stats" msgstr "get_stats" #: :1602 #, safe-html, strict-same msgid "```c++ stats get_stats() const; ```" msgstr "```c++ stats get_stats() const; ```" #: :1607 #, 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_node_set_boost_unordered_enable_stats[enabled]." msgstr "" "返回值：;; 截至目前，由该表执行的插入与查找操作的统计信息描述。\n" "注意：;; 仅当**统计计算功能启用**时可用。" #: :1610 #, safe-html, strict-same msgctxt ":1610" msgid "---" msgstr "---" #: :1612 #, safe-html, strict-same msgid "reset_stats" msgstr "reset_stats" #: :1613 #, safe-html, strict-same msgid "```c++ void reset_stats() noexcept; ```" msgstr "```c++ void reset_stats() noexcept; ```" #: :1618 #, 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_node_set_boost_unordered_enable_stats[enabled]." msgstr "" "效果：;; 将该哈希表所维护的内部统计数据清零。\n" "注意：;; 仅当xref:reference/stats.adoc#stats[statistics calculation]（统计计" "算功能）被xref:concurrent_node_set_boost_unordered_enable_stats[enabled]（启" "用状态）激活时，本函数才可使用。" #: :1621 #, safe-html, strict-same msgctxt ":1621" msgid "---" msgstr "---" #: :1623 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1624 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "如果以下任何一条件为真，则推导指引将不参与重载决议：" #: :1626 #, 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` 模板参数，且为该参数推导出的类型" "符合分配器要求。" #: :1631 #, safe-html, strict-same msgid "" "A `size_­type` parameter type in a deduction guide refers to the `size_­type` " "member type of the container type deduced by the deduction guide. Its " "default value coincides with the default value of the constructor selected." msgstr "" "推导指引中的 `size++_++type` 参数类型，指向由该推导指引所推导容器类型的 " "`size++_++type` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1635 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "_iter-value-type_" #: :1643 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1645 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1646 #, safe-html, strict-same msgid "" "```c++ template bool " "operator==(const concurrent_node_set& x, const " "concurrent_node_set& y); ```" msgstr "" "```c++ template " "bool operator==(const concurrent_node_set& x, const concurrent_node_set& y); ```" #: :1652 #, 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`。" #: :1655 #, safe-html, strict-same msgctxt ":1655" 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" "注意：;; 若两个哈希表的相等性断言不匹配，则行为未定义。" #: :1658 #, safe-html, strict-same msgctxt ":1658" msgid "---" msgstr "---" #: :1660 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1661 #, safe-html, strict-same msgid "" "```c++ template bool " "operator!=(const concurrent_node_set& x, const " "concurrent_node_set& y); ```" msgstr "" "```c++ template " "bool operator!=(const concurrent_node_set& x, const concurrent_node_set& y); ```" #: :1667 #, 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`。" #: :1670 #, safe-html, strict-same msgctxt ":1670" 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" "注意：;; 若两个哈希表不具备等价的相等性断言，则行为未定义。" #: :1673 #, safe-html, strict-same msgctxt ":1673" msgid "---" msgstr "---" #: :1675 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1676 #, safe-html, strict-same msgid "" "```c++ template void swap" "(concurrent_node_set& x, concurrent_node_set& y) noexcept(noexcept(x.swap(y))); ```" msgstr "" "```c++ template " "void swap(concurrent_node_set& x, " "concurrent_node_set& y) noexcept" "(noexcept(x.swap(y))); ```" #: :1683 #, safe-html, strict-same msgctxt ":1683" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1689 #, safe-html, strict-same msgctxt ":1689" msgid "---" msgstr "---" #: :1691 #, safe-html, strict-same msgctxt ":1691" msgid "erase_if" msgstr "erase_if" #: :1692 #, safe-html, strict-same msgid "" "```c++ template " "typename concurrent_node_set::size_type erase_if" "(concurrent_node_set& c, Predicate pred); ```" msgstr "" "```c++ template typename concurrent_node_set" "::size_type erase_if(concurrent_node_set& c, " "Predicate pred); ```" #: :1698 #, safe-html, strict-same msgctxt ":1698" msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]" msgstr "等价于 [listing,subs=\"+macros,+quotes\"]" #: :1704 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1706 #, safe-html, strict-same msgid "" "``concurrent_node_set``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++_++node++_++set` 可通过本组件库提供的 API，借助 link:../../../" "../../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归" "档与 XML 归档两种格式。" #: :1710 #, safe-html, strict-same msgid "Saving an concurrent_node_set to an archive" msgstr "将 concurrent++_++node++_++set 保存到归档" #: :1712 #, safe-html, strict-same msgid "" "Saves all the elements of a `concurrent_node_set` `x` to an archive (XML " "archive) `ar`." msgstr "将 `concurrent++_++node++_++set` `x` 的所有元素保存至归档（XML 归档） `ar` 。" #: :1715 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is serializable (XML serializable), and it supports " "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 "" "要求;; `value++_++type` 必须可序列化（支持 XML 序列化），且需要支持 " "Boost.Serialization 的 `save++_++construct++_++data` / " "`load++_++construct++_++data` 协议（该协议自动支持满足 https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求的类" "型）。 并发性;; 阻塞于 `x` 。" #: :1721 #, safe-html, strict-same msgctxt ":1721" msgid "---" msgstr "---" #: :1723 #, safe-html, strict-same msgid "Loading an concurrent_node_set from an archive" msgstr "从归档加载 concurrent++_++node++_++set" #: :1725 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of a `concurrent_node_set` `x` and inserts " "from an archive (XML archive) `ar` restored copies of the elements of the " "original `concurrent_node_set` `other` saved to the storage read by `ar`." msgstr "" "删除 `concurrent++_++node++_++set` 容器 `x` 中所有已存在的元素，并从归档（" "XML 归档） `ar` 中插入原始 `concurrent++_++node++_++set` 容器 `other` 的元素" "副本，这些副本是从 `ar` 所读取的存储中恢复的。" #: :1730 #, 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` 。"