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 02:07+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_set" msgstr "类模板 unordered_set" #: :4 #, safe-html, strict-same msgid ":idprefix: unordered_set_" msgstr ":idprefix: unordered_set_" #: :6 #, safe-html, strict-same msgid "" "`boost::unordered_set` — An unordered associative container that stores " "unique values." msgstr "`boost::unordered++_++set` — 一种用于存储唯一值的无序关联容器。" #: :8 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :239 #, safe-html, strict-same msgctxt ":239" msgid "---" msgstr "---" #: :241 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :243 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :246 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :246 #, safe-html, strict-same msgid "" "`Key` must be https://en.cppreference.com/w/cpp/named_req/" "Erasable[Erasable^] from the container (i.e. `allocator_traits` can destroy " "it)." msgstr "" "`Key` 必须可以从容器中 https://en.cppreference.com/w/cpp/named_req/" "Erasable[Erasable^]（即 `allocator_traits` 能够销毁它）。" #: :246 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :246 #, 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` 类型的值。" #: :246 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :246 #, safe-html, strict-same msgid "" "A binary function object that implements an equivalence relation on values " "of type `Key`. 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` " "类型值上诱导出等价关系。它接受两个 `Key` 类型的参数并返回一个 `bool` 类型的值" "。" #: :246 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :246 #, safe-html, strict-same msgid "" "An allocator whose value type is the same as the container's value type." msgstr "一个分配器，其值类型与容器的值类型相同。" #: :259 #, 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[异形指针] 的分配器。" #: :263 #, safe-html, strict-same msgid "" "The elements are organized into buckets. Keys with the same hash code are " "stored in the same bucket." msgstr "元素被组织到桶中。具有相同哈希码的键存储在同一桶中。" #: :265 #, safe-html, strict-same msgid "" "The number of buckets can be automatically increased by a call to insert, or " "as the result of calling rehash." msgstr "桶的数量可以通过调用 insert 自动增加，或者作为调用 rehash 的结果。" #: :267 #, safe-html, strict-same msgid "Configuration macros" msgstr "配置宏" #: :269 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`" msgstr "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`" #: :271 #, safe-html, strict-same msgid "" "Globally define this macro to support loading of ``unordered_set``s saved to " "a Boost.Serialization archive with a version of Boost prior to Boost 1.84." msgstr "" "全局定义此宏以支持加载由 Boost 1.84 之前版本的 Boost 保存到 " "Boost.Serialization 归档中的 `unordered_set`。" #: :274 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :281 #, safe-html, strict-same msgctxt ":281" msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value_type`。" #: :283 #, safe-html, strict-same msgctxt ":283" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :285 #, safe-html, strict-same msgid "Convertible to `const_iterator`." msgstr "可转换为 `const++_++iterator` 。" #: :287 #, safe-html, strict-same msgctxt ":287" msgid "---" msgstr "---" #: :294 #, safe-html, strict-same msgctxt ":294" msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value_type`。" #: :296 #, safe-html, strict-same msgctxt ":296" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :298 #, safe-html, strict-same msgctxt ":298" msgid "---" msgstr "---" #: :305 #, safe-html, strict-same msgid "" "An iterator with the same value type, difference type and pointer and " "reference type as iterator." msgstr "一种迭代器，其值类型、差值类型以及指针和引用类型均与 iterator 相同。" #: :307 #, safe-html, strict-same msgid "" "A `local_iterator` object can be used to iterate through a single bucket." msgstr "`local++_iterator` 对象可用于遍历单个桶内的元素。" #: :309 #, safe-html, strict-same msgctxt ":309" msgid "---" msgstr "---" #: :316 #, safe-html, strict-same msgid "" "A constant iterator with the same value type, difference type and pointer " "and reference type as const_iterator." msgstr "" "一种常量迭代器，其值类型、差值类型以及指针和引用类型均与 const++_iterator 相" "同。" #: :318 #, safe-html, strict-same msgid "" "A const_local_iterator object can be used to iterate through a single bucket." msgstr "`const_local_iterator` 对象可用于遍历单个桶。" #: :320 #, safe-html, strict-same msgctxt ":320" msgid "---" msgstr "---" #: :327 #, 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] 模型。" #: :330 #, safe-html, strict-same msgctxt ":330" msgid "---" msgstr "---" #: :337 #, safe-html, strict-same msgid "A specialization of an internal class template:" msgstr "内部类模板的特化：" #: :350 #, safe-html, strict-same msgid "with `Iterator` = `iterator` and `NodeType` = `node_type`." msgstr "其中 `Iterator` = `iterator`，`NodeType` = `node_type`。" #: :352 #, safe-html, strict-same msgctxt ":352" msgid "---" msgstr "---" #: :354 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :356 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :357 #, safe-html, strict-same msgid "```c++ unordered_set(); ```" msgstr "```c++ unordered_set(); ```" #: :361 #, safe-html, strict-same msgid "" "Constructs an empty container using `hasher()` as the hash function, " "`key_equal()` as the key equality predicate, `allocator_type()` as the " "allocator and a maximum load factor of `1.0`." msgstr "" "使用 `hasher()` 作为哈希函数，`key_equal()` 作为键相等谓词，`allocator_type()" "` 作为分配器，以及最大负载因子 `1.0` 构造一个空容器。" #: :366 #, safe-html, strict-same msgctxt ":366" 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[可默认构造^]要求。" #: :369 #, safe-html, strict-same msgctxt ":369" msgid "---" msgstr "---" #: :371 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :372 #, safe-html, strict-same msgid "" "```c++ explicit unordered_set(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = allocator_type" "()); ```" msgstr "" "```c++ explicit unordered_set(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" #: :379 #, 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, `a` as the allocator and " "a maximum load factor of `1.0`." msgstr "" "explicit unordered_set(size_type n, const hasher& hf = hasher(), const " "key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type());" #: :384 #, safe-html, strict-same msgctxt ":384" 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[可默认构造^]要求。" #: :387 #, safe-html, strict-same msgctxt ":387" msgid "---" msgstr "---" #: :389 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :400 #, 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, `a` as the allocator and " "a maximum load factor of `1.0` and inserts the elements from `[f, l)` into " "it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、 `a` 作为分配器，将最大负载因子设为 `1.0` ，并将区间 `++[++f, l)` 中" "的元素插入其中。" #: :403 #, safe-html, strict-same msgctxt ":403" 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[可默" "认构造] 要求。" #: :405 #, safe-html, strict-same msgctxt ":405" msgid "---" msgstr "---" #: :407 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :408 #, safe-html, strict-same msgid "```c++ unordered_set(const unordered_set& other); ```" msgstr "```c++ unordered_set(const unordered_set& other); ```" #: :412 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate, maximum load factor and allocator." msgstr "复制构造函数。复制所含元素、哈希函数、谓词、最大负载因子和分配器。" #: :414 #, 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` 存在且具有正确的签名，" "则将根据其结果来构造分配器。" #: :417 #, safe-html, strict-same msgctxt ":417" msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：;; `value_type` 需满足可复制构造要求。" #: :419 #, safe-html, strict-same msgctxt ":419" msgid "---" msgstr "---" #: :421 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :422 #, safe-html, strict-same msgid "```c++ unordered_set(unordered_set&& other); ```" msgstr "```c++ unordered_set(unordered_set&& other); ```" #: :426 #, safe-html, strict-same msgid "The move constructor." msgstr "移动构造函数。" #: :429 #, safe-html, strict-same msgid "" "Notes:;; This is implemented using Boost.Move. Requires:;; `value_type` is " "move-constructible." msgstr "说明：;; 该实现使用 Boost.Move。要求：;; `value_type` 需满足可移动构造要求。" #: :432 #, safe-html, strict-same msgctxt ":432" msgid "---" msgstr "---" #: :434 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器范围构造函数" #: :435 #, safe-html, strict-same msgid "" "```c++ template unordered_set(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template unordered_set(InputIterator f, " "InputIterator l, const allocator_type& a); ```" #: :440 #, safe-html, strict-same msgid "" "Constructs an empty container using `a` as the allocator, with the default " "hash function and key equality predicate and a maximum load factor of `1.0` " "and inserts the elements from `[f, l)` into it." msgstr "" "构造一个空容器，使用 `a` 作为分配器、默认的哈希函数和键相等性谓词，并将最大负" "载因子设为 `1.0` ，然后将 `[f, l)` 范围内的元素插入其中。" #: :443 #, safe-html, strict-same msgctxt ":443" 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[可默认构造^]要求。" #: :445 #, safe-html, strict-same msgctxt ":445" msgid "---" msgstr "---" #: :447 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :448 #, safe-html, strict-same msgid "```c++ explicit unordered_set(const Allocator& a); ```" msgstr "```c++ explicit unordered_set(const Allocator& a); ```" #: :452 #, safe-html, strict-same msgid "Constructs an empty container, using allocator `a`." msgstr "构造一个空容器，使用分配器 `a`。" #: :454 #, safe-html, strict-same msgctxt ":454" msgid "---" msgstr "---" #: :456 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :457 #, safe-html, strict-same msgid "" "```c++ unordered_set(const unordered_set& other, const Allocator& a); ```" msgstr "" "```c++ unordered_set(const unordered_set& other, const Allocator& a)" "; ```" #: :461 #, safe-html, strict-same msgid "" "Constructs an container, copying ``other``'s contained elements, hash " "function, predicate, maximum load factor, but using allocator `a`." msgstr "" "构造一个容器，移动 `other` 中所包含的元素，并获取其哈希函数、谓词及最大负载因" "子，但使用分配器 `a` 。" #: :463 #, safe-html, strict-same msgctxt ":463" msgid "---" msgstr "---" #: :465 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :466 #, safe-html, strict-same msgid "```c++ unordered_set(unordered_set&& other, const Allocator& a); ```" msgstr "" "```c++ unordered_set(unordered_set&& other, const Allocator& a); " "```" #: :470 #, safe-html, strict-same msgid "" "Construct a container moving ``other``'s contained elements, and having the " "hash function, predicate and maximum load factor, but using allocate `a`." msgstr "" "构造一个容器，移动 `other` 中所包含的元素，并获取其哈希函数、谓词及最大负载因" "子，但使用分配器 `a` 。" #: :473 #, safe-html, strict-same msgid "" "Notes:;; This is implemented using Boost.Move. Requires:;; `value_type` is " "move insertable." msgstr "说明：该实现使用 Boost.Move。要求：`value_type` 需满足可移动插入要求。" #: :476 #, safe-html, strict-same msgctxt ":476" msgid "---" msgstr "---" #: :478 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :488 #, 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, `a` as the allocator and " "a maximum load factor of `1.0` and inserts the elements from `il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、及 `a` 作为分配器，并设置最大负载因子为 `1.0` ，随后将 `il` 中的元素" "插入该容器。" #: :491 #, safe-html, strict-same msgctxt ":491" 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[可默" "认构造] 要求。" #: :493 #, safe-html, strict-same msgctxt ":493" msgid "---" msgstr "---" #: :495 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :496 #, safe-html, strict-same msgid "```c++ unordered_set(size_type n, const allocator_type& a); ```" msgstr "```c++ unordered_set(size_type n, const allocator_type& a); ```" #: :500 #, 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, `a` as " "the allocator and a maximum load factor of `1.0`." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数（应为默认哈希函数）" "、默认的键相等性谓词、 `a` 作为分配器，并设置最大负载因子为 `1.0` 。" #: :503 #, 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[可默认构造^]要求。" #: :506 #, safe-html, strict-same msgctxt ":506" msgid "---" msgstr "---" #: :508 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :509 #, safe-html, strict-same msgid "" "```c++ unordered_set(size_type n, const hasher& hf, const allocator_type& a)" "; ```" msgstr "" "```c++ unordered_set(size_type n, const hasher& hf, const " "allocator_type& a); ```" #: :513 #, 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, `a` as the allocator and " "a maximum load factor of `1.0`." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、默认的键相等性谓词" "、 `a` 作为分配器，并设置最大负载因子为 `1.0` 。" #: :516 #, 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[可默认构造^]要求。" #: :519 #, safe-html, strict-same msgctxt ":519" msgid "---" msgstr "---" #: :521 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :528 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` as the " "allocator, with the default hash function and key equality predicate and a " "maximum load factor of `1.0` and inserts the elements from `[f, l)` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器、默认的哈希函数和键相" "等性谓词，并设置最大负载因子为 `1.0` ，随后将区间 `++[++f, l)` 中的元素插入该" "容器。" #: :531 #, safe-html, strict-same msgctxt ":531" 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[可默认构造] 要求。" #: :533 #, safe-html, strict-same msgctxt ":533" msgid "---" msgstr "---" #: :535 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :543 #, 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 a maximum load factor of `1.0` and inserts the elements from `[f, l)` " "into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、默认的键相等性谓词" "、 `a` 作为分配器，并设置最大负载因子为 `1.0` ，随后将区间 `++[++f, l)` 中的" "元素插入该容器。" #: :546 #, safe-html, strict-same msgctxt ":546" 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[可默认构造] 要求。" #: :548 #, safe-html, strict-same msgctxt ":548" msgid "---" msgstr "---" #: :550 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :552 #, safe-html, strict-same msgid "" "```c++ unordered_set(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ unordered_set(std::initializer_list il, const " "allocator_type& a); ```" #: :556 #, safe-html, strict-same msgid "" "Constructs an empty container using `a` as the allocator and a maximum load " "factor of 1.0 and inserts the elements from `il` into it." msgstr "" "使用 `a` 作为分配器构造一个空容器，设置最大负载因子为 1.0，并将 `il` 中的元素" "插入其中。" #: :559 #, safe-html, strict-same msgctxt ":559" 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[可默认构造^]要求。" #: :561 #, safe-html, strict-same msgctxt ":561" msgid "---" msgstr "---" #: :563 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :565 #, safe-html, strict-same msgid "" "```c++ unordered_set(std::initializer_list il, size_type n, " "const allocator_type& a); ```" msgstr "" "```c++ unordered_set(std::initializer_list il, size_type n, " "const allocator_type& a); ```" #: :569 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` as the " "allocator and a maximum load factor of 1.0 and inserts the elements from " "`il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器，并设置最大负载因子为 " "1.0，随后将 `il` 中的元素插入该容器。" #: :572 #, safe-html, strict-same msgctxt ":572" 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[可默认构造^]要求。" #: :574 #, safe-html, strict-same msgctxt ":574" msgid "---" msgstr "---" #: :576 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :578 #, safe-html, strict-same msgid "" "```c++ unordered_set(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ unordered_set(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" #: :583 #, 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 a maximum load factor of 1.0 and " "inserts the elements from `il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器，" "设置最大负载因子为 1.0，并将 `il` 中的元素插入其中。" #: :586 #, safe-html, strict-same msgctxt ":586" 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[可默认构造^]要求。" #: :588 #, safe-html, strict-same msgctxt ":588" msgid "---" msgstr "---" #: :590 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :592 #, safe-html, strict-same msgid "```c++ ~unordered_set(); ```" msgstr "```c++ ~unordered_set(); ```" #: :597 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：析构函数会应用于每个元素，并且所有内存都会被释放。" #: :599 #, safe-html, strict-same msgctxt ":599" msgid "---" msgstr "---" #: :601 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :603 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :605 #, safe-html, strict-same msgid "```c++ unordered_set& operator=(const unordered_set& other); ```" msgstr "" "```c++ unordered_set& operator=(const unordered_set& other); ```" #: :609 #, safe-html, strict-same msgid "" "The assignment operator. Copies the contained elements, hash function, " "predicate and maximum load factor but not the allocator." msgstr "" "赋值运算符。该操作会复制容器内的元素、哈希函数、谓词及最大负载因子，但不会复" "制分配器。" #: :611 #, safe-html, strict-same msgid "" "If `Alloc::propagate_on_container_copy_assignment` exists and " "`Alloc::propagate_on_container_copy_assignment::value` is `true`, the " "allocator is overwritten, if not the copied elements are created using the " "existing allocator." msgstr "" "若 `Alloc::propagate_on_container_copy_assignment` 存在且 " "`Alloc::propagate_on_container_copy_assignment::value` 为 `true`，则覆盖分配" "器；否则，将使用现有分配器创建复制的元素。" #: :614 #, safe-html, strict-same msgctxt ":614" msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：`value_type` 需满足可复制构造要求。" #: :616 #, safe-html, strict-same msgctxt ":616" msgid "---" msgstr "---" #: :618 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :619 #, safe-html, strict-same msgid "" "```c++ unordered_set& operator=(unordered_set&& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_move_assignable_v && " "boost::is_nothrow_move_assignable_v); ``` The move assignment operator." msgstr "" "```c++ unordered_set& operator=(unordered_set&& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_move_assignable_v && " "boost::is_nothrow_move_assignable_v); ``` 移动赋值运算符。" #: :627 #, safe-html, strict-same msgid "" "If `Alloc::propagate_on_container_move_assignment` exists and " "`Alloc::propagate_on_container_move_assignment::value` is `true`, the " "allocator is overwritten, if not the moved elements are created using the " "existing allocator." msgstr "" "若 `Alloc::propagate_on_container_move_assignment` 存在且 " "`Alloc::propagate_on_container_move_assignment::value` 为 `true`，则覆盖分配" "器；否则，将使用现有分配器创建移动的元素。" #: :630 #, safe-html, strict-same msgid "Requires:;; `value_type` is move constructible." msgstr "要求：`value_type` 需满足可移动构造要求。" #: :632 #, safe-html, strict-same msgctxt ":632" msgid "---" msgstr "---" #: :634 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :635 #, safe-html, strict-same msgid "" "```c++ unordered_set& operator=(std::initializer_list il); ```" msgstr "" "```c++ unordered_set& operator=(std::initializer_list il); " "```" #: :639 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All existing elements are either " "overwritten by the new elements or destroyed." msgstr "将初始化列表中的值赋给容器。所有已存在的元素将被新元素覆盖或销毁。" #: :642 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] into the container and https://" "en.cppreference.com/w/cpp/named_req/CopyAssignable[CopyAssignable^]." msgstr "" "要求：`value_type` 需满足对容器而言的 https://en.cppreference.com/w/cpp/" "named_req/CopyInsertable[可复制插入^] 要求和 https://en.cppreference.com/w/" "cpp/named_req/CopyAssignable[可复制赋值^] 要求。" #: :644 #, safe-html, strict-same msgctxt ":644" msgid "---" msgstr "---" #: :646 #, safe-html, strict-same msgid "Iterators" msgstr "迭代器" #: :648 #, safe-html, strict-same msgctxt ":648" msgid "begin" msgstr "begin" #: :649 #, safe-html, strict-same msgid "" "```c++ iterator begin() noexcept; const_iterator begin() const " "noexcept; ```" msgstr "" "```c++ iterator begin() noexcept; const_iterator begin() const " "noexcept; ```" #: :655 #, 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." msgstr "返回：指向容器第一个元素的迭代器，若容器为空则返回容器尾后迭代器。" #: :657 #, safe-html, strict-same msgctxt ":657" msgid "---" msgstr "---" #: :659 #, safe-html, strict-same msgctxt ":659" msgid "end" msgstr "end" #: :660 #, safe-html, strict-same msgid "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; " "```" msgstr "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; " "```" #: :666 #, safe-html, strict-same msgid "" "Returns:;; An iterator which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后位置的迭代器。" #: :668 #, safe-html, strict-same msgctxt ":668" msgid "---" msgstr "---" #: :670 #, safe-html, strict-same msgctxt ":670" msgid "cbegin" msgstr "cbegin" #: :671 #, safe-html, strict-same msgid "```c++ const_iterator cbegin() const noexcept; ```" msgstr "```c++ const_iterator cbegin() const noexcept; ```" #: :676 #, 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." msgstr "" "返回：指向容器第一个元素的 `const_iterator`，若容器为空，则返回容器尾后迭代器" "。" #: :678 #, safe-html, strict-same msgctxt ":678" msgid "---" msgstr "---" #: :680 #, safe-html, strict-same msgctxt ":680" msgid "cend" msgstr "cend" #: :681 #, safe-html, strict-same msgid "```c++ const_iterator cend() const noexcept; ```" msgstr "```c++ const_iterator cend() const noexcept; ```" #: :686 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后位置的 `const_iterator`。" #: :688 #, safe-html, strict-same msgctxt ":688" msgid "---" msgstr "---" #: :690 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :692 #, safe-html, strict-same msgid "empty" msgstr "空" #: :694 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :699 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "返回：`size() == 0`" #: :701 #, safe-html, strict-same msgctxt ":701" msgid "---" msgstr "---" #: :703 #, safe-html, strict-same msgid "size" msgstr "大小" #: :705 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :710 #, safe-html, strict-same msgid "Returns:;; `std::distance(begin(), end())`" msgstr "返回：`std::distance(begin(), end())`" #: :712 #, safe-html, strict-same msgctxt ":712" msgid "---" msgstr "---" #: :714 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :716 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :721 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible container." msgstr "返回：可能的最大容器的 `size()`。" #: :723 #, safe-html, strict-same msgctxt ":723" msgid "---" msgstr "---" #: :725 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :727 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :728 #, safe-html, strict-same msgid "" "```c++ template std::pair emplace(Args&&... " "args); ```" msgstr "" "```c++ template std::pair emplace" "(Args&&... args); ```" #: :732 #, safe-html, strict-same msgctxt ":732" 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 value." msgstr "当且仅当容器中没有等价值的元素时，插入一个使用参数 `args` 构造的对象。" #: :735 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into `X` 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 value. " "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 factor to be greater to or equal to the " "maximum load factor. + + Pointers and references to elements are never " "invalidated." msgstr "" "要求：`value_type` 需从 `args` 处满足对 `X` 的 https://en.cppreference.com/w/" "cpp/named_req/EmplaceConstructible[可原位构造^] 要求。返回：若执行了插入，则" "返回类型中的布尔分量为 `true`。+ + 若执行了插入，则迭代器指向新插入的元素；否" "则指向等价的元素。 抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。 " "说明：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发" "生。+ + 指向元素的指针和引用永远不会失效。" #: :744 #, safe-html, strict-same msgctxt ":744" msgid "---" msgstr "---" #: :746 #, safe-html, strict-same msgid "emplace_hint" msgstr "emplace_hint" #: :747 #, 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); ```" #: :751 #, safe-html, strict-same msgctxt ":751" 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 value." msgstr "当且仅当容器中没有等价值的元素时，插入一个使用参数 `args` 构造的对象。" #: :753 #, safe-html, strict-same msgid "`position` is a suggestion to where the element should be inserted." msgstr "`position` 是一个关于元素应插入位置的提示。" #: :756 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into `X` from `args`. Returns:;; " "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:;; The standard is fairly vague on the meaning " "of the hint. But the only practical way to use it, and the only way that " "Boost.Unordered supports is to point to an existing element with the same " "key. + + Can invalidate iterators, but only if the insert causes the load " "factor to be greater to or equal to the maximum load factor. + + Pointers " "and references to elements are never invalidated." msgstr "" "要求：`value_type` 需从 `args` 处满足对 `X` 的 https://en.cppreference.com/w/" "cpp/named_req/EmplaceConstructible[可原位构造^] 要求。返回：若执行了插入，则" "迭代器指向新插入的元素；否则指向等价的元素。抛出：若调用 `hasher` 以外的操作" "抛出异常，则函数无效果。说明：标准对提示的含义表述相当模糊。但使用它的唯一实" "际方式，也是 Boost.Unordered 唯一支持的方式，是将其指向具有相同键的现有元素" "。+ +可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生" "。+ +指向元素的指针和引用永远不会失效。" #: :765 #, safe-html, strict-same msgctxt ":765" msgid "---" msgstr "---" #: :767 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :768 #, safe-html, strict-same msgid "```c++ std::pair insert(const value_type& obj); ```" msgstr "" "```c++ std::pair insert(const value_type& obj); " "```" #: :772 #, safe-html, strict-same msgctxt ":772" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中不存在等价键时，将 `obj` 对象插入到容器中。" #: :775 #, safe-html, strict-same 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 factor to " "be greater to or equal to the maximum load factor. + + Pointers and " "references to elements are never invalidated." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。返回：若执行了插入，则返回类型中的布尔分量" "为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素。抛" "出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。说明：可能使迭代器失效" "，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ +指向元素的指针和" "引用永远不会失效。" #: :784 #, safe-html, strict-same msgctxt ":784" msgid "---" msgstr "---" #: :786 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :787 #, safe-html, strict-same msgid "```c++ std::pair insert(value_type&& obj); ```" msgstr "" "```c++ std::pair insert(value_type&& obj); ```" #: :791 #, safe-html, strict-same msgctxt ":791" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中不存在等价键时，将 `obj` 对象插入到容器中。" #: :794 #, safe-html, strict-same 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 factor to " "be greater to or equal to the maximum load factor. + + Pointers and " "references to elements are never invalidated." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^] 要求。返回：若执行了插入，则返回类型中的布尔分量" "为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素。抛" "出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。说明：可能使迭代器失效" "，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ +指向元素的指针和" "引用永远不会失效。" #: :803 #, safe-html, strict-same msgctxt ":803" msgid "---" msgstr "---" #: :805 #, safe-html, strict-same msgid "Transparent Insert" msgstr "透明插入" #: :806 #, safe-html, strict-same msgid "```c++ template std::pair insert(K&& k); ```" msgstr "" "```c++ template std::pair insert" "(K&& k); ```" #: :810 #, safe-html, strict-same msgctxt ":810" 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++>++" "(k)` 构造的元素。" #: :813 #, safe-html, strict-same 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 factor to be greater to or equal to the maximum load " "factor. + + Pointers and references to elements are never invalidated. + + " "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[可原位构造^] 要求。返回：若执行了插入，则返回" "类型中的布尔分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指" "向等价的元素。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。说明：" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ " "+指向元素的指针和引用永远不会失效。+ +此重载仅在以下条件下参与重载决议" "：`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 " "`iterator` 和 `const_iterator` 均不能从 `K` 隐式转换。库假定 `Hash` 可同时以 " "`K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :824 #, safe-html, strict-same msgctxt ":824" msgid "---" msgstr "---" #: :826 #, safe-html, strict-same msgid "Copy Insert with Hint" msgstr "带提示的复制插入" #: :827 #, 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); ``` " "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." #: :832 #, safe-html, strict-same msgctxt ":832" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是插入元素位置的建议。" #: :835 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; 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:;; " "The standard is fairly vague on the meaning of the hint. But the only " "practical way to use it, and the only way that Boost.Unordered supports is " "to point to an existing element with the same key. + + Can invalidate " "iterators, but only if the insert causes the load factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。返回：若执行了插入，则迭代器指向新插入的元" "素；否则指向等价的元素。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效" "果。说明：标准对提示的含义表述相当模糊。但使用它的唯一实际方式，也是 " "Boost.Unordered 唯一支持的方式，是将其指向具有相同键的现有元素。+ +可能使迭代" "器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ +指向元素的" "指针和引用永远不会失效。" #: :844 #, safe-html, strict-same msgctxt ":844" msgid "---" msgstr "---" #: :846 #, safe-html, strict-same msgid "Move Insert with Hint" msgstr "带提示的移动插入" #: :847 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" msgstr "" "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" #: :851 #, safe-html, strict-same msgctxt ":851" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有等价的键时，将 `obj` 插入容器。" #: :853 #, safe-html, strict-same msgctxt ":853" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是一个关于元素应插入位置的建议。" #: :856 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; 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:;; " "The standard is fairly vague on the meaning of the hint. But the only " "practical way to use it, and the only way that Boost.Unordered supports is " "to point to an existing element with the same key. + + Can invalidate " "iterators, but only if the insert causes the load factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^] 要求。返回：若执行了插入，则迭代器指向新插入的元" "素；否则指向等价的元素。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效" "果。说明：标准对提示的含义表述相当模糊。但使用它的唯一实际方式，也是 " "Boost.Unordered 唯一支持的方式，是将其指向具有相同键的现有元素。+ +可能使迭代" "器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ +指向元素的" "指针和引用永远不会失效。" #: :865 #, safe-html, strict-same msgctxt ":865" msgid "---" msgstr "---" #: :867 #, safe-html, strict-same msgid "Transparent Insert with Hint" msgstr "带提示的透明插入" #: :868 #, safe-html, strict-same msgid "" "```c++ template iterator insert(const_iterator hint, K&& k); ```" msgstr "" "```c++ template iterator insert(const_iterator hint, " "K&& k); ```" #: :872 #, safe-html, strict-same msgctxt ":872" 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)` 构造的元" "素。" #: :874 #, safe-html, strict-same msgctxt ":874" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是插入元素位置的建议。" #: :877 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; 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:;; The standard is fairly vague on the meaning " "of the hint. But the only practical way to use it, and the only way that " "Boost.Unordered supports is to point to an existing element with the same " "key. + + Can invalidate iterators, but only if the insert causes the load " "factor to be greater to or equal to the maximum load factor. + + Pointers " "and references to elements are never invalidated. + + 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[可原位构造^] 要求。返回：若执行了插入，则迭代" "器指向新插入的元素；否则指向等价的元素。抛出：若调用 `hasher` 以外的操作抛出" "异常，则函数无效果。说明：标准对 hint 的含义表述相当模糊。但使用它的唯一实际" "方式，也是 Boost.Unordered 唯一支持的方式，是将其指向具有相同键的现有元素。+ " "+可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ " "+指向元素的指针和引用永远不会失效。+ +此重载仅在以下条件下参与重载决议" "：`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 " "`iterator` 和 `const_iterator` 均不能从 `K` 隐式转换。库假定 `Hash` 可同时以 " "`K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :888 #, safe-html, strict-same msgctxt ":888" msgid "---" msgstr "---" #: :890 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :891 #, safe-html, strict-same msgid "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" #: :895 #, safe-html, strict-same msgctxt ":895" 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 "将元素范围插入容器中。仅当容器中不存在等价键的元素时，才会插入相应元素。" #: :898 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into `X` 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 factor to " "be greater to or equal to the maximum load factor. + + Pointers and " "references to elements are never invalidated." msgstr "" "要求：`value_type` 需从 `*first` 处满足对 `X` 的 https://en.cppreference.com/" "w/cpp/named_req/EmplaceConstructible[可原位构造^] 要求。抛出：当插入单个元素" "时，若调用 `hasher` 以外的操作抛出异常，则函数无效果。说明：可能使迭代器失效" "，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ +指向元素的指针和" "引用永远不会失效。" #: :904 #, safe-html, strict-same msgctxt ":904" msgid "---" msgstr "---" #: :906 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :907 #, safe-html, strict-same msgid "```c++ void insert(std::initializer_list); ```" msgstr "```c++ void insert(std::initializer_list); ```" #: :911 #, safe-html, strict-same msgctxt ":911" 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 "将元素范围插入容器中。仅当容器中不存在等价键的元素时，才会插入相应元素。" #: :914 #, 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 factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated." msgstr "" "要求：`value_type` 需满足对容器而言的 https://en.cppreference.com/w/cpp/" "named_req/CopyInsertable[可复制插入^] 要求。抛出：当插入单个元素时，若调用 " "`hasher` 以外的操作抛出异常，则函数无效果。说明：可能使迭代器失效，但仅当插入" "导致负载因子大于或等于最大负载因子时才会发生。+ +指向元素的指针和引用永远不会" "失效。" #: :920 #, safe-html, strict-same msgctxt ":920" msgid "---" msgstr "---" #: :922 #, safe-html, strict-same msgid "Extract by Iterator" msgstr "通过迭代器提取" #: :923 #, safe-html, strict-same msgid "```c++ node_type extract(const_iterator position); ```" msgstr "```c++ node_type extract(const_iterator position); ```" #: :927 #, safe-html, strict-same msgid "Removes the element pointed to by `position`." msgstr "移除由 `position` 指向的元素。" #: :930 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` owning the element. Notes:;; In C++17 a node " "extracted using this method can be inserted into a compatible " "`unordered_multiset`, but that is not supported yet." msgstr "" "返回：一个拥有该元素的 `node_type`。说明：在 C++17 中，通过此方法提取的节点可" "以插入到兼容的 `unordered_multiset` 中，但该功能尚未支持。" #: :933 #, safe-html, strict-same msgctxt ":933" msgid "---" msgstr "---" #: :935 #, safe-html, strict-same msgid "Extract by Value" msgstr "通过键值提取元素" #: :936 #, 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); ```" #: :941 #, safe-html, strict-same msgid "Removes an element with key equivalent to `k`." msgstr "移除键等价于 `k` 的元素。" #: :944 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` owning the element if found, otherwise an empty " "`node_type`. Throws:;; Only throws an exception if it is thrown by `hasher` " "or `key_equal`. Notes:;; In C++17 a node extracted using this method can be " "inserted into a compatible `unordered_multiset`, but that is not supported " "yet. + + 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 "" "返回：若找到元素，则返回拥有该元素的 `node_type`；否则返回空 `node_type`。抛" "出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。说明：在 C++17 中，" "通过此方法提取的节点可以插入到兼容的 `unordered_multiset` 中，但该功能尚未支" "持。+ +`template` 重载仅在以下条件下参与重载决议" "：`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 " "`iterator` 和 `const_iterator` 均不能从 `K` 隐式转换。库假定 `Hash` 可同时以 " "`K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :950 #, safe-html, strict-same msgctxt ":950" msgid "---" msgstr "---" #: :952 #, safe-html, strict-same msgid "Insert with `node_handle`" msgstr "通过 `node++_++handle` 插入" #: :953 #, safe-html, strict-same msgid "```c++ insert_return_type insert(node_type&& nh); ```" msgstr "```c++ insert_return_type insert(node_type&& nh); ```" #: :957 #, safe-html, strict-same msgctxt ":957" msgid "If `nh` is empty, has no effect." msgstr "若 `nh` 为空节点，则此操作不产生任何效果。" #: :959 #, safe-html, strict-same msgctxt ":959" msgid "" "Otherwise inserts the element owned by `nh` if and only if there is no " "element in the container with an equivalent key." msgstr "否则，当且仅当容器中不存在等价键的元素时，才会插入 `nh` 所拥有的元素。" #: :962 #, safe-html, strict-same msgid "" "Requires:;; `nh` is empty or `nh.get_allocator()` is equal to the " "container's allocator. Returns:;; If `nh` was empty, returns an " "`insert_return_type` with: `inserted` equal to `false`, `position` equal to " "`end()` and `node` empty. + + Otherwise if there was already an element with " "an equivalent key, returns an `insert_return_type` with: `inserted` equal to " "`false`, `position` pointing to a matching element and `node` contains the " "node from `nh`. + + Otherwise if the insertion succeeded, returns an " "`insert_return_type` with: `inserted` equal to `true`, `position` pointing " "to the newly inserted element and `node` empty. 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 factor to be greater to or equal to the maximum load factor. + + " "Pointers and references to elements are never invalidated. + + In C++17 this " "can be used to insert a node extracted from a compatible " "`unordered_multiset`, but that is not supported yet." msgstr "" "要求：`nh` 为空或 `nh.get_allocator()` 与容器的分配器相等。返回：若 `nh` 为空" "，则返回一个 `insert_return_type`，其中：`inserted` 为 `false`，`position` 等" "于 `end()`，`node` 为空。+ +否则若已存在等价的键，则返回一个 " "`insert_return_type`，其中：`inserted` 为 `false`，`position` 指向匹配的元素" "，`node` 包含 `nh` 中的节点。+ +否则若插入成功，则返回一个 " "`insert_return_type`，其中：`inserted` 为 `true`，`position` 指向新插入的元素" "，`node` 为空。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。说明：" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ " "+指向元素的指针和引用永远不会失效。+ +在 C++17 中，该函数可用于插入从兼容的 " "`unordered_multiset` 中提取的节点，但该功能尚未支持。" #: :975 #, safe-html, strict-same msgctxt ":975" msgid "---" msgstr "---" #: :977 #, safe-html, strict-same msgid "Insert with Hint and `node_handle`" msgstr "带提示和 `node++_++handle` 的插入" #: :978 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" msgstr "" "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" #: :982 #, safe-html, strict-same msgctxt ":982" msgid "If `nh` is empty, has no effect." msgstr "若 `nh` 为空节点，则此操作不产生任何效果。" #: :984 #, safe-html, strict-same msgctxt ":984" msgid "" "Otherwise inserts the element owned by `nh` if and only if there is no " "element in the container with an equivalent key." msgstr "否则，当且仅当容器中不存在等价键的元素时，才会插入 `nh` 所拥有的元素。" #: :986 #, safe-html, strict-same msgid "" "If there is already an element in the container with an equivalent key has " "no effect on `nh` (i.e. `nh` still contains the node.)" msgstr "" "如果容器中已存在具有等价键的元素，则对 `nh` 不产生任何影响.（即 `nh` 仍持有该" "节点.）" #: :988 #, safe-html, strict-same msgctxt ":988" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是插入元素位置的建议。" #: :991 #, safe-html, strict-same msgid "" "Requires:;; `nh` is empty or `nh.get_allocator()` is equal to the " "container's allocator. Returns:;; If `nh` was empty returns `end()`. + + If " "there was already an element in the container with an equivalent key returns " "an iterator pointing to that. + + Otherwise returns an iterator pointing to " "the newly inserted element. Throws:;; If an exception is thrown by an " "operation other than a call to `hasher` the function has no effect. Notes:;; " "The standard is fairly vague on the meaning of the hint. But the only " "practical way to use it, and the only way that Boost.Unordered supports is " "to point to an existing element with the same key. + + Can invalidate " "iterators, but only if the insert causes the load factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated. + + This can be used to insert a node extracted from " "a compatible `unordered_multiset`." msgstr "" "要求：`nh` 为空或 `nh.get_allocator()` 与容器的分配器相等。返回：若 `nh` 为空" "，则返回 `end()`。+ +若容器中已存在等价的键，则返回指向该元素的迭代器。+ +否" "则，返回指向新插入元素的迭代器。抛出：若调用 `hasher` 以外的操作抛出异常，则" "函数无效果。说明：标准对 hint 的含义表述相当模糊。但使用它的唯一实际方式，也" "是 Boost.Unordered 唯一支持的方式，是将其指向具有相同键的现有元素。+ +可能使" "迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。+ +指向元" "素的指针和引用永远不会失效。+ +该函数可用于插入从兼容的 `unordered_multiset` " "中提取的节点。" #: :1006 #, safe-html, strict-same msgctxt ":1006" msgid "---" msgstr "---" #: :1008 #, safe-html, strict-same msgid "Erase by Position" msgstr "通过位置擦除" #: :1010 #, safe-html, strict-same msgid "" "```c++ iterator erase(iterator position); iterator erase(const_iterator " "position); ```" msgstr "" "```c++ iterator erase(iterator position); iterator erase(const_iterator " "position); ```" #: :1015 #, safe-html, strict-same msgctxt ":1015" msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :1018 #, safe-html, strict-same msgid "" "Returns:;; The iterator following `position` before the erasure. Throws:;; " "Only throws an exception if it is thrown by `hasher` or `key_equal`. " "Notes:;; In older versions this could be inefficient because it had to " "search through several buckets to find the position of the returned " "iterator. The data structure has been changed so that this is no longer the " "case, and the alternative erase methods have been deprecated." msgstr "" "返回：擦除前指向 `position` 之后位置的迭代器。抛出：仅当 `hasher` 或 " "`key_equal` 抛出异常时才会抛出异常。说明：在旧版本中，该操作可能效率较低，因" "为它需要搜索多个桶才能找到所返回迭代器的位置。数据结构已做修改，此问题已不复" "存在，并且其他替代的 `erase` 方法已被弃用。" #: :1022 #, safe-html, strict-same msgctxt ":1022" msgid "---" msgstr "---" #: :1024 #, safe-html, strict-same msgid "Erase by Value" msgstr "通过值擦除" #: :1025 #, 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); ```" #: :1030 #, safe-html, strict-same msgid "Erase all elements with key equivalent to `k`." msgstr "擦除所有键等价于 `k` 的元素。" #: :1033 #, 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 "" "返回：擦除的元素数量。抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异" "常。说明：`template` 重载仅在以下条件下参与重载决议" "：`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 " "`iterator` 和 `const_iterator` 均不能从 `K` 隐式转换。库假定 `Hash` 可同时以 " "`K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :1037 #, safe-html, strict-same msgctxt ":1037" msgid "---" msgstr "---" #: :1039 #, safe-html, strict-same msgid "Erase Range" msgstr "范围擦除" #: :1041 #, safe-html, strict-same msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```" msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```" #: :1045 #, safe-html, strict-same msgid "Erases the elements in the range from `first` to `last`." msgstr "擦除从 `first` 到 `last` 范围内（包含 `first` ，不包含 `last` ）的元素。" #: :1048 #, safe-html, strict-same msgid "" "Returns:;; The iterator following the erased elements - i.e. `last`. " "Throws:;; Only throws an exception if it is thrown by `hasher` or " "`key_equal`. + + In this implementation, this overload doesn't call either " "function object's methods so it is no throw, but this might not be true in " "other implementations." msgstr "" "返回：指向被擦除元素之后位置的迭代器，即 `last`。抛出：仅当 `hasher` 或 " "`key_equal` 抛出异常时才会抛出异常。+ + 在此实现中，此重载不会调用这两个函数" "对象的任何方法，因此不会抛出异常，但在其他实现中可能并非如此。" #: :1053 #, safe-html, strict-same msgctxt ":1053" msgid "---" msgstr "---" #: :1055 #, safe-html, strict-same msgid "quick_erase" msgstr "quick_erase" #: :1056 #, safe-html, strict-same msgid "```c++ void quick_erase(const_iterator position); ```" msgstr "```c++ void quick_erase(const_iterator position); ```" #: :1060 #, safe-html, strict-same msgctxt ":1060" msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :1063 #, safe-html, strict-same msgctxt ":1063" msgid "" "Throws:;; Only throws an exception if it is thrown by `hasher` or " "`key_equal`. + + In this implementation, this overload doesn't call either " "function object's methods so it is no throw, but this might not be true in " "other implementations. Notes:;; This method was implemented because " "returning an iterator to the next element from erase was expensive, but the " "container has been redesigned so that is no longer the case. So this method " "is now deprecated." msgstr "" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。 \n" "+ + 在此实现中，此重载不会调用这两个函数对象的任何方法，因此不会抛出异常，但" "在其他实现中可能并非如此。 \n" "说明：此方法最初实现的原因是，从 `erase` 返回指向下一个元素的迭代器开销较大，" "但容器已经过重新设计，该问题已不复存在。因此，此方法现已弃用。" #: :1068 #, safe-html, strict-same msgctxt ":1068" msgid "---" msgstr "---" #: :1070 #, safe-html, strict-same msgid "erase_return_void" msgstr "erase_return_void" #: :1071 #, safe-html, strict-same msgid "```c++ void erase_return_void(const_iterator position); ```" msgstr "```c++ void erase_return_void(const_iterator position); ```" #: :1075 #, safe-html, strict-same msgctxt ":1075" msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :1078 #, safe-html, strict-same msgctxt ":1078" msgid "" "Throws:;; Only throws an exception if it is thrown by `hasher` or " "`key_equal`. + + In this implementation, this overload doesn't call either " "function object's methods so it is no throw, but this might not be true in " "other implementations. Notes:;; This method was implemented because " "returning an iterator to the next element from erase was expensive, but the " "container has been redesigned so that is no longer the case. So this method " "is now deprecated." msgstr "" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出异常。 \n" "+ + 在此实现中，此重载不会调用这两个函数对象的任何方法，因此不会抛出异常，但" "在其他实现中可能并非如此。 \n" "说明：此方法最初实现的原因是，从 `erase` 返回指向下一个元素的迭代器开销较大，" "但容器已经过重新设计，该问题已不复存在。因此，此方法现已弃用。" #: :1083 #, safe-html, strict-same msgctxt ":1083" msgid "---" msgstr "---" #: :1085 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :1086 #, safe-html, strict-same msgid "" "```c++ void swap(unordered_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_swappable_v && boost::is_nothrow_swappable_v); " "```" msgstr "" "```c++ void swap(unordered_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_swappable_v && " "boost::is_nothrow_swappable_v); ```" #: :1093 #, safe-html, strict-same msgid "Swaps the contents of the container with the parameter." msgstr "交换容器与参数的内容。" #: :1095 #, safe-html, strict-same msgctxt ":1095" 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` ，则交" "换容器的分配器。则，在分配器不相等的情况下进行交换将导致未定义行为。" #: :1098 #, safe-html, strict-same msgid "" "Throws:;; Doesn't throw an exception unless it is thrown by the copy " "constructor or copy assignment operator of `key_equal` or `hasher`. Notes:;; " "The exception specifications aren't quite the same as the C++11 standard, as " "the equality predicate and hash function are swapped using their copy " "constructors." msgstr "" "抛出：除非 `key_equal` 或 `hasher` 的复制构造函数或复制赋值运算符抛出异常，否" "则不会抛出异常。说明：由于相等谓词和哈希函数是通过它们的复制构造函数进行交换" "的，因此异常规范与 C++11 标准并不完全相同。" #: :1101 #, safe-html, strict-same msgctxt ":1101" msgid "---" msgstr "---" #: :1103 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1104 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :1108 #, safe-html, strict-same msgid "Erases all elements in the container." msgstr "擦除容器中的所有元素。" #: :1111 #, safe-html, strict-same msgid "Postconditions:;; `size() == 0` Throws:;; Never throws an exception." msgstr "后置条件：`size() == 0` 抛出：永不抛出异常。" #: :1114 #, safe-html, strict-same msgctxt ":1114" msgid "---" msgstr "---" #: :1116 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1117 #, safe-html, strict-same msgid "" "```c++ template void merge(unordered_set& source); template void merge" "(unordered_set&& source); template void merge(unordered_multiset& source); " "template void merge(unordered_multiset&& source); ```" msgstr "" "```c++ template void merge" "(unordered_set& source); " "template void merge(unordered_set&& source); template void merge(unordered_multiset& source); template " "void merge(unordered_multiset" "&& source); ```" #: :1128 #, safe-html, strict-same msgid "" "Attempt to \"merge\" two containers by iterating `source` and extracting any " "node in `source` that is not contained in `*this` and then inserting it into " "`*this`." msgstr "" "通过遍历 `source` 容器，提取其中所有不包含在 `++*++this` 中的节点，并将其插入" "到 `++*++this` 中，以此尝试将两个容器\"合并\"。" #: :1131 #, safe-html, strict-same msgid "" "Because `source` can have a different hash function and key equality " "predicate, the key of each node in `source` is rehashed using `this\\->" "hash_function()` and then, if required, compared using `this\\->key_eq()`." msgstr "" "由于 `source` 可以有不同的哈希函数和键相等性谓词，因此会使用 `this-" "++>++hash++_++function()` 操作对 `source` 中每个节点的键进行重哈希，并在需" "要时使用 `this-++>++key++_++eq()` 进行比较。" #: :1134 #, safe-html, strict-same msgid "" "The behavior of this function is undefined if `this\\->get_allocator() != " "source.get_allocator()`." msgstr "" "如果 `this-++>++get++_++allocator() != source.get++_++allocator()` ，则此" "函数的行为未定义。" #: :1136 #, safe-html, strict-same msgid "" "This function does not copy or move any elements and instead simply " "relocates the nodes from `source` into `*this`." msgstr "此函数不会复制或移动任何元素，而是仅将节点从 `source` 重新定位到 `*this` 中。" #: :1140 #, safe-html, strict-same msgid "Notes:;; + --" msgstr "说明：+ --" #: :1143 #, safe-html, strict-same msgid "Pointers and references to transferred elements remain valid." msgstr "指向被转移元素的指针和引用保持有效。" #: :1144 #, safe-html, strict-same msgid "Invalidates iterators to transferred elements." msgstr "使指向被转移元素的迭代器失效。" #: :1145 #, safe-html, strict-same msgid "Invalidates iterators belonging to `*this`." msgstr "使属于 `++*++this` 的迭代器失效。" #: :1146 #, safe-html, strict-same msgid "Iterators to non-transferred elements in `source` remain valid." msgstr "指向 `source` 中未被转移元素的迭代器保持有效。" #: :1147 #, safe-html, strict-same msgid "--" msgstr "--" #: :1149 #, safe-html, strict-same msgctxt ":1149" msgid "---" msgstr "---" #: :1151 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1153 #, safe-html, strict-same msgid "get_allocator" msgstr "get++_++allocator" #: :1154 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const; ```" msgstr "``` allocator_type get_allocator() const; ```" #: :1158 #, safe-html, strict-same msgctxt ":1158" msgid "---" msgstr "---" #: :1160 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1161 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :1166 #, safe-html, strict-same msgid "Returns:;; The container's hash function." msgstr "返回：容器的哈希函数。" #: :1168 #, safe-html, strict-same msgctxt ":1168" msgid "---" msgstr "---" #: :1170 #, safe-html, strict-same msgid "key_eq" msgstr "key++_++eq" #: :1172 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1177 #, safe-html, strict-same msgid "Returns:;; The container's key equality predicate" msgstr "返回：容器的键相等谓词。" #: :1179 #, safe-html, strict-same msgctxt ":1179" msgid "---" msgstr "---" #: :1181 #, safe-html, strict-same msgid "Lookup" msgstr "查找" #: :1183 #, safe-html, strict-same msgid "find" msgstr "find" #: :1184 #, 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); " "template const_iterator find(const K& k) const; template " "iterator find(CompatibleKey const& k, CompatibleHash const& hash, " "CompatiblePredicate const& eq); template const_iterator find" "(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate " "const& eq) const; ```" msgstr "" "```c++ iterator find(const key_type& k); const_iterator find" "(const key_type& k) const; template iterator find" "(const K& k); template const_iterator find(const K& k) " "const; template iterator find" "(CompatibleKey const& k, CompatibleHash const& hash, " "CompatiblePredicate const& eq); template const_iterator " "find(CompatibleKey const& k, CompatibleHash const& hash, " "CompatiblePredicate const& eq) const; ```" #: :1200 #, safe-html, strict-same msgid "" "Returns:;; An iterator pointing to an element with key equivalent to `k`, or " "`b.end()` if no such element exists. Notes:;; The templated overloads " "containing `CompatibleKey`, `CompatibleHash` and `CompatiblePredicate` are " "non-standard extensions which allow you to use a compatible hash function " "and equality predicate for a key of a different type in order to avoid an " "expensive type cast. In general, its use is not encouraged and instead the " "`K` member function templates should be used. + + 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` 等价的元素的迭代器，若不存在这样的元素则返回 `b.end()`。说" "明：包含 `CompatibleKey`、`CompatibleHash` 和 `CompatiblePredicate` 的模板化" "重载是非标准扩展，允许您使用兼容的哈希函数和相等谓词来处理不同类型的键，以避" "免昂贵的类型转换。通常不鼓励使用它们，而应使用 `K` 成员函数模板。+ " "+`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实" "例化 `Key` 类型对象的开销。" #: :1205 #, safe-html, strict-same msgctxt ":1205" msgid "---" msgstr "---" #: :1207 #, safe-html, strict-same msgid "count" msgstr "count" #: :1208 #, 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; ```" #: :1215 #, 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` 等价的元素数量。说明：`template` 重载仅在 " "`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与" "重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。这实" "现了异构查找，从而避免了实例化 `Key` 类型对象的开销。" #: :1218 #, safe-html, strict-same msgctxt ":1218" msgid "---" msgstr "---" #: :1220 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1221 #, 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; ```" #: :1228 #, 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` 的元素。说明" "：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实" "例化 `Key` 类型对象的开销。" #: :1231 #, safe-html, strict-same msgctxt ":1231" msgid "---" msgstr "---" #: :1233 #, safe-html, strict-same msgid "equal_range" msgstr "equal++_++range" #: :1234 #, 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; ```" "" #: :1244 #, 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())`。说明：`template` 重载仅在 " "`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与" "重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。这实" "现了异构查找，从而避免了实例化 `Key` 类型对象的开销。" #: :1247 #, safe-html, strict-same msgctxt ":1247" msgid "---" msgstr "---" #: :1249 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1251 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket++_++count" #: :1252 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1257 #, safe-html, strict-same msgid "Returns:;; The number of buckets." msgstr "返回：桶的数量。" #: :1259 #, safe-html, strict-same msgctxt ":1259" msgid "---" msgstr "---" #: :1261 #, safe-html, strict-same msgid "max_bucket_count" msgstr "max_bucket_count" #: :1262 #, safe-html, strict-same msgid "```c++ size_type max_bucket_count() const noexcept; ```" msgstr "```c++ size_type max_bucket_count() const noexcept; ```" #: :1267 #, safe-html, strict-same msgid "Returns:;; An upper bound on the number of buckets." msgstr "返回：桶数的上限。" #: :1269 #, safe-html, strict-same msgctxt ":1269" msgid "---" msgstr "---" #: :1271 #, safe-html, strict-same msgid "bucket_size" msgstr "桶大小" #: :1272 #, safe-html, strict-same msgid "```c++ size_type bucket_size(size_type n) const; ```" msgstr "```c++ size_type bucket_size(size_type n) const; ```" #: :1277 #, safe-html, strict-same msgid "" "Requires:;; `n < bucket_count()` Returns:;; The number of elements in bucket " "`n`." msgstr "要求：`n < bucket_count()` 返回：桶 `n` 中的元素数量。" #: :1280 #, safe-html, strict-same msgctxt ":1280" msgid "---" msgstr "---" #: :1282 #, safe-html, strict-same msgid "bucket" msgstr "桶" #: :1283 #, safe-html, strict-same msgid "" "```c++ size_type bucket(const key_type& k) const; template " "size_type bucket(const K& k) const; ```" msgstr "" "```c++ size_type bucket(const key_type& k) const; template " "size_type bucket(const K& k) const; ```" #: :1289 #, safe-html, strict-same msgid "" "Returns:;; The index of the bucket which would contain an element with key " "`k`. Postconditions:;; The return value is less than `bucket_count()`. " "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` 的元素的桶索引。后置条件：返回值小于 `bucket_count()`。" "说明：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。这实现了异构查找，从而避免了实" "例化 `Key` 类型对象的开销。" #: :1293 #, safe-html, strict-same msgctxt ":1293" msgid "---" msgstr "---" #: :1295 #, safe-html, strict-same msgctxt ":1295" msgid "begin" msgstr "begin" #: :1297 #, safe-html, strict-same msgid "" "```c++ local_iterator begin(size_type n); const_local_iterator begin" "(size_type n) const; ```" msgstr "" "```c++ local_iterator begin(size_type n); const_local_iterator begin" "(size_type n) const; ```" #: :1303 #, safe-html, strict-same msgid "" "Requires:;; `n` shall be in the range `[0, bucket_count())`. Returns:;; A " "local iterator pointing the first element in the bucket with index `n`." msgstr "" "要求：`n` 应在 `[0, bucket_count())` 范围内。返回：指向索引为 `n` 的桶中第一" "个元素的局部迭代器。" #: :1306 #, safe-html, strict-same msgctxt ":1306" msgid "---" msgstr "---" #: :1308 #, safe-html, strict-same msgctxt ":1308" msgid "end" msgstr "end" #: :1309 #, safe-html, strict-same msgid "" "```c++ local_iterator end(size_type n); const_local_iterator end(size_type " "n) const; ```" msgstr "" "```c++ local_iterator end(size_type n); const_local_iterator end(size_type " "n) const; ```" #: :1315 #, safe-html, strict-same msgid "" "Requires:;; `n` shall be in the range `[0, bucket_count())`. Returns:;; A " "local iterator pointing the 'one past the end' element in the bucket with " "index `n`." msgstr "" "要求：`n` 应在 `[0, bucket_count())` 范围内。返回：指向索引为 `n` 的桶中“尾后" "”元素的局部迭代器。" #: :1318 #, safe-html, strict-same msgctxt ":1318" msgid "---" msgstr "---" #: :1320 #, safe-html, strict-same msgctxt ":1320" msgid "cbegin" msgstr "cbegin" #: :1321 #, safe-html, strict-same msgid "```c++ const_local_iterator cbegin(size_type n) const; ```" msgstr "```c++ const_local_iterator cbegin(size_type n) const; ```" #: :1326 #, safe-html, strict-same msgid "" "Requires:;; `n` shall be in the range `[0, bucket_count())`. Returns:;; A " "constant local iterator pointing the first element in the bucket with index " "`n`." msgstr "" "要求：`n` 应在 `[0, bucket_count())` 范围内。返回：指向索引为 `n` 的桶中第一" "个元素的常量局部迭代器。" #: :1329 #, safe-html, strict-same msgctxt ":1329" msgid "---" msgstr "---" #: :1331 #, safe-html, strict-same msgctxt ":1331" msgid "cend" msgstr "cend" #: :1332 #, safe-html, strict-same msgid "```c++ const_local_iterator cend(size_type n) const; ```" msgstr "```c++ const_local_iterator cend(size_type n) const; ```" #: :1337 #, safe-html, strict-same msgid "" "Requires:;; `n` shall be in the range `[0, bucket_count())`. Returns:;; A " "constant local iterator pointing the 'one past the end' element in the " "bucket with index `n`." msgstr "" "要求：`n` 应在 `[0, bucket_count())` 范围内。返回：指向索引为 `n` 的桶中“尾后" "”元素的常量局部迭代器。" #: :1340 #, safe-html, strict-same msgctxt ":1340" msgid "---" msgstr "---" #: :1342 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1344 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1345 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1350 #, safe-html, strict-same msgid "Returns:;; The average number of elements per bucket." msgstr "返回：每个桶的平均元素数量。" #: :1352 #, safe-html, strict-same msgctxt ":1352" msgid "---" msgstr "---" #: :1354 #, safe-html, strict-same msgid "max_load_factor" msgstr "max_load_factor" #: :1356 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1361 #, safe-html, strict-same msgid "Returns:;; Returns the current maximum load factor." msgstr "返回：当前最大负载因子。" #: :1363 #, safe-html, strict-same msgctxt ":1363" msgid "---" msgstr "---" #: :1365 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置max_load_factor（最大负载因子）" #: :1366 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1371 #, safe-html, strict-same msgid "" "Effects:;; Changes the container's maximum load factor, using `z` as a hint." msgstr "效果：使用 `z` 作为提示，更改容器的最大负载因子。" #: :1373 #, safe-html, strict-same msgctxt ":1373" msgid "---" msgstr "---" #: :1375 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1376 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1380 #, safe-html, strict-same msgid "" "Changes the number of buckets 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()` 。" #: :1382 #, safe-html, strict-same msgid "" "When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array." msgstr "当 `size() == 0` 时，`rehash(0)` 将释放底层桶数组。" #: :1384 #, safe-html, strict-same msgctxt ":1384" msgid "" "Invalidates iterators, and changes the order of elements. Pointers and " "references to elements are not invalidated." msgstr "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。" #: :1387 #, safe-html, strict-same msgctxt ":1387" 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 "抛出：若抛出异常（除非由容器的哈希函数或比较函数抛出），则该函数无效果。" #: :1389 #, safe-html, strict-same msgctxt ":1389" msgid "---" msgstr "---" #: :1391 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1392 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1396 #, safe-html, strict-same msgid "" "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`, or `a.rehash(1)` if " "`n > 0` and `a.max_load_factor() == std::numeric_limits::infinity()`." msgstr "" "等价于 `a.rehash(ceil(n / a.max_load_factor()))`，若 `n > 0` 且 " "`a.max_load_factor() == std::numeric_limits::infinity()` 则等价于 " "`a.rehash(1)`。" #: :1398 #, 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` 类似，该函数可用于增加或减少容器中的桶数量。" #: :1400 #, safe-html, strict-same msgctxt ":1400" msgid "" "Invalidates iterators, and changes the order of elements. Pointers and " "references to elements are not invalidated." msgstr "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。" #: :1403 #, safe-html, strict-same msgctxt ":1403" 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 "抛出：若抛出异常（除非由容器的哈希函数或比较函数抛出），则该函数无效果。" #: :1406 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1407 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "如果以下任何一条件为真，则推导指引将不参与重载决议：" #: :1409 #, 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` 模板参数，且为该参数推导出的类型" "符合分配器要求。" #: :1414 #, 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` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1418 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "__iter-value-type__" #: :1426 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1428 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1429 #, safe-html, strict-same msgid "" "```c++ template bool " "operator==(const unordered_set& x, const " "unordered_set& y); ```" msgstr "" "```c++ template " "bool operator==(const unordered_set" "& x, const unordered_set& y); " "```" #: :1435 #, 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`。" #: :1438 #, safe-html, strict-same msgctxt ":1438" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "说明：如果两个容器的相等谓词不等价，则行为未定义。" #: :1440 #, safe-html, strict-same msgctxt ":1440" msgid "---" msgstr "---" #: :1442 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1443 #, safe-html, strict-same msgid "" "```c++ template bool " "operator!=(const unordered_set& x, const " "unordered_set& y); ```" msgstr "" "```c++ template " "bool operator!=(const unordered_set" "& x, const unordered_set& y); " "```" #: :1449 #, 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`。" #: :1452 #, safe-html, strict-same msgctxt ":1452" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器的相等谓词不等价，则行为未定义。" #: :1454 #, safe-html, strict-same msgctxt ":1454" msgid "---" msgstr "---" #: :1456 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1457 #, safe-html, strict-same msgid "" "```c++ template void swap" "(unordered_set& x, unordered_set& y) noexcept(noexcept(x.swap(y))); ```" msgstr "" "```c++ template " "void swap(unordered_set& x, " "unordered_set& y) noexcept" "(noexcept(x.swap(y))); ```" #: :1464 #, safe-html, strict-same msgid "Swaps the contents of `x` and `y`." msgstr "交换 `x` 和 `y` 的内容。" #: :1466 #, safe-html, strict-same msgctxt ":1466" 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1469 #, safe-html, strict-same msgid "" "Effects:;; `x.swap(y)` Throws:;; Doesn't throw an exception unless it is " "thrown by the copy constructor or copy assignment operator of `key_equal` or " "`hasher`. Notes:;; The exception specifications aren't quite the same as the " "C++11 standard, as the equality predicate and hash function are swapped " "using their copy constructors." msgstr "" "效果：`x.swap(y)` 抛出：除非 `key_equal` 或 `hasher` 的复制构造函数或复制赋" "值运算符抛出异常，否则不会抛出异常。 注意：由于相等谓词和哈希函数是通过它们" "的复制构造函数进行交换的，因此异常规范与 C++11 标准并不完全相同。" #: :1473 #, safe-html, strict-same msgctxt ":1473" msgid "---" msgstr "---" #: :1475 #, safe-html, strict-same msgid "erase_if" msgstr "erase_if" #: :1476 #, safe-html, strict-same msgid "" "```c++ template " "typename unordered_set::size_type erase_if(unordered_set& c, Predicate pred); ```" msgstr "" "```c++ template typename unordered_set::size_type " "erase_if(unordered_set& c, Predicate pred); " "```" #: :1482 #, safe-html, strict-same msgid "" "Traverses the container `c` and removes all elements for which the supplied " "predicate returns `true`." msgstr "遍历容器 `c`，并移除所有使得给定谓词返回 `true` 的元素。" #: :1485 #, 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 "" "返回：被擦除的元素数量。注意：等价于：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();" #: :1500 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1502 #, safe-html, strict-same msgid "" "``unordered_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++_++set` 可通过本库提供的 API，借助 link:../../../../../" "serialization/index.html[Boost.Serialization] 实现序列化存档与读取功能。同时" "支持常规格式与 XML 格式的归档。" #: :1506 #, safe-html, strict-same msgid "Saving an unordered_set to an archive" msgstr "将 unordered++_++set 保存到归档" #: :1508 #, safe-html, strict-same msgid "" "Saves all the elements of an `unordered_set` `x` to an archive (XML archive) " "`ar`." msgstr "将 `unordered++_++set` 对象 `x` 的所有元素保存到归档（XML 归档） `ar` 中。" #: :1511 #, 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 序列化），且需要支持 " "Boost.Serialization 的 `save++_++construct++_++data` / " "`load++_++construct++_++data` 协议（该协议自动支持满足 https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造] 要求的类" "型）。" #: :1517 #, safe-html, strict-same msgctxt ":1517" msgid "---" msgstr "---" #: :1519 #, safe-html, strict-same msgid "Loading an unordered_set from an archive" msgstr "从归档加载 unordered++_++set" #: :1521 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of an `unordered_set` `x` and inserts from " "an archive (XML archive) `ar` restored copies of the elements of the " "original `unordered_set` `other` saved to the storage read by `ar`." msgstr "" "删除 `unordered++_++set` 对象 `x` 的所有预先存在的元素，并从归档（XML 归档） " "`ar` 中读取原始 `unordered++_++set` 对象 `other` 先前保存至存储的元素副本并插" "入到 `x` 中。" #: :1526 #, 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()`. Note:;; If the archive was saved using a release of " "Boost prior to Boost 1.84, the configuration macro " "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0` has to be globally " "defined for this operation to succeed; otherwise, an exception is thrown." msgstr "" "要求;; `value++_++type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入] 要求，且 `x.key++_++equal()` 在功能上需等价于 " "`other.key++_++equal()` 。 注意;; 若归档文件是使用 Boost 1.84 之前的版本保存" "的，则必须全局定义配置宏 " "`BOOST++_++UNORDERED++_++ENABLE++_++SERIALIZATION++_++COMPATIBILITY++_++V0` " "才能成功执行此操作；否则将抛出异常。" #: :1532 #, safe-html, strict-same msgctxt ":1532" msgid "---" msgstr "---" #: :1534 #, safe-html, strict-same msgid "Saving an iterator/const_iterator to an archive" msgstr "将迭代器/常量迭代器保存到归档" #: :1536 #, 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 "" "将 `iterator` （ `const++_++iterator` ）常量迭代器 `it` 的位置信息保存到归档" "（XML 归档） `ar` 中。 `it` 可以是 `end()` 迭代器。" #: :1540 #, safe-html, strict-same msgid "" "Requires:;; The `unordered_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++_++set` `x` 必须已预先保存至归档 `ar` " "，且在保存 `x` 和保存 `it` 的时间间隔内 `x` 执行任何修改操作。" #: :1544 #, safe-html, strict-same msgctxt ":1544" msgid "---" msgstr "---" #: :1546 #, safe-html, strict-same msgid "Loading an iterator/const_iterator from an archive" msgstr "从归档加载迭代器/常量迭代器" #: :1548 #, 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 "" "使 `iterator` （ `const++_++iterator` ） `it` 指向原始 `iterator` （ " "`const++_++iterator` ）所恢复的位置。该原始迭代器已被保存到由归档（XML 归档" "） `ar` 读取的存储中。" #: :1553 #, safe-html, strict-same msgid "" "Requires:;; If `x` is the `unordered_set` `it` points to, no modifying " "operations have been issued on `x` between loading of `x` and loading of " "`it`." msgstr "" "要求;; 如果 `x` 是 `it` 指向的 `unordered++_++set` ，则在加载 `x` 与加载 " "`it` 的时间间隔内，不得对 `x` 执行任何修改操作。"