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 06:40+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" #: :2 #, safe-html, strict-same msgid "Class Template unordered_node_set" msgstr "类模板 unordered_node_set" #: :4 #, safe-html, strict-same msgid ":idprefix: unordered_node_set_" msgstr ":idprefix: unordered_node_set_" #: :6 #, safe-html, strict-same msgid "" "`boost::unordered_node_set` — A node-based, open-addressing unordered " "associative container that stores unique values." msgstr "" "`boost::unordered_node_set` — 一种基于节点的开放寻址无序关联容器，用于存储唯" "一值。" #: :8 #, safe-html, strict-same msgid "" "`boost::unordered_node_set` uses an open-addressing layout like " "`boost::unordered_flat_set`, but, being node-based, it provides pointer " "stability and node handling functionalities. Its performance lies between " "those of `boost::unordered_set` and `boost::unordered_flat_set`." msgstr "" "`boost::unordered_node_set` 使用与 `boost::unordered_flat_set` 类似的开放寻址" "布局，但由于其基于节点的特性，它提供了指针稳定性和节点处理功能。其性能介于 " "`boost::unordered_set` 和 `boost::unordered_flat_set` 之间。" #: :12 #, safe-html, strict-same msgid "" "As a result of its using open addressing, the interface of " "`boost::unordered_node_set` deviates in a number of aspects from that of " "`boost::unordered_set`/`std::unordered_set`:" msgstr "" "由于使用开放寻址，`boost::unordered_node_set` 的接口在多个方面与 " "`boost::unordered_set`/`std::unordered_set` 有所不同：" #: :15 #, safe-html, strict-same msgid "" "- `begin()` is not constant-time. - There is no API for bucket handling " "(except `bucket_count`). - The maximum load factor of the container is " "managed internally and can't be set by the user." msgstr "" "- `begin()` 不是常数时间复杂度的。\n" "- 没有用于桶操作的 API（除了 `bucket_count` 之外）。\n" "- 容器的最大负载因子由内部管理，用户无法设置。" #: :19 #, safe-html, strict-same msgid "" "Other than this, `boost::unordered_node_set` is mostly a drop-in replacement " "of standard unordered associative containers." msgstr "除此之外， `boost::unordered_node_set` 几乎可以完全替代标准无序关联容器。" #: :22 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :240 #, safe-html, strict-same msgctxt ":240" msgid "---" msgstr "---" #: :242 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :244 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :247 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :247 #, safe-html, strict-same msgid "" "`Key` must be https://en.cppreference.com/w/cpp/named_req/" "Erasable[Erasable^] from the container." msgstr "" "`Key` 必须可以从容器中 https://en.cppreference.com/w/cpp/named_req/" "Erasable[Erasable^]（即可擦除）。" #: :247 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :247 #, safe-html, strict-same msgid "" "A unary function object type that acts a hash function for a `Key`. It takes " "a single argument of type `Key` and returns a value of type `std::size_t`." msgstr "" "一个一元函数对象类型，用作 `Key` 的哈希函数。它接受一个 `Key` 类型的参数，并" "返回一个 `std::size_t` 类型的值。" #: :247 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :247 #, 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` 类型的值。" #: :247 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :247 #, safe-html, strict-same msgid "" "An allocator whose value type is the same as the container's value type." msgstr "一个分配器，其值类型与容器的值类型相同。" #: :260 #, safe-html, strict-same msgid "" "Allocators using https://en.cppreference.com/w/cpp/named_req/" "Allocator#Fancy_pointers[fancy pointers] are supported." msgstr "" "支持使用 https://en.cppreference.com/w/cpp/named_req/" "Allocator#Fancy_pointers[异形指针] 的分配器。" #: :264 #, safe-html, strict-same msgid "" "The element nodes of the container are held into an internal _bucket array_. " "A 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 "" "容器的元素节点被保存在内部的 _桶数组_ 中。节点根据其元素的哈希码被插入到对应" "的桶中，但如果该桶已被占用（发生 _冲突_），则会使用原始位置附近的一个可用桶。" #: :268 #, 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 container (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()`，但在容器规模较小时，实现可能会允许更高的负载。" #: :273 #, 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_avalanching[hash_is_avalanching]::value` 为 " "`true`，则哈希函数将按原样使用；否则，会增加一个位混合后处理阶段，以牺牲额外" "的计算成本为代价来提高哈希质量。" #: :277 #, safe-html, strict-same msgctxt ":277" msgid "---" msgstr "---" #: :279 #, safe-html, strict-same msgid "Configuration Macros" msgstr "配置宏" #: :281 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_STATS`" msgstr "`BOOST_UNORDERED_ENABLE_STATS`" #: :283 #, safe-html, strict-same msgid "" "Globally define this macro to enable xref:reference/" "stats.adoc#stats[statistics calculation] for the container. Note that this " "option decreases the overall performance of many operations." msgstr "" "全局定义此宏，以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请" "注意，此选项会降低许多操作的总体性能。" #: :286 #, safe-html, strict-same msgctxt ":286" msgid "---" msgstr "---" #: :288 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :295 #, safe-html, strict-same msgctxt ":295" msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value_type` 。" #: :297 #, safe-html, strict-same msgctxt ":297" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :299 #, safe-html, strict-same msgid "Convertible to `const_iterator`." msgstr "可转换为 `const_iterator` 。" #: :301 #, safe-html, strict-same msgctxt ":301" msgid "---" msgstr "---" #: :308 #, safe-html, strict-same msgctxt ":308" msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value_type` 。" #: :310 #, safe-html, strict-same msgctxt ":310" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :312 #, safe-html, strict-same msgctxt ":312" msgid "---" msgstr "---" #: :319 #, safe-html, strict-same msgid "" "A class for holding extracted container elements, modelling https://" "en.cppreference.com/w/cpp/container/node_handle[NodeHandle]." msgstr "" "用于保存已提取容器元素的类，其建模自 https://en.cppreference.com/w/cpp/" "container/node_handle[NodeHandle] 。" #: :322 #, safe-html, strict-same msgctxt ":322" msgid "---" msgstr "---" #: :329 #, safe-html, strict-same msgid "A specialization of an internal class template:" msgstr "内部类模板的特化：" #: :342 #, safe-html, strict-same msgid "with `Iterator` = `iterator` and `NodeType` = `node_type`." msgstr "其中 `Iterator` = `iterator` ，且 `NodeType` = `node_type` 。" #: :344 #, safe-html, strict-same msgctxt ":344" msgid "---" msgstr "---" #: :346 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :348 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :349 #, safe-html, strict-same msgid "```c++ unordered_node_set(); ```" msgstr "```c++ unordered_node_set(); ```" #: :353 #, safe-html, strict-same msgid "" "Constructs an empty container 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()` 作为分配器，构造一个空容器。" #: :357 #, safe-html, strict-same msgctxt ":357" 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[可默认构" "造^]。" #: :360 #, safe-html, strict-same msgctxt ":360" msgid "---" msgstr "---" #: :362 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :363 #, safe-html, strict-same msgid "" "```c++ explicit unordered_node_set(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = allocator_type" "()); ```" msgstr "" "```c++ explicit unordered_node_set(size_type n, const hasher& hf = hasher" "(), const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" #: :370 #, safe-html, strict-same msgid "" "Constructs an empty container 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` 作为分配器。" #: :374 #, safe-html, strict-same msgctxt ":374" 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` 要求：如果使用默认参数，则 `hasher`、`key_equal` 和 " "`allocator_type` 需要满足 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[可默认构造^]。" #: :377 #, safe-html, strict-same msgctxt ":377" msgid "---" msgstr "---" #: :379 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :390 #, safe-html, strict-same msgid "" "Constructs an empty container 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)` 中的元素插入其中。" #: :393 #, safe-html, strict-same msgctxt ":393" 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[可默认构" "造^]。" #: :395 #, safe-html, strict-same msgctxt ":395" msgid "---" msgstr "---" #: :397 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :398 #, safe-html, strict-same msgid "```c++ unordered_node_set(unordered_node_set const& other); ```" msgstr "```c++ unordered_node_set(unordered_node_set const& other); ```" #: :402 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate and allocator." msgstr "拷贝构造函数。拷贝所包含的元素、哈希函数、谓词和分配器。" #: :404 #, 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` 存在且具有正确的签名" "，则分配器将根据其结果进行构造。" #: :407 #, safe-html, strict-same msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：`value_type` 可拷贝构造" #: :409 #, safe-html, strict-same msgctxt ":409" msgid "---" msgstr "---" #: :411 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :412 #, safe-html, strict-same msgid "```c++ unordered_node_set(unordered_node_set&& other); ```" msgstr "```c++ unordered_node_set(unordered_node_set&& other); ```" #: :416 #, safe-html, strict-same msgid "" "The move constructor. 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:unordered_node_set_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "移动构造函数。`other` 的内部桶数组会被直接转移给新容器。哈希函数、谓词和分配" "器通过移动构造从 `other` 获得。如果启用了统计信息（详见 " "xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则会从 `other` 转移内部的统计信息，并调用 `other.reset_stats()`。" #: :421 #, safe-html, strict-same msgctxt ":421" msgid "---" msgstr "---" #: :423 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器范围构造函数" #: :424 #, safe-html, strict-same msgid "" "```c++ template unordered_node_set(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template unordered_node_set(InputIterator " "f, InputIterator l, const allocator_type& a); ```" #: :429 #, safe-html, strict-same msgid "" "Constructs an empty container 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)` " "范围内的元素插入其中。" #: :432 #, safe-html, strict-same msgctxt ":432" 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[可默认构造^]。" #: :434 #, safe-html, strict-same msgctxt ":434" msgid "---" msgstr "---" #: :436 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :437 #, safe-html, strict-same msgid "```c++ explicit unordered_node_set(Allocator const& a); ```" msgstr "```c++ explicit unordered_node_set(Allocator const& a); ```" #: :441 #, safe-html, strict-same msgid "Constructs an empty container, using allocator `a`." msgstr "使用分配器 `a` 构造一个空容器。" #: :443 #, safe-html, strict-same msgctxt ":443" msgid "---" msgstr "---" #: :445 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :446 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(unordered_node_set const& other, Allocator const& " "a); ```" msgstr "" "```c++ unordered_node_set(unordered_node_set const& other, Allocator " "const& a); ```" #: :450 #, safe-html, strict-same msgid "" "Constructs a container, copying ``other``'s contained elements, hash " "function, and predicate, but using allocator `a`." msgstr "构造一个容器，拷贝 `other` 所包含的元素、哈希函数和谓词，但使用分配器 `a`。" #: :452 #, safe-html, strict-same msgctxt ":452" msgid "---" msgstr "---" #: :454 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :455 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(unordered_node_set&& other, Allocator const& a); " "```" msgstr "" "```c++ unordered_node_set(unordered_node_set&& other, Allocator " "const& a); ```" #: :459 #, safe-html, strict-same msgid "" "If `a == other.get_allocator()`, the element nodes of `other` are " "transferred directly to the new container; 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:unordered_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` 中的元素通过移动构造获得。哈希函数和谓词通过移动构造" "从 `other` 获得，而分配器则通过拷贝构造从 `a` 获得。如果启用了统计信息（详见 " "xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则当 `a == other.get_allocator()` 时，会从 `other` 转移内部的统计信息，并且" "始终会调用 `other.reset_stats()`。" #: :466 #, safe-html, strict-same msgctxt ":466" msgid "---" msgstr "---" #: :468 #, safe-html, strict-same msgid "Move Constructor from concurrent_node_set" msgstr "从 concurrent_node_set 的移动构造函数" #: :470 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(concurrent_node_set&& " "other); ```" msgstr "" "```c++ unordered_node_set(concurrent_node_set&& other); ```" #: :474 #, safe-html, strict-same msgid "" "Move construction from a xref:#concurrent_node_set[`concurrent_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:unordered_node_set_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "从 xref:#concurrent_node_set[`concurrent_node_set`] 进行移动构造。`other` 的" "内部桶数组直接转移给新容器。哈希函数、谓词和分配器通过移动构造从 `other` 获得" "。如果启用了统计信息（详见 " "xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则从 `other` 转移内部的统计信息，并调用 `other.reset_stats()`。" #: :481 #, safe-html, strict-same msgid "Complexity:;; Constant time. Concurrency:;; Blocking on `other`." msgstr "" "复杂度：常数时间。 \n" "并发性：在 `other` 上阻塞。" #: :484 #, safe-html, strict-same msgctxt ":484" msgid "---" msgstr "---" #: :486 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :496 #, safe-html, strict-same msgid "" "Constructs an empty container 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` 中的元素插入其中。" #: :499 #, safe-html, strict-same msgctxt ":499" 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[可默认构" "造^]。" #: :501 #, safe-html, strict-same msgctxt ":501" msgid "---" msgstr "---" #: :503 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :504 #, safe-html, strict-same msgid "```c++ unordered_node_set(size_type n, allocator_type const& a); ```" msgstr "" "```c++ unordered_node_set(size_type n, allocator_type const& a); ```" #: :508 #, safe-html, strict-same msgid "" "Constructs an empty container 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` 作为分配器。" #: :511 #, 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` 要求：`hasher` 和 `key_equal` 需要满足 https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。" #: :514 #, safe-html, strict-same msgctxt ":514" msgid "---" msgstr "---" #: :516 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :517 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(size_type n, hasher const& hf, allocator_type " "const& a); ```" msgstr "" "```c++ unordered_node_set(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :521 #, safe-html, strict-same msgid "" "Constructs an empty container 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` 作为分配器。" #: :524 #, 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` 要求：`key_equal` 需要满足 https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。" #: :527 #, safe-html, strict-same msgctxt ":527" msgid "---" msgstr "---" #: :529 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :536 #, safe-html, strict-same msgid "" "Constructs an empty container 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)` 范围内的元素插入其中。" #: :539 #, safe-html, strict-same msgctxt ":539" 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[可默认构造] 要求。" #: :541 #, safe-html, strict-same msgctxt ":541" msgid "---" msgstr "---" #: :543 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :551 #, safe-html, strict-same msgid "" "Constructs an empty container 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)` 范围内的元素插入其中。" #: :554 #, safe-html, strict-same msgctxt ":554" 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[可默认构造] 要求。" #: :556 #, safe-html, strict-same msgctxt ":556" msgid "---" msgstr "---" #: :558 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :560 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ unordered_node_set(std::initializer_list il, const " "allocator_type& a); ```" #: :564 #, safe-html, strict-same msgid "" "Constructs an empty container using `a` and default hash function and key " "equality predicate, and inserts the elements from `il` into it." msgstr "" "使用 `a` 以及默认的哈希函数和键相等谓词构造一个空容器，并将 `il` 中的元素插入" "其中。" #: :567 #, safe-html, strict-same msgctxt ":567" 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[可默认构造^]。" #: :569 #, safe-html, strict-same msgctxt ":569" msgid "---" msgstr "---" #: :571 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :573 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(std::initializer_list il, size_type n, " "const allocator_type& a); ```" msgstr "" "```c++ unordered_node_set(std::initializer_list il, size_type n, " "const allocator_type& a); ```" #: :577 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` and " "default hash function and key equality predicate, and inserts the elements " "from `il` into it." msgstr "" "使用 `a` 以及默认的哈希函数和键相等谓词，构造一个至少包含 `n` 个桶的空容器，" "并将 `il` 中的元素插入其中。" #: :580 #, safe-html, strict-same msgctxt ":580" 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[可默认构造^]。" #: :582 #, safe-html, strict-same msgctxt ":582" msgid "---" msgstr "---" #: :584 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :586 #, safe-html, strict-same msgid "" "```c++ unordered_node_set(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ unordered_node_set(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" #: :591 #, safe-html, strict-same msgid "" "Constructs an empty container 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` 中的元素插入其中。" #: :594 #, safe-html, strict-same msgctxt ":594" 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[可默认构造^]。" #: :596 #, safe-html, strict-same msgctxt ":596" msgid "---" msgstr "---" #: :598 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :600 #, safe-html, strict-same msgid "```c++ ~unordered_node_set(); ```" msgstr "```c++ ~unordered_node_set(); ```" #: :605 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：析构函数会应用于每个元素，并且所有内存都会被释放。" #: :607 #, safe-html, strict-same msgctxt ":607" msgid "---" msgstr "---" #: :609 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :611 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :613 #, safe-html, strict-same msgid "" "```c++ unordered_node_set& operator=(unordered_node_set const& other); ```" msgstr "" "```c++ unordered_node_set& operator=(unordered_node_set const& other)" "; ```" #: :617 #, 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` 中元素的副本。" #: :622 #, safe-html, strict-same msgctxt ":622" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]" msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可拷贝插入^]" #: :624 #, safe-html, strict-same msgctxt ":624" msgid "---" msgstr "---" #: :626 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :627 #, safe-html, strict-same msgid "" "```c++ unordered_node_set& operator=(unordered_node_set&& other) noexcept(" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && std::is_same::value); ``` The move assignment operator. Destroys previously " "existing elements, swaps the hash function and predicate from `other`, and " "move-assigns the allocator from `other` if " "`Alloc::propagate_on_container_move_assignment` exists and " "`Alloc::propagate_on_container_move_assignment::value` is `true`. If at this " "point the allocator is equal to `other.get_allocator()`, the internal bucket " "array of `other` is transferred directly to the new container; otherwise, " "inserts move-constructed copies of the elements of `other`. If statistics " "are xref:unordered_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++\n" "unordered_node_set& operator=(unordered_node_set&& other) " "noexcept((boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && " "std::is_same::value);\n" "```\n" "移动赋值运算符。销毁之前存在的元素，交换来自 `other` 的哈希函数和谓词，并且如" "果 `Alloc::propagate_on_container_move_assignment` 存在且 " "`Alloc::propagate_on_container_move_assignment::value` 为 `true`，则从 " "`other` 移动赋值分配器。如果此时分配器与 `other.get_allocator()` 相等，则 " "`other` 的内部桶数组直接转移给当前容器；否则，插入从 `other` 元素移动构造而来" "的副本。如果启用了统计信息（详见 " "xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则当最终分配器与 `other.get_allocator()` 相等时，从 `other` 转移内部的统计" "信息，并且始终会调用 `other.reset_stats()`。" #: :641 #, safe-html, strict-same msgctxt ":641" msgid "---" msgstr "---" #: :643 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :644 #, safe-html, strict-same msgid "" "```c++ unordered_node_set& operator=(std::initializer_list il); " "```" msgstr "" "```c++ unordered_node_set& operator=(std::initializer_list " "il); ```" #: :648 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All previously existing elements are " "destroyed." msgstr "从初始化列表中的值进行赋值。所有之前存在的元素都会被销毁。" #: :651 #, safe-html, strict-same msgctxt ":651" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]" msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可拷贝插入^]。" #: :653 #, safe-html, strict-same msgid "Iterators" msgstr "迭代器" #: :655 #, safe-html, strict-same msgid "begin" msgstr "begin" #: :656 #, safe-html, strict-same msgid "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" msgstr "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" #: :662 #, safe-html, strict-same msgid "" "Returns:;; An iterator referring to the first element of the container, or " "if the container is empty the past-the-end value for the container. " "Complexity:;; O(`bucket_count()`)" msgstr "" "返回：指向容器第一个元素的迭代器，如果容器为空则返回容器的尾后迭代器。 \n" "复杂度：O(`bucket_count()`)" #: :665 #, safe-html, strict-same msgctxt ":665" msgid "---" msgstr "---" #: :667 #, safe-html, strict-same msgid "end" msgstr "end" #: :668 #, safe-html, strict-same msgid "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" msgstr "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" #: :674 #, safe-html, strict-same msgid "" "Returns:;; An iterator which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后值的迭代器。" #: :676 #, safe-html, strict-same msgctxt ":676" msgid "---" msgstr "---" #: :678 #, safe-html, strict-same msgid "cbegin" msgstr "cbegin" #: :679 #, safe-html, strict-same msgid "```c++ const_iterator cbegin() const noexcept; ```" msgstr "```c++ const_iterator cbegin() const noexcept; ```" #: :684 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` referring to the first element of the " "container, or if the container is empty the past-the-end value for the " "container. Complexity:;; O(`bucket_count()`)" msgstr "" "Returns:;; A `const_iterator` referring to the first element of the " "container, or if the container is empty the past-the-end value for the " "container. Complexity:;; O(`bucket_count()`)" #: :687 #, safe-html, strict-same msgctxt ":687" msgid "---" msgstr "---" #: :689 #, safe-html, strict-same msgid "cend" msgstr "cend" #: :690 #, safe-html, strict-same msgid "```c++ const_iterator cend() const noexcept; ```" msgstr "```c++ const_iterator cend() const noexcept; ```" #: :695 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后值的 `const_iterator`。" #: :697 #, safe-html, strict-same msgctxt ":697" msgid "---" msgstr "---" #: :699 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :701 #, safe-html, strict-same msgid "empty" msgstr "空" #: :703 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :708 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "Returns:;; `size() == 0`" #: :710 #, safe-html, strict-same msgctxt ":710" msgid "---" msgstr "---" #: :712 #, safe-html, strict-same msgid "size" msgstr "大小" #: :714 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :719 #, safe-html, strict-same msgid "Returns:;; `std::distance(begin(), end())`" msgstr "Returns:;; `std::distance(begin(), end())`" #: :721 #, safe-html, strict-same msgctxt ":721" msgid "---" msgstr "---" #: :723 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :725 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :730 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible container." msgstr "返回：;; 可能的最大容器的 `size()`。" #: :732 #, safe-html, strict-same msgctxt ":732" msgid "---" msgstr "---" #: :734 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :736 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :737 #, safe-html, strict-same msgid "" "```c++ template std::pair emplace(Args&&... " "args); ```" msgstr "" "```c++ template std::pair emplace" "(Args&&... args); ```" #: :741 #, safe-html, strict-same msgctxt ":741" msgid "" "Inserts an object, constructed with the arguments `args`, in the container " "if and only if there is no element in the container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。" #: :744 #, safe-html, strict-same msgctxt ":744" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load to be greater than the maximum load. +" msgstr "" "要求：`value_type` 可从 `args` 构造。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :751 #, safe-html, strict-same msgctxt ":751" msgid "---" msgstr "---" #: :753 #, safe-html, strict-same msgid "emplace_hint" msgstr "emplace_hint" #: :754 #, safe-html, strict-same msgid "" "```c++ template iterator emplace_hint(const_iterator " "position, Args&&... args); ```" msgstr "" "```c++ template iterator emplace_hint(const_iterator " "position, Args&&... args); ```" #: :758 #, safe-html, strict-same msgctxt ":758" msgid "" "Inserts an object, constructed with the arguments `args`, in the container " "if and only if there is no element in the container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。" #: :760 #, safe-html, strict-same msgid "" "`position` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`position` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :763 #, safe-html, strict-same msgctxt ":763" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load to be greater than the maximum load. +" msgstr "" "要求：`value_type` 可从 `args` 构造。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :770 #, safe-html, strict-same msgctxt ":770" msgid "---" msgstr "---" #: :772 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :773 #, safe-html, strict-same msgid "```c++ std::pair insert(const value_type& obj); ```" msgstr "" "```c++ std::pair insert(const value_type& obj); " "```" #: :777 #, safe-html, strict-same msgctxt ":777" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :780 #, safe-html, strict-same msgctxt ":780" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load to " "be greater than the maximum load." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可拷贝插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :787 #, safe-html, strict-same msgctxt ":787" msgid "---" msgstr "---" #: :789 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :790 #, safe-html, strict-same msgid "```c++ std::pair insert(value_type&& obj); ```" msgstr "" "```c++ std::pair insert(value_type&& obj); ```" #: :794 #, safe-html, strict-same msgctxt ":794" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :797 #, safe-html, strict-same msgctxt ":797" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load to " "be greater than the maximum load." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :804 #, safe-html, strict-same msgctxt ":804" msgid "---" msgstr "---" #: :806 #, safe-html, strict-same msgid "Transparent Insert" msgstr "透明插入" #: :807 #, safe-html, strict-same msgid "```c++ template std::pair insert(K&& k); ```" msgstr "" "```c++ template std::pair insert" "(K&& k); ```" #: :811 #, safe-html, strict-same msgctxt ":811" 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)` 构造的元素。" #: :814 #, safe-html, strict-same msgctxt ":814" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; The bool " "component of the return type is true if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load to be greater than the maximum load. + + This " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. 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[可原位构造^]。 \n" "返回：如果发生了插入，则返回类型的 bool 分量为 true。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "只有当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef" "，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时，此重载才会参与重" "载决议。库假定 `Hash` 可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支" "持了异构查找，从而避免了实例化 `Key` 类型对象的开销。" #: :823 #, safe-html, strict-same msgctxt ":823" msgid "---" msgstr "---" #: :825 #, safe-html, strict-same msgid "Copy Insert with Hint" msgstr "带提示的复制插入" #: :826 #, safe-html, strict-same msgid "" "```c++ iterator insert(const_iterator hint, const value_type& obj); ``` " "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "" "```c++ iterator insert(const_iterator hint, const value_type& obj); ```当" "且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :831 #, safe-html, strict-same msgctxt ":831" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :834 #, safe-html, strict-same msgctxt ":834" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load to " "be greater than the maximum load." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可拷贝插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :841 #, safe-html, strict-same msgctxt ":841" msgid "---" msgstr "---" #: :843 #, safe-html, strict-same msgid "Move Insert with Hint" msgstr "带提示的移动插入" #: :844 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" msgstr "" "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" #: :848 #, safe-html, strict-same msgctxt ":848" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :850 #, safe-html, strict-same msgctxt ":850" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :853 #, safe-html, strict-same msgctxt ":853" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load to " "be greater than the maximum load." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :860 #, safe-html, strict-same msgctxt ":860" msgid "---" msgstr "---" #: :862 #, safe-html, strict-same msgid "Transparent Insert with Hint" msgstr "带提示的透明插入" #: :863 #, safe-html, strict-same msgid "" "```c++ template std::pair insert(const_iterator " "hint, K&& k); ```" msgstr "" "```c++ template std::pair insert" "(const_iterator hint, K&& k); ```" #: :867 #, safe-html, strict-same msgctxt ":867" 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)` 构造的元素。" #: :869 #, safe-html, strict-same msgctxt ":869" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :872 #, safe-html, strict-same msgctxt ":872" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; The bool " "component of the return type is true if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load to be greater than the maximum load. + + This " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. 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[可原位构造^]。 \n" "返回：如果发生了插入，则返回类型的 bool 分量为 true。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "只有当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef" "，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时，此重载才会参与重" "载决议。库假定 `Hash` 可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支" "持了异构查找，从而避免了实例化 `Key` 类型对象的开销。" #: :881 #, safe-html, strict-same msgctxt ":881" msgid "---" msgstr "---" #: :883 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :884 #, safe-html, strict-same msgid "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" #: :888 #, safe-html, strict-same msgctxt ":888" msgid "" "Inserts a range of elements into the container. Elements are inserted if and " "only if there is no element in the container with an equivalent key." msgstr "" "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入" "这些元素。" #: :891 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into the container from " "`*first`. Throws:;; When inserting a single element, if an exception is " "thrown by an operation other than a call to `hasher` the function has no " "effect. Notes:;; Can invalidate iterators, but only if the insert causes the " "load to be greater than the maximum load." msgstr "" "要求：`value_type` 可以从 `*first` 出发在容器中进行 https://" "en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 \n" "抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效" "果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :895 #, safe-html, strict-same msgctxt ":895" msgid "---" msgstr "---" #: :897 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :898 #, safe-html, strict-same msgid "```c++ void insert(std::initializer_list); ```" msgstr "```c++ void insert(std::initializer_list); ```" #: :902 #, safe-html, strict-same msgctxt ":902" msgid "" "Inserts a range of elements into the container. Elements are inserted if and " "only if there is no element in the container with an equivalent key." msgstr "" "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入" "这些元素。" #: :905 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] into the container. Throws:;; When inserting " "a single element, if an exception is thrown by an operation other than a " "call to `hasher` the function has no effect. Notes:;; Can invalidate " "iterators, but only if the insert causes the load to be greater than the " "maximum load." msgstr "" "要求：`value_type` 可以在容器中进行 https://en.cppreference.com/w/cpp/" "named_req/CopyInsertable[可拷贝插入^]。 \n" "抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效" "果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :909 #, safe-html, strict-same msgctxt ":909" msgid "---" msgstr "---" #: :911 #, safe-html, strict-same msgid "Insert Node" msgstr "节点插入" #: :912 #, safe-html, strict-same msgid "```c++ insert_return_type insert(node_type&& nh); ```" msgstr "```c++ insert_return_type insert(node_type&& nh); ```" #: :916 #, safe-html, strict-same msgid "" "If `nh` is not empty, inserts the associated element in the container if and " "only if there is no element in the container with a key equivalent to " "`nh.value()`. `nh` is empty when the function returns." msgstr "" "如果 `nh` 非空，则当且仅当容器中没有键与 `nh.value()` 等价的元素时，才将关联" "的元素插入容器。函数返回时 `nh` 变为空。" #: :920 #, safe-html, strict-same msgid "" "Returns:;; An `insert_return_type` object constructed from `position`, " "`inserted` and `node`: +" msgstr "" "返回：一个 `insert_return_type` 对象，由 `position`、`inserted` 和 `node` 构" "造而成：" #: :921 #, safe-html, strict-same msgid "" "If `nh` is empty, `inserted` is `false`, `position` is `end()`, and `node` " "is empty." msgstr "" "若 `nh` 为空，则 `inserted` 为 `false` ， `position` 为 `end()` ，且 `node` " "为空。" #: :922 #, safe-html, strict-same msgid "" "Otherwise if the insertion took place, `inserted` is true, `position` points " "to the inserted element, and `node` is empty." msgstr "" "否则，若插入操作发生，则 `inserted` 为 `true` ， `position` 指向被插入的元素" "，且 `node` 为空。" #: :923 #, safe-html, strict-same msgid "" "If the insertion failed, `inserted` is false, `node` has the previous value " "of `nh`, and `position` points to an element with a key equivalent to " "`nh.value()`." msgstr "" "若插入操作失败，则 `inserted` 为 `false` ， `node` 保留 `nh` 的原始值，且 " "`position` 指向一个键等价于 `nh.value()` 的元素。" #: :924 #, 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. 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` 为空。" #: :927 #, safe-html, strict-same msgctxt ":927" msgid "---" msgstr "---" #: :929 #, safe-html, strict-same msgid "Insert Node with Hint" msgstr "带提示的节点插入" #: :930 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" msgstr "" "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" #: :934 #, safe-html, strict-same msgid "" "If `nh` is not empty, inserts the associated element in the container if and " "only if there is no element in the container with a key equivalent to " "`nh.value()`. `nh` becomes empty if insertion took place, otherwise it is " "not changed." msgstr "" "如果 `nh` 非空，则当且仅当容器中没有键与 `nh.value()` 等价的元素时，才将关联" "的元素插入容器。如果插入发生，则 `nh` 变为空；否则 `nh` 不变。" #: :937 #, safe-html, strict-same msgctxt ":937" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :940 #, safe-html, strict-same msgid "" "Returns:;; The iterator returned is `end()` if `nh` is empty. If insertion " "took place, then the iterator points to the newly inserted element; " "otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Behavior is undefined if `nh` is not empty " "and the allocators of `nh` and the container are not equal." msgstr "" "返回：如果 `nh` 为空，则返回的迭代器为 `end()`。如果插入发生，则迭代器指向新" "插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：如果 `nh` 非空且 `nh` 与容器的分配器不相等，则行为未定义。" #: :945 #, safe-html, strict-same msgctxt ":945" msgid "---" msgstr "---" #: :947 #, safe-html, strict-same msgid "Erase by Position" msgstr "通过位置擦除" #: :955 #, safe-html, strict-same msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :958 #, safe-html, strict-same msgid "" "Returns:;; An opaque object implicitly convertible to the `iterator` or " "`const_iterator` immediately following `position` prior to the erasure. " "Throws:;; Nothing. Notes:;; The opaque object returned must only be " "discarded or immediately converted to `iterator` or `const_iterator`." msgstr "" "返回;; 返回一个不透明对象，该对象可隐式转换为擦除前紧接在 `position` 之后的 " "`iterator` 或 `const++_++iterator` 。 抛出;; 无。 注意;; 返回的不透明对象必须" "被立即丢弃或转换为 `iterator` 或 `const++_++iterator` 。" #: :963 #, safe-html, strict-same msgctxt ":963" msgid "---" msgstr "---" #: :965 #, safe-html, strict-same msgid "Erase by Key" msgstr "通过键擦除" #: :966 #, safe-html, strict-same msgid "" "```c++ size_type erase(const key_type& k); template size_type erase" "(K&& k); ```" msgstr "" "```c++ size_type erase(const key_type& k); template " "size_type erase(K&& k); ```" #: :971 #, safe-html, strict-same msgid "Erase all elements with key equivalent to `k`." msgstr "擦除所有键与 `k` 等价的元素。" #: :974 #, safe-html, strict-same msgid "" "Returns:;; The number of elements erased. 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 and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. 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 "" "返回：被擦除的元素数量。 \n" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 " "`const_iterator` 都不能从 `K` 隐式转换时，才参与重载决议。库假定 `Hash` 可同" "时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支持了异构查找，从而避免了实" "例化 `Key` 类型对象的开销。" #: :978 #, safe-html, strict-same msgctxt ":978" msgid "---" msgstr "---" #: :980 #, safe-html, strict-same msgid "Erase Range" msgstr "范围擦除" #: :982 #, safe-html, strict-same msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```" msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```" #: :986 #, safe-html, strict-same msgid "Erases the elements in the range from `first` to `last`." msgstr "擦除从 `first` 到 `last` 范围内的元素。" #: :989 #, safe-html, strict-same msgid "" "Returns:;; The iterator following the erased elements - i.e. `last`. " "Throws:;; Nothing in this implementation (neither the `hasher` nor the " "`key_equal` objects are called)." msgstr "" "返回：被擦除元素之后的迭代器——即 `last`。 \n" "抛出：在此实现中不抛出任何异常（既不调用 `hasher` 也不调用 `key_equal` 对象）" "。" #: :992 #, safe-html, strict-same msgctxt ":992" msgid "---" msgstr "---" #: :994 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :995 #, safe-html, strict-same msgid "" "```c++ void swap(unordered_node_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); ```" msgstr "" "```c++ void swap(unordered_node_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); " "```" #: :1001 #, safe-html, strict-same msgid "Swaps the contents of the container with the parameter." msgstr "交换容器的内容与参数的内容。" #: :1003 #, safe-html, strict-same msgctxt ":1003" msgid "" "If `Allocator::propagate_on_container_swap` is declared and " "`Allocator::propagate_on_container_swap::value` is `true` then the " "containers' 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1006 #, safe-html, strict-same msgid "Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping." msgstr "抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。" #: :1008 #, safe-html, strict-same msgctxt ":1008" msgid "---" msgstr "---" #: :1010 #, safe-html, strict-same msgid "Extract by Position" msgstr "通过位置提取" #: :1011 #, safe-html, strict-same msgid "```c++ node_type extract(const_iterator position); ```" msgstr "```c++ node_type extract(const_iterator position); ```" #: :1015 #, safe-html, strict-same msgid "Extracts the element pointed to by `position`." msgstr "提取 `position` 所指向的元素。" #: :1018 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` object holding the extracted element. Throws:;; " "Nothing." msgstr "" "返回：一个持有被提取元素的 `node_type` 对象。 \n" "抛出：不抛出任何异常。" #: :1021 #, safe-html, strict-same msgctxt ":1021" msgid "---" msgstr "---" #: :1023 #, safe-html, strict-same msgid "Extract by Key" msgstr "通过键提取" #: :1024 #, 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); ```" #: :1029 #, safe-html, strict-same msgid "Extracts the element with key equivalent to `k`, if it exists." msgstr "提取键与 `k` 等价的元素（如果存在）。" #: :1032 #, 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" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时才参与重载决议。库假定 `Hash` " "可同时用 `K` 和 `Key` 调用，并且 `Pred` 是透明的。这支持了异构查找，从而避免" "了实例化 `Key` 类型对象的开销。" #: :1036 #, safe-html, strict-same msgctxt ":1036" msgid "---" msgstr "---" #: :1038 #, safe-html, strict-same msgid "pull" msgstr "pull" #: :1039 #, safe-html, strict-same msgid "```c++ init_type pull(const_iterator position); ```" msgstr "```c++ init_type pull(const_iterator position); ```" #: :1043 #, safe-html, strict-same msgid "" "Move-constructs an `init_value` `x` from the element pointed to by " "`position`, erases the element and returns `x`." msgstr "" "从 `position` 指向的元素移动构造一个 `init_value` 对象 `x`，擦除该元素并返回 " "`x`。" #: :1046 #, safe-html, strict-same msgctxt ":1046" msgid "---" msgstr "---" #: :1048 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1049 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :1053 #, safe-html, strict-same msgid "Erases all elements in the container." msgstr "擦除容器中的所有元素。" #: :1056 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * " "bucket_count()`" msgstr "" "后置条件：`size() == 0`，`max_load() >= max_load_factor() * bucket_count()" "`" #: :1058 #, safe-html, strict-same msgctxt ":1058" msgid "---" msgstr "---" #: :1060 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1061 #, safe-html, strict-same msgid "" "```c++ template void merge(unordered_node_set& source); template void merge" "(unordered_node_set&& source); ```" msgstr "" "```c++ template void merge" "(unordered_node_set& " "source); template void merge" "(unordered_node_set&& " "source); ```" #: :1068 #, safe-html, strict-same msgid "" "Transfers all the element nodes from `source` whose key is not already " "present in `*this`." msgstr "从 `source` 转移所有键在 `*this` 中尚未存在的元素节点。" #: :1071 #, safe-html, strict-same msgid "" "Requires:;; `this\\->get_allocator() == source.get_allocator()`. Notes:;; " "Invalidates iterators to the elements transferred. If the resulting size of " "`*this` is greater than its original maximum load, invalidates all iterators " "associated to `*this`." msgstr "" "要求：`this->get_allocator() == source.get_allocator()`。 \n" "注意：会使被转移元素的迭代器失效。如果 `*this` 的结果大小大于其原始最大负载，" "则会使与 `*this` 关联的所有迭代器失效。" #: :1076 #, safe-html, strict-same msgctxt ":1076" msgid "---" msgstr "---" #: :1078 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1080 #, safe-html, strict-same msgid "get_allocator" msgstr "get_allocator" #: :1081 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const noexcept; ```" msgstr "``` allocator_type get_allocator() const noexcept; ```" #: :1086 #, safe-html, strict-same msgid "Returns:;; The container's allocator." msgstr "返回：容器的分配器。" #: :1088 #, safe-html, strict-same msgctxt ":1088" msgid "---" msgstr "---" #: :1090 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1091 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "" "```cpp\n" "hasher hash_function() const;\n" "```" #: :1096 #, safe-html, strict-same msgid "Returns:;; The container's hash function." msgstr "返回：容器的哈希函数对象。" #: :1098 #, safe-html, strict-same msgctxt ":1098" msgid "---" msgstr "---" #: :1100 #, safe-html, strict-same msgid "key_eq" msgstr "key_eq" #: :1101 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1106 #, safe-html, strict-same msgid "Returns:;; The container's key equality predicate" msgstr "返回：容器的键相等谓词。" #: :1108 #, safe-html, strict-same msgctxt ":1108" msgid "---" msgstr "---" #: :1110 #, safe-html, strict-same msgid "Lookup" msgstr "查找" #: :1112 #, safe-html, strict-same msgid "find" msgstr "find" #: :1113 #, safe-html, strict-same msgid "" "```c++ iterator find(const key_type& k); const_iterator find(const " "key_type& k) const; template iterator find(const K& k);" msgstr "" "```c++ iterator find(const key_type& k); const_iterator find" "(const key_type& k) const; template iterator find" "(const K& k);" #: :1119 #, safe-html, strict-same msgid "```" msgstr "```" #: :1122 #, safe-html, strict-same msgid "" "Returns:;; An iterator pointing to an element with key equivalent to `k`, or " "`end()` if no such element exists. 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 "" "返回：指向键与 `k` 等价的元素的迭代器；如果不存在这样的元素，则返回 `end()`。" " \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1125 #, safe-html, strict-same msgctxt ":1125" msgid "---" msgstr "---" #: :1127 #, safe-html, strict-same msgid "count" msgstr "count" #: :1128 #, 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; ```" #: :1135 #, safe-html, strict-same msgid "" "Returns:;; The number of elements with key equivalent to `k`. 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 "" "返回：键与 `k` 等价的元素数量。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1138 #, safe-html, strict-same msgctxt ":1138" msgid "---" msgstr "---" #: :1140 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1141 #, 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; ```" #: :1148 #, safe-html, strict-same msgid "" "Returns:;; A boolean indicating whether or not there is an element with key " "equal to `key` in the container 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 "" "返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1151 #, safe-html, strict-same msgctxt ":1151" msgid "---" msgstr "---" #: :1153 #, safe-html, strict-same msgid "equal_range" msgstr "equal_range" #: :1154 #, safe-html, strict-same msgid "" "```c++ std::pair equal_range(const " "key_type& k); std::pair equal_range(const " "key_type& k) const; template std::pair" " equal_range(const K& k); template " "std::pair equal_range(const K& k) const; ```" msgstr "" "```c++ std::pair equal_range(const " "key_type& k); std::pair " "equal_range(const key_type& k) const; template " "std::pair equal_range(const K& k); " "template std::pair " "equal_range(const K& k) const; ```" "" #: :1164 #, safe-html, strict-same msgid "" "Returns:;; A range containing all elements with key equivalent to `k`. If " "the container doesn't contain any such elements, returns `std::make_pair" "(b.end(), b.end())`. 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 "" "返回：包含所有键与 `k` 等价的元素的范围。如果容器不包含任何此类元素，则返回 " "`std::make_pair(b.end(), b.end())`。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1167 #, safe-html, strict-same msgctxt ":1167" msgid "---" msgstr "---" #: :1169 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1171 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1172 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1177 #, safe-html, strict-same msgid "Returns:;; The size of the bucket array." msgstr "返回：桶数组的大小。" #: :1179 #, safe-html, strict-same msgctxt ":1179" msgid "---" msgstr "---" #: :1181 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1183 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1184 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1189 #, 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`。" #: :1191 #, safe-html, strict-same msgctxt ":1191" msgid "---" msgstr "---" #: :1193 #, safe-html, strict-same msgid "max_load_factor" msgstr "max_load_factor" #: :1195 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1200 #, safe-html, strict-same msgid "Returns:;; Returns the container's maximum load factor." msgstr "返回：容器的最大负载因子。" #: :1202 #, safe-html, strict-same msgctxt ":1202" msgid "---" msgstr "---" #: :1204 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1205 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1210 #, 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` 保持兼容。" #: :1212 #, safe-html, strict-same msgctxt ":1212" msgid "---" msgstr "---" #: :1215 #, safe-html, strict-same msgid "max_load" msgstr "max_load" #: :1217 #, safe-html, strict-same msgid "```c++ size_type max_load() const noexcept; ```" msgstr "```c++ size_type max_load() const noexcept; ```" #: :1222 #, safe-html, strict-same msgid "" "Returns:;; The maximum number of elements the container can hold without " "rehashing, assuming that no further elements will be erased. Note:;; After " "construction, rehash or clearance, the container's maximum load is at least " "`max_load_factor() * bucket_count()`. This number may decrease on erasure " "under high-load conditions." msgstr "" "返回：容器在不触发重哈希的情况下能够容纳的最大元素数量（假设不再有元素被擦除" "）。 \n" "注意：在构造、重哈希或清空操作之后，容器的最大负载至少为 `max_load_factor() " "* bucket_count()`。在高负载条件下，该数值可能会因元素擦除而减小。" #: :1226 #, safe-html, strict-same msgctxt ":1226" msgid "---" msgstr "---" #: :1228 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1229 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1233 #, 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 container." msgstr "" "必要时更改桶数组的大小，使其至少包含 `n` 个桶，并且使得负载因子小于或等于最大" "负载因子。在适用的情况下，这将增大或缩小与容器关联的 `bucket_count()`。" #: :1235 #, safe-html, strict-same msgid "" "When `size() == 0`, `rehash(0)` will deallocate the underlying buckets " "array. If the provided Allocator uses fancy pointers, a default allocation " "is subsequently performed." msgstr "" "当 `size() == 0` 时，`rehash(0)` 将释放底层的桶数组。如果提供的分配器使用异形" "指针，则会随后执行一次默认分配。" #: :1237 #, safe-html, strict-same msgctxt ":1237" msgid "Invalidates iterators and changes the order of elements." msgstr "使迭代器失效并改变元素的顺序。" #: :1240 #, safe-html, strict-same msgctxt ":1240" msgid "" "Throws:;; The function has no effect if an exception is thrown, unless it is " "thrown by the container's hash function or comparison function." msgstr "" "抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果" "。" #: :1242 #, safe-html, strict-same msgctxt ":1242" msgid "---" msgstr "---" #: :1244 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1245 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1249 #, safe-html, strict-same msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`." msgstr "等价于 `a.rehash(ceil(n / a.max_load_factor()))`。" #: :1251 #, safe-html, strict-same msgid "" "Similar to `rehash`, this function can be used to grow or shrink the number " "of buckets in the container." msgstr "与 `rehash` 类似，此函数可用于增大或缩小容器中的桶数量。" #: :1253 #, safe-html, strict-same msgctxt ":1253" msgid "Invalidates iterators and changes the order of elements." msgstr "使迭代器失效并改变元素的顺序。" #: :1256 #, safe-html, strict-same msgctxt ":1256" msgid "" "Throws:;; The function has no effect if an exception is thrown, unless it is " "thrown by the container's hash function or comparison function." msgstr "" "抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果" "。" #: :1258 #, safe-html, strict-same msgctxt ":1258" msgid "---" msgstr "---" #: :1260 #, safe-html, strict-same msgid "Statistics" msgstr "统计信息" #: :1262 #, safe-html, strict-same msgid "get_stats" msgstr "get_stats" #: :1263 #, safe-html, strict-same msgid "```c++ stats get_stats() const; ```" msgstr "```c++ stats get_stats() const; ```" #: :1268 #, safe-html, strict-same msgid "" "Returns:;; A statistical description of the insertion and lookup operations " "performed by the container so far. Notes:;; Only available if xref:reference/" "stats.adoc#stats[statistics calculation] is " "xref:unordered_node_set_boost_unordered_enable_stats[enabled]." msgstr "" "返回：容器迄今为止所执行插入和查找操作的统计描述。 \n" "注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 " "xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] " "启用时才可用。" #: :1271 #, safe-html, strict-same msgctxt ":1271" msgid "---" msgstr "---" #: :1273 #, safe-html, strict-same msgid "reset_stats" msgstr "reset_stats" #: :1274 #, safe-html, strict-same msgid "```c++ void reset_stats() noexcept; ```" msgstr "```c++ void reset_stats() noexcept; ```" #: :1279 #, safe-html, strict-same msgid "" "Effects:;; Sets to zero the internal statistics kept by the container. " "Notes:;; Only available if xref:reference/stats.adoc#stats[statistics " "calculation] is " "xref:unordered_node_set_boost_unordered_enable_stats[enabled]." msgstr "" "效果：将容器内部维护的统计信息归零。 \n" "注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 " "xref:unordered_node_set_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] " "启用时才可用。" #: :1282 #, safe-html, strict-same msgctxt ":1282" msgid "---" msgstr "---" #: :1284 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1285 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "如果以下任何一条件为真，则推导指引将不参与重载决议：" #: :1287 #, 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` 模板参数，并且为该参数推导出的类型不符合输入迭代" "器的要求。\n" "- 它具有一个 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要求" "。\n" "- 它具有一个 `Hash` 模板参数，并且为该参数推导出的类型是整数类型或符合分配器" "的要求。\n" "- 它具有一个 `Pred` 模板参数，并且为该参数推导出的类型符合分配器的要求。" #: :1292 #, 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` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1296 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "_iter-value-type_" #: :1304 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1306 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1307 #, safe-html, strict-same msgid "" "```c++ template " "bool operator==(const unordered_node_set& x, " "const unordered_node_set& y); ```" msgstr "" "```c++ template bool operator==(const unordered_node_set& x, const unordered_node_set& y); ```" #: :1313 #, safe-html, strict-same msgid "" "Return `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`。" #: :1316 #, safe-html, strict-same msgctxt ":1316" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1318 #, safe-html, strict-same msgctxt ":1318" msgid "---" msgstr "---" #: :1320 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1321 #, safe-html, strict-same msgid "" "```c++ template " "bool operator!=(const unordered_node_set& x, " "const unordered_node_set& y); ```" msgstr "" "```c++ template bool operator!=(const unordered_node_set& x, const unordered_node_set& y); ```" #: :1327 #, safe-html, strict-same msgid "" "Return `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`。" #: :1330 #, safe-html, strict-same msgctxt ":1330" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1332 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1333 #, safe-html, strict-same msgid "" "```c++ template " "void swap(unordered_node_set& x, " "unordered_node_set& y) noexcept(noexcept(x.swap" "(y))); ```" msgstr "" "```c++ template void swap(unordered_node_set& x, unordered_node_set& y) noexcept(noexcept(x.swap(y))); ```" #: :1340 #, safe-html, strict-same msgid "Swaps the contents of `x` and `y`." msgstr "交换 `x` 和 `y` 的内容。" #: :1342 #, safe-html, strict-same msgctxt ":1342" msgid "" "If `Allocator::propagate_on_container_swap` is declared and " "`Allocator::propagate_on_container_swap::value` is `true` then the " "containers' 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1345 #, safe-html, strict-same msgid "" "Effects:;; `x.swap(y)` Throws:;; Nothing unless `key_equal` or `hasher` " "throw on swapping." msgstr "" "效果：`x.swap(y)` \n" "抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。" #: :1348 #, safe-html, strict-same msgctxt ":1348" msgid "---" msgstr "---" #: :1350 #, safe-html, strict-same msgid "erase_if" msgstr "erase_if" #: :1351 #, safe-html, strict-same msgid "" "```c++ template typename unordered_node_set::size_type erase_if" "(unordered_node_set& c, Predicate pred); ```" msgstr "" "```c++ template typename unordered_node_set::size_type erase_if(unordered_node_set& c, Predicate pred); ```" #: :1357 #, safe-html, strict-same msgid "" "Traverses the container `c` and removes all elements for which the supplied " "predicate returns `true`." msgstr "遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。" #: :1360 #, safe-html, strict-same msgid "" "Returns:;; The number of erased elements. Notes:;; Equivalent to: + + ```c++ " "auto original_size = c.size(); for (auto i = c.begin(), last = c.end(); i != " "last; ) { if (pred(*i)) { i = c.erase(i); } else { ++i; } } return " "original_size - c.size(); ```" msgstr "" "返回：被擦除的元素数量。 \n" "注意：等价于： \n" "```c++\n" "auto original_size = c.size();\n" "for (auto i = c.begin(), last = c.end(); i != last; ) {\n" " if (pred(*i)) {\n" " i = c.erase(i);\n" " } else {\n" " ++i;\n" " }\n" "}\n" "return original_size - c.size();\n" "```" #: :1375 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1377 #, safe-html, strict-same msgid "" "``unordered_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 "" "`unordered++_++node++_++set` 可通过本组件库提供的 API，借助 link:../../../../" "../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归档" "与 XML 归档两种格式。" #: :1381 #, safe-html, strict-same msgid "Saving an unordered_node_set to an archive" msgstr "将 `unordered_node_set` 保存到归档中" #: :1383 #, safe-html, strict-same msgid "" "Saves all the elements of an `unordered_node_set` `x` to an archive (XML " "archive) `ar`." msgstr "将 `unordered_node_set` 容器 `x` 的所有元素保存到归档（XML 归档）`ar` 中。" #: :1386 #, 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)." msgstr "" "要求：`value_type` 必须是可序列化的（对于 XML 归档需支持 XML 序列化），并且支" "持 Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（" "该协议由满足 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[可默认构造^] 的类型自动支持）。" #: :1392 #, safe-html, strict-same msgctxt ":1392" msgid "---" msgstr "---" #: :1394 #, safe-html, strict-same msgid "Loading an unordered_node_set from an archive" msgstr "从归档中加载 `unordered_node_set`" #: :1396 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of an `unordered_node_set` `x` and inserts " "from an archive (XML archive) `ar` restored copies of the elements of the " "original `unordered_node_set` `other` saved to the storage read by `ar`." msgstr "" "删除 `unordered_node_set` 容器 `x` 中所有已存在的元素，并从归档（XML 归档" "）`ar` 中插入从原始 `unordered_node_set` 容器 `other` 保存到 `ar` 所读取存储" "中的元素恢复出的副本。" #: :1401 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. `x.key_equal()` is functionally equivalent " "to `other.key_equal()`." msgstr "" "要求;; `value++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入] 要求，且 `x.key++_++equal()` 在功能上需等价于 " "`other.key++_++equal()` 。" #: :1404 #, safe-html, strict-same msgctxt ":1404" msgid "---" msgstr "---" #: :1406 #, safe-html, strict-same msgid "Saving an iterator/const_iterator to an archive" msgstr "将迭代器/常量迭代器保存到归档" #: :1408 #, safe-html, strict-same msgid "" "Saves the positional information of an `iterator` (`const_iterator`) `it` to " "an archive (XML archive) `ar`. `it` can be and `end()` iterator." msgstr "" "将迭代器（或常量迭代器）`it` 的位置信息保存到归档（XML 归档）`ar` 中。`it` 可" "以是一个 `end()` 迭代器。" #: :1412 #, safe-html, strict-same msgid "" "Requires:;; The `unordered_node_set` `x` pointed to by `it` has been " "previously saved to `ar`, and no modifying operations have been issued on " "`x` between saving of `x` and saving of `it`." msgstr "" "要求：`it` 所指向的 `unordered_node_set` 容器 `x` 必须先被保存到 `ar` 中，并" "且在保存 `x` 和保存 `it` 之间，不能对 `x` 执行任何修改操作。" #: :1416 #, safe-html, strict-same msgctxt ":1416" msgid "---" msgstr "---" #: :1418 #, safe-html, strict-same msgid "Loading an iterator/const_iterator from an archive" msgstr "从归档加载迭代器/常量迭代器" #: :1420 #, safe-html, strict-same msgid "" "Makes an `iterator` (`const_iterator`) `it` point to the restored position " "of the original `iterator` (`const_iterator`) saved to the storage read by " "an archive (XML archive) `ar`." msgstr "" "使迭代器（或常量迭代器）`it` 指向原始迭代器（或常量迭代器）被保存到归档（XML " "归档）`ar` 所读取存储中的位置恢复后的位置。" #: :1425 #, safe-html, strict-same msgid "" "Requires:;; If `x` is the `unordered_node_set` `it` points to, no modifying " "operations have been issued on `x` between loading of `x` and loading of " "`it`." msgstr "" "要求：如果 `x` 是 `it` 所指向的 `unordered_node_set` 容器，则在加载 `x` 和加" "载 `it` 之间，不能对 `x` 执行任何修改操作。"