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 09:17+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: Chinese (Simplified Han script) <https://"
"insights.cppalliance.org/weblate/projects/boost-unordered-documentation-"
"zh_Hans/doc-modules-root-pages-reference-unordered-multimap-adoc/zh_Hans/>\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_multimap"
msgstr "类模板 unordered_multimap"

#: :4
#, safe-html, strict-same
msgid ":idprefix: unordered_multimap_"
msgstr ":idprefix: unordered_multimap_"

#: :6
#, safe-html, strict-same
msgid ""
"`boost::unordered_multimap` — An unordered associative container that "
"associates keys with another value. The same key can be stored multiple "
"times."
msgstr ""
"`boost::unordered_multimap` — 一个无序关联容器，将键与对应值相关联。同一个键"
"可以多次存储。"

#: :8
#, safe-html, strict-same
msgid "Synopsis"
msgstr "概要"

#: :247
#, safe-html, strict-same
msgctxt ":247"
msgid "---"
msgstr "---"

#: :249
#, safe-html, strict-same
msgid "Description"
msgstr "描述"

#: :251
#, safe-html, strict-same
msgid "*Template Parameters*"
msgstr "*模板参数*"

#: :254
#, safe-html, strict-same
msgid "_Key_"
msgstr "_键_"

#: :254
#, 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` 能够销毁它）。"

#: :254
#, safe-html, strict-same
msgid "_T_"
msgstr "_T_"

#: :254
#, safe-html, strict-same
msgid ""
"`T` must be https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] "
"from the container (i.e. `allocator_traits` can destroy it)."
msgstr ""
"`T` 必须可以从容器中 https://en.cppreference.com/w/cpp/named_req/"
"Erasable[Erasable^]（即 `allocator_traits` 能够销毁它）。"

#: :254
#, safe-html, strict-same
msgid "_Hash_"
msgstr "_Hash_"

#: :254
#, 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` 类型的值。"

#: :254
#, safe-html, strict-same
msgid "_Pred_"
msgstr "_Pred_"

#: :254
#, 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` 类型"
"的参数，并返回一个 `bool` 类型的值。"

#: :254
#, safe-html, strict-same
msgid "_Allocator_"
msgstr "_Allocator_"

#: :254
#, safe-html, strict-same
msgid ""
"An allocator whose value type is the same as the container's value type."
msgstr "一个分配器，其值类型与容器的值类型相同。"

#: :270
#, 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[异形指针] 的分配器。"

#: :274
#, safe-html, strict-same
msgid ""
"The elements are organized into buckets. Keys with the same hash code are "
"stored in the same bucket."
msgstr "元素被组织到桶中。具有相同哈希码的键存储在同一桶中。"

#: :276
#, 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 的结果。"

#: :278
#, safe-html, strict-same
msgid "Configuration macros"
msgstr "配置宏"

#: :280
#, safe-html, strict-same
msgid "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`"
msgstr "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`"

#: :282
#, safe-html, strict-same
msgid ""
"Globally define this macro to support loading of ``unordered_multimap``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_multimap`。"

#: :285
#, safe-html, strict-same
msgid "Typedefs"
msgstr "类型定义"

#: :292
#, safe-html, strict-same
msgid "An iterator whose value type is `value_type`."
msgstr "一种迭代器，其值类型为 `value_type` 。"

#: :294
#, safe-html, strict-same
msgctxt ":294"
msgid "The iterator category is at least a forward iterator."
msgstr "迭代器类别至少为前向迭代器。"

#: :296
#, safe-html, strict-same
msgid "Convertible to `const_iterator`."
msgstr "可转换为 `const_iterator` 。"

#: :298
#, safe-html, strict-same
msgctxt ":298"
msgid "---"
msgstr "---"

#: :305
#, safe-html, strict-same
msgid "A constant iterator whose value type is `value_type`."
msgstr "一个常量迭代器，其值类型为 `value_type` 。"

#: :307
#, safe-html, strict-same
msgctxt ":307"
msgid "The iterator category is at least a forward iterator."
msgstr "迭代器类别至少为前向迭代器。"

#: :309
#, safe-html, strict-same
msgctxt ":309"
msgid "---"
msgstr "---"

#: :316
#, safe-html, strict-same
msgid ""
"An iterator with the same value type, difference type and pointer and "
"reference type as iterator."
msgstr "一种迭代器，其值类型、差值类型以及指针和引用类型均与 iterator 相同。"

#: :318
#, safe-html, strict-same
msgid ""
"A `local_iterator` object can be used to iterate through a single bucket."
msgstr "`local_iterator` 对象可用于遍历单个桶内的元素。"

#: :320
#, safe-html, strict-same
msgctxt ":320"
msgid "---"
msgstr "---"

#: :327
#, 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` 相同"
"。"

#: :329
#, safe-html, strict-same
msgid ""
"A const_local_iterator object can be used to iterate through a single bucket."
msgstr "`const_local_iterator` 对象可用于遍历单个桶。"

#: :331
#, safe-html, strict-same
msgctxt ":331"
msgid "---"
msgstr "---"

#: :338
#, safe-html, strict-same
msgid "See node_handle_map for details."
msgstr "详见 `node_handle_map`。"

#: :340
#, safe-html, strict-same
msgctxt ":340"
msgid "---"
msgstr "---"

#: :342
#, safe-html, strict-same
msgid "Constructors"
msgstr "构造函数"

#: :344
#, safe-html, strict-same
msgid "Default Constructor"
msgstr "默认构造函数"

#: :345
#, safe-html, strict-same
msgid "```c++ unordered_multimap(); ```"
msgstr "```c++ unordered_multimap(); ```"

#: :349
#, 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` 构造一个空容器。"

#: :354
#, safe-html, strict-same
msgctxt ":354"
msgid ""
"Postconditions:;; `size() == 0` Requires:;; If the defaults are used, "
"`hasher`, `key_equal` and `allocator_type` need to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"后置条件：`size() == 0`  \n"
"要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 "
"https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构"
"造^]。"

#: :357
#, safe-html, strict-same
msgctxt ":357"
msgid "---"
msgstr "---"

#: :359
#, safe-html, strict-same
msgid "Bucket Count Constructor"
msgstr "桶数构造函数"

#: :360
#, safe-html, strict-same
msgid ""
"```c++ explicit unordered_multimap(size_type n, const hasher& hf = hasher(), "
"const key_equal& eql = key_equal(), const allocator_type& a = allocator_type"
"()); ```"
msgstr ""
"```c++ explicit unordered_multimap(size_type n, const hasher&amp; hf = hasher"
"(), const key_equal&amp; eql = key_equal(), const allocator_type&amp; a = "
"allocator_type()); ```"

#: :367
#, 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 ""
"构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，`eql` 作为键相等谓"
"词，`a` 作为分配器，以及最大负载因子 `1.0`。"

#: :372
#, safe-html, strict-same
msgctxt ":372"
msgid ""
"Postconditions:;; `size() == 0` Requires:;; If the defaults are used, "
"`hasher`, `key_equal` and `allocator_type` need to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"后置条件：`size() == 0`  \n"
"要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 "
"https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构"
"造^]。"

#: :375
#, safe-html, strict-same
msgctxt ":375"
msgid "---"
msgstr "---"

#: :377
#, safe-html, strict-same
msgid "Iterator Range Constructor"
msgstr "迭代器范围构造函数"

#: :388
#, 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)` 范围内的元素插入其"
"中。"

#: :391
#, safe-html, strict-same
msgctxt ":391"
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[可默认构"
"造^]。"

#: :393
#, safe-html, strict-same
msgctxt ":393"
msgid "---"
msgstr "---"

#: :395
#, safe-html, strict-same
msgid "Copy Constructor"
msgstr "复制构造函数"

#: :396
#, safe-html, strict-same
msgid "```c++ unordered_multimap(const unordered_multimap& other); ```"
msgstr "```c++ unordered_multimap(const unordered_multimap&amp; other); ```"

#: :400
#, safe-html, strict-same
msgid ""
"The copy constructor. Copies the contained elements, hash function, "
"predicate, maximum load factor and allocator."
msgstr "拷贝构造函数。拷贝所包含的元素、哈希函数、谓词、最大负载因子和分配器。"

#: :402
#, 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` 存在且具有正确的签名"
"，则分配器将根据其结果进行构造。"

#: :405
#, safe-html, strict-same
msgctxt ":405"
msgid "Requires:;; `value_type` is copy constructible"
msgstr "要求：`value_type` 可拷贝构造。"

#: :407
#, safe-html, strict-same
msgctxt ":407"
msgid "---"
msgstr "---"

#: :409
#, safe-html, strict-same
msgid "Move Constructor"
msgstr "移动构造函数"

#: :410
#, safe-html, strict-same
msgid "```c++ unordered_multimap(unordered_multimap&& other); ```"
msgstr "```c++ unordered_multimap(unordered_multimap&amp;&amp; other); ```"

#: :414
#, safe-html, strict-same
msgid "The move constructor."
msgstr "移动构造函数。"

#: :417
#, safe-html, strict-same
msgid ""
"Notes:;; This is implemented using Boost.Move. Requires:;; `value_type` is "
"move-constructible."
msgstr ""
"注意：此函数使用 Boost.Move 实现。  \n"
"要求：`value_type` 可移动构造。"

#: :420
#, safe-html, strict-same
msgctxt ":420"
msgid "---"
msgstr "---"

#: :422
#, safe-html, strict-same
msgid "Iterator Range Constructor with Allocator"
msgstr "带分配器的迭代器范围构造函数"

#: :423
#, safe-html, strict-same
msgid ""
"```c++ template<class InputIterator> unordered_multimap(InputIterator f, "
"InputIterator l, const allocator_type& a); ```"
msgstr ""
"```c++ template<class inputiterator=\"\"> unordered_multimap(InputIterator "
"f, InputIterator l, const allocator_type&amp; a); ```</class>"

#: :428
#, 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)` 范围内的元素插入其中。"

#: :431
#, safe-html, strict-same
msgctxt ":431"
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[可默认构造^]。"

#: :433
#, safe-html, strict-same
msgctxt ":433"
msgid "---"
msgstr "---"

#: :435
#, safe-html, strict-same
msgid "Allocator Constructor"
msgstr "分配器构造函数"

#: :436
#, safe-html, strict-same
msgid "```c++ explicit unordered_multimap(const Allocator& a); ```"
msgstr "```c++ explicit unordered_multimap(const Allocator&amp; a); ```"

#: :440
#, safe-html, strict-same
msgid "Constructs an empty container, using allocator `a`."
msgstr "使用分配器 `a` 构造一个空容器。"

#: :442
#, safe-html, strict-same
msgctxt ":442"
msgid "---"
msgstr "---"

#: :444
#, safe-html, strict-same
msgid "Copy Constructor with Allocator"
msgstr "带分配器的复制构造函数"

#: :445
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap(const unordered_multimap& other, const Allocator& "
"a); ```"
msgstr ""
"```c++ unordered_multimap(const unordered_multimap&amp; other, const "
"Allocator&amp; a); ```"

#: :449
#, 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`。"

#: :451
#, safe-html, strict-same
msgctxt ":451"
msgid "---"
msgstr "---"

#: :453
#, safe-html, strict-same
msgid "Move Constructor with Allocator"
msgstr "带分配器的移动构造函数"

#: :454
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap(unordered_multimap&& other, const Allocator& a); "
"```"
msgstr ""
"```c++ unordered_multimap(unordered_multimap&amp;&amp; other, const "
"Allocator&amp; a); ```"

#: :458
#, 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`。"

#: :461
#, safe-html, strict-same
msgid ""
"Notes:;; This is implemented using Boost.Move. Requires:;; `value_type` is "
"move insertable."
msgstr ""
"注意：此函数使用 Boost.Move 实现。  \n"
"要求：`value_type` 可移动插入。"

#: :464
#, safe-html, strict-same
msgctxt ":464"
msgid "---"
msgstr "---"

#: :466
#, safe-html, strict-same
msgid "Initializer List Constructor"
msgstr "初始化列表构造函数"

#: :476
#, 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` 中的元素"
"插入该容器。"

#: :479
#, safe-html, strict-same
msgctxt ":479"
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[可默认构"
"造^]。"

#: :481
#, safe-html, strict-same
msgctxt ":481"
msgid "---"
msgstr "---"

#: :482
#, safe-html, strict-same
msgid "Bucket Count Constructor with Allocator"
msgstr "带分配器的桶数构造函数"

#: :483
#, safe-html, strict-same
msgid "```c++ unordered_multimap(size_type n, const allocator_type& a); ```"
msgstr ""
"```c++ unordered_multimap(size_type n, const allocator_type&amp; a); ```"

#: :487
#, 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`。"

#: :490
#, 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[可默认构造^]。"

#: :493
#, safe-html, strict-same
msgctxt ":493"
msgid "---"
msgstr "---"

#: :495
#, safe-html, strict-same
msgid "Bucket Count Constructor with Hasher and Allocator"
msgstr "带哈希函数和分配器的桶数构造函数"

#: :496
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap(size_type n, const hasher& hf, const "
"allocator_type& a); ```"
msgstr ""
"```c++ unordered_multimap(size_type n, const hasher&amp; hf, const "
"allocator_type&amp; a); ```"

#: :500
#, 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`。"

#: :503
#, safe-html, strict-same
msgid ""
"Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"后置条件：`size() == 0`  \n"
"要求：`key_equal` 需要满足 https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[可默认构造^]。"

#: :506
#, safe-html, strict-same
msgctxt ":506"
msgid "---"
msgstr "---"

#: :508
#, safe-html, strict-same
msgid "Iterator Range Constructor with Bucket Count and Allocator"
msgstr "带桶数和分配器的迭代器范围构造函数"

#: :515
#, 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)` 范围内的元素插入其中。"

#: :518
#, safe-html, strict-same
msgctxt ":518"
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[可默认构造^]。"

#: :520
#, safe-html, strict-same
msgctxt ":520"
msgid "---"
msgstr "---"

#: :522
#, safe-html, strict-same
msgid "Iterator Range Constructor with Bucket Count and Hasher"
msgstr "带桶数和哈希函数的迭代器范围构造函数"

#: :530
#, 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)` 中的元素"
"插入该容器。"

#: :533
#, safe-html, strict-same
msgctxt ":533"
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[可默认构造] 要求。"

#: :535
#, safe-html, strict-same
msgctxt ":535"
msgid "---"
msgstr "---"

#: :537
#, safe-html, strict-same
msgid "initializer_list Constructor with Allocator"
msgstr "带分配器的初始化列表构造函数"

#: :539
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap(std::initializer_list<value_type> il, const "
"allocator_type& a); ```"
msgstr ""
"```c++ unordered_multimap(std::initializer_list<value_type> il, const "
"allocator_type&amp; a); ```</value_type>"

#: :543
#, 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` 中的元素"
"插入其中。"

#: :546
#, safe-html, strict-same
msgctxt ":546"
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[可默认构造^]。"

#: :548
#, safe-html, strict-same
msgctxt ":548"
msgid "---"
msgstr "---"

#: :550
#, safe-html, strict-same
msgid "initializer_list Constructor with Bucket Count and Allocator"
msgstr "带桶数和分配器的初始化列表构造函数"

#: :552
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap(std::initializer_list<value_type> il, size_type n, "
"const allocator_type& a); ```"
msgstr ""
"```c++ unordered_multimap(std::initializer_list<value_type> il, size_type n, "
"const allocator_type&amp; a); ```</value_type>"

#: :556
#, 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 ""
"使用 `a` 作为分配器，最大负载因子为 `1.0`，构造一个至少包含 `n` 个桶的空容器"
"，并将 `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 Hasher and Allocator"
msgstr "带桶数、哈希函数和分配器的初始化列表构造函数"

#: :565
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap(std::initializer_list<value_type> il, size_type n, "
"const hasher& hf, const allocator_type& a); ```"
msgstr ""
"```c++ unordered_multimap(std::initializer_list<value_type> il, size_type n, "
"const hasher&amp; hf, const allocator_type&amp; a); ```</value_type>"

#: :570
#, 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` 中的元素插入其中。"

#: :573
#, safe-html, strict-same
msgctxt ":573"
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[可默认构造^]。"

#: :575
#, safe-html, strict-same
msgctxt ":575"
msgid "---"
msgstr "---"

#: :577
#, safe-html, strict-same
msgid "Destructor"
msgstr "析构函数"

#: :579
#, safe-html, strict-same
msgid "```c++ ~unordered_multimap(); ```"
msgstr "```c++ ~unordered_multimap(); ```"

#: :584
#, safe-html, strict-same
msgid ""
"Note:;; The destructor is applied to every element, and all memory is "
"deallocated"
msgstr "注意：析构函数会应用于每个元素，并且所有内存都会被释放。"

#: :586
#, safe-html, strict-same
msgctxt ":586"
msgid "---"
msgstr "---"

#: :588
#, safe-html, strict-same
msgid "Assignment"
msgstr "赋值操作"

#: :590
#, safe-html, strict-same
msgid "Copy Assignment"
msgstr "拷贝赋值"

#: :592
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap& operator=(const unordered_multimap& other); ```"
msgstr ""
"```c++ unordered_multimap&amp; operator=(const unordered_multimap&amp; other)"
"; ```"

#: :596
#, safe-html, strict-same
msgid ""
"The assignment operator. Copies the contained elements, hash function, "
"predicate and maximum load factor but not the allocator."
msgstr "赋值运算符。拷贝所包含的元素、哈希函数、谓词和最大负载因子，但不拷贝分配器。"

#: :598
#, 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`，则分配器会"
"被覆盖；否则，拷贝的元素将使用现有的分配器创建。"

#: :601
#, safe-html, strict-same
msgctxt ":601"
msgid "Requires:;; `value_type` is copy constructible"
msgstr "要求：`value_type` 可拷贝构造。"

#: :603
#, safe-html, strict-same
msgctxt ":603"
msgid "---"
msgstr "---"

#: :605
#, safe-html, strict-same
msgid "Move Assignment"
msgstr "移动赋值"

#: :606
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap& operator=(unordered_multimap&& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value && "
"boost::is_nothrow_move_assignable_v<Hash> && "
"boost::is_nothrow_move_assignable_v<Pred>); ``` The move assignment operator."
msgstr ""
"```c++ unordered_multimap&amp; operator=(unordered_multimap&amp;&amp; other) "
"noexcept(boost::allocator_traits<allocator>::is_always_equal::value "
"&amp;&amp; boost::is_nothrow_move_assignable_v<hash> &amp;&amp; "
"boost::is_nothrow_move_assignable_v<pred>); ``` The move assignment "
"operator.</pred></hash></allocator>"

#: :614
#, 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`，则分配器会"
"被覆盖；否则，移动的元素将使用现有的分配器创建。"

#: :617
#, safe-html, strict-same
msgid "Requires:;; `value_type` is move constructible."
msgstr "要求：`value_type` 可移动构造。"

#: :619
#, safe-html, strict-same
msgctxt ":619"
msgid "---"
msgstr "---"

#: :621
#, safe-html, strict-same
msgid "Initializer List Assignment"
msgstr "初始化列表赋值"

#: :622
#, safe-html, strict-same
msgid ""
"```c++ unordered_multimap& operator=(std::initializer_list<value_type> il); "
"```"
msgstr ""
"```c++ unordered_multimap&amp; operator=(std::initializer_list<value_type> "
"il); ```</value_type>"

#: :626
#, safe-html, strict-same
msgid ""
"Assign from values in initializer list. All existing elements are either "
"overwritten by the new elements or destroyed."
msgstr "从初始化列表中的值进行赋值。所有现有元素要么被新元素覆盖，要么被销毁。"

#: :629
#, 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[可拷贝赋值^]。"

#: :631
#, safe-html, strict-same
msgid "Iterators"
msgstr "迭代器"

#: :633
#, safe-html, strict-same
msgctxt ":633"
msgid "begin"
msgstr "开始"

#: :634
#, safe-html, strict-same
msgid ""
"```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```"
msgstr ""
"```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```"

#: :640
#, 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 "返回：指向容器第一个元素的迭代器，如果容器为空则返回容器的尾后迭代器。"

#: :642
#, safe-html, strict-same
msgctxt ":642"
msgid "---"
msgstr "---"

#: :644
#, safe-html, strict-same
msgctxt ":644"
msgid "end"
msgstr "结束"

#: :645
#, safe-html, strict-same
msgid ""
"```c++ iterator       end() noexcept; const_iterator end() const noexcept; "
"```"
msgstr ""
"```c++ iterator       end() noexcept; const_iterator end() const noexcept; "
"```"

#: :651
#, safe-html, strict-same
msgid ""
"Returns:;; An iterator which refers to the past-the-end value for the "
"container."
msgstr "返回：指向容器尾后值的迭代器。"

#: :653
#, safe-html, strict-same
msgctxt ":653"
msgid "---"
msgstr "---"

#: :655
#, safe-html, strict-same
msgctxt ":655"
msgid "cbegin"
msgstr "cbegin"

#: :656
#, safe-html, strict-same
msgid "```c++ const_iterator cbegin() const noexcept; ```"
msgstr "```c++ const_iterator cbegin() const noexcept; ```"

#: :661
#, 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`，如果容器为空则返回容器的尾后值。"

#: :663
#, safe-html, strict-same
msgctxt ":663"
msgid "---"
msgstr "---"

#: :665
#, safe-html, strict-same
msgctxt ":665"
msgid "cend"
msgstr "cend"

#: :666
#, safe-html, strict-same
msgid "```c++ const_iterator cend() const noexcept; ```"
msgstr "```c++ const_iterator cend() const noexcept; ```"

#: :671
#, safe-html, strict-same
msgid ""
"Returns:;; A `const_iterator` which refers to the past-the-end value for the "
"container."
msgstr "返回：指向容器尾后值的 `const_iterator`。"

#: :673
#, safe-html, strict-same
msgctxt ":673"
msgid "---"
msgstr "---"

#: :675
#, safe-html, strict-same
msgid "Size and Capacity"
msgstr "大小与容量"

#: :677
#, safe-html, strict-same
msgid "empty"
msgstr "空"

#: :679
#, safe-html, strict-same
msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```"
msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```"

#: :684
#, safe-html, strict-same
msgid "Returns:;; `size() == 0`"
msgstr "返回：`size() == 0`。"

#: :686
#, safe-html, strict-same
msgctxt ":686"
msgid "---"
msgstr "---"

#: :688
#, safe-html, strict-same
msgid "size"
msgstr "大小"

#: :690
#, safe-html, strict-same
msgid "```c++ size_type size() const noexcept; ```"
msgstr "```c++ size_type size() const noexcept; ```"

#: :695
#, safe-html, strict-same
msgid "Returns:;; `std::distance(begin(), end())`"
msgstr "返回：`std::distance(begin(), end())`。"

#: :697
#, safe-html, strict-same
msgctxt ":697"
msgid "---"
msgstr "---"

#: :699
#, safe-html, strict-same
msgid "max_size"
msgstr "max_size"

#: :701
#, safe-html, strict-same
msgid "```c++ size_type max_size() const noexcept; ```"
msgstr "```c++ size_type max_size() const noexcept; ```"

#: :706
#, safe-html, strict-same
msgid "Returns:;; `size()` of the largest possible container."
msgstr "返回：可能的最大容器的 `size()`。"

#: :708
#, safe-html, strict-same
msgctxt ":708"
msgid "---"
msgstr "---"

#: :710
#, safe-html, strict-same
msgid "Modifiers"
msgstr "修改器"

#: :712
#, safe-html, strict-same
msgid "emplace"
msgstr "原地构造"

#: :713
#, safe-html, strict-same
msgid "```c++ template<class... Args> iterator emplace(Args&&... args); ```"
msgstr ""
"```c++ template<class... args=\"\"> iterator emplace(Args&amp;&amp;... args)"
"; ```</class...>"

#: :717
#, safe-html, strict-same
msgid ""
"Inserts an object, constructed with the arguments `args`, in the container."
msgstr "插入一个使用参数 `args` 构造的对象到容器中。"

#: :720
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] into `X` from `args`. Returns:;; "
"An iterator pointing to the inserted element. 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[可原位构造^]。  \n"
"返回：指向已插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发"
"生。  \n"
"指向元素的指针和引用永远不会失效。"

#: :727
#, safe-html, strict-same
msgctxt ":727"
msgid "---"
msgstr "---"

#: :729
#, safe-html, strict-same
msgid "emplace_hint"
msgstr "emplace_hint"

#: :730
#, safe-html, strict-same
msgid ""
"```c++ template<class... Args> iterator emplace_hint(const_iterator "
"position, Args&&... args); ```"
msgstr ""
"```c++ template<class... args=\"\"> iterator emplace_hint(const_iterator "
"position, Args&amp;&amp;... args); ```</class...>"

#: :734
#, safe-html, strict-same
msgid ""
"Inserts an object, constructed with the arguments args, in the container."
msgstr "插入一个使用参数 `args` 构造的对象到容器中。"

#: :736
#, safe-html, strict-same
msgid "`position` is a suggestion to where the element should be inserted."
msgstr "`position` 是关于元素插入位置的建议。"

#: :739
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] into `X` from `args`. Returns:;; "
"An iterator pointing to the 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."
msgstr ""
"要求：`value_type` 必须可以从 `args` 出发在 `X` 中进行 https://"
"en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。  \n"
"返回：指向已插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：标准关于 `position` 的含义表述相当模糊。但唯一实际的使用方式，也是 "
"Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。  \n"
"可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。  "
"\n"
"指向元素的指针和引用永远不会失效。"

#: :748
#, safe-html, strict-same
msgctxt ":748"
msgid "---"
msgstr "---"

#: :750
#, safe-html, strict-same
msgid "Copy Insert"
msgstr "拷贝插入"

#: :751
#, safe-html, strict-same
msgid "```c++ iterator insert(const value_type& obj); ```"
msgstr "```c++ iterator insert(const value_type&amp; obj); ```"

#: :755
#, safe-html, strict-same
msgctxt ":755"
msgid "Inserts `obj` in the container."
msgstr "将 `obj` 插入容器中。"

#: :758
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; An iterator pointing to the "
"inserted element. 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[可拷贝插入^]。  \n"
"返回：指向已插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发"
"生。  \n"
"指向元素的指针和引用永远不会失效。"

#: :765
#, safe-html, strict-same
msgctxt ":765"
msgid "---"
msgstr "---"

#: :767
#, safe-html, strict-same
msgid "Move Insert"
msgstr "移动插入"

#: :768
#, safe-html, strict-same
msgid "```c++ iterator insert(value_type&& obj); ```"
msgstr "```c++ iterator insert(value_type&amp;&amp; obj); ```"

#: :772
#, safe-html, strict-same
msgctxt ":772"
msgid "Inserts `obj` in the container."
msgstr "将 `obj` 插入容器中。"

#: :775
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"MoveInsertable[MoveInsertable^]. Returns:;; An iterator pointing to the "
"inserted element. 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[可移动插入^]。  \n"
"返回：指向已插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发"
"生。  \n"
"指向元素的指针和引用永远不会失效。"

#: :782
#, safe-html, strict-same
msgctxt ":782"
msgid "---"
msgstr "---"

#: :784
#, safe-html, strict-same
msgid "Emplace Insert"
msgstr "原地插入"

#: :785
#, safe-html, strict-same
msgid "```c++ template<class P> iterator insert(P&& obj); ```"
msgstr ""
"```c++ template<class p=\"\"> iterator insert(P&amp;&amp; obj); ```</class>"

#: :789
#, safe-html, strict-same
msgid ""
"Inserts an element into the container by performing `emplace(std::forward<P>"
"(value))`."
msgstr "通过执行 `emplace(std::forward<p>(value))` 向容器中插入一个元素。</p>"

#: :791
#, safe-html, strict-same
msgctxt ":791"
msgid ""
"Only participates in overload resolution if "
"`std::is_constructible<value_type, P&&>::value` is `true`."
msgstr ""
"仅在 `std::is_constructible<value_type, p&&=\"\">::value` 为 `true` 时参与重"
"载决议。</value_type,>"

#: :794
#, safe-html, strict-same
msgid "Returns:;; An iterator pointing to the inserted element."
msgstr "返回：指向已插入元素的迭代器。"

#: :796
#, safe-html, strict-same
msgctxt ":796"
msgid "---"
msgstr "---"

#: :798
#, safe-html, strict-same
msgid "Copy Insert with Hint"
msgstr "带提示的拷贝插入"

#: :799
#, safe-html, strict-same
msgid ""
"```c++ iterator insert(const_iterator hint, const value_type& obj); ``` "
"Inserts `obj` in the container."
msgstr ""
"```c++iterator insert(const_iterator hint, const value_type&amp; obj);```\n"
"将 `obj` 插入容器中。"

#: :804
#, safe-html, strict-same
msgctxt ":804"
msgid "`hint` is a suggestion to where the element should be inserted."
msgstr "`hint` 是关于元素插入位置的建议。"

#: :807
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; An iterator pointing to the "
"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."
msgstr ""
"要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[可拷贝插入^]。  \n"
"返回：指向已插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 "
"Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。  \n"
"可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。  "
"\n"
"指向元素的指针和引用永远不会失效。"

#: :816
#, safe-html, strict-same
msgctxt ":816"
msgid "---"
msgstr "---"

#: :818
#, safe-html, strict-same
msgid "Move Insert with Hint"
msgstr "带提示的移动插入"

#: :819
#, safe-html, strict-same
msgid "```c++ iterator insert(const_iterator hint, value_type&& obj); ```"
msgstr ""
"```c++ iterator insert(const_iterator hint, value_type&amp;&amp; obj); ```"

#: :823
#, safe-html, strict-same
msgctxt ":823"
msgid "Inserts `obj` in the container."
msgstr "将 `obj` 插入容器中。"

#: :825
#, safe-html, strict-same
msgctxt ":825"
msgid "`hint` is a suggestion to where the element should be inserted."
msgstr "`hint` 是关于元素插入位置的建议。"

#: :828
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"MoveInsertable[MoveInsertable^]. Returns:;; An iterator pointing to the "
"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."
msgstr ""
"要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/"
"MoveInsertable[可移动插入^]。  \n"
"返回：指向已插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 "
"Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。  \n"
"可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。  "
"\n"
"指向元素的指针和引用永远不会失效。"

#: :837
#, safe-html, strict-same
msgctxt ":837"
msgid "---"
msgstr "---"

#: :839
#, safe-html, strict-same
msgid "Emplace Insert with Hint"
msgstr "带提示的原地插入"

#: :840
#, safe-html, strict-same
msgid ""
"```c++ template<class P> iterator insert(const_iterator hint, P&& obj); ```"
msgstr ""
"```c++ template<class p=\"\"> iterator insert(const_iterator hint, "
"P&amp;&amp; obj); ```</class>"

#: :844
#, safe-html, strict-same
msgid ""
"Inserts an element into the container by performing `emplace_hint(hint, "
"std::forward<P>(value))`."
msgstr ""
"通过执行 `emplace_hint(hint, std::forward<p>(value))` 向容器中插入一个元素"
"。</p>"

#: :846
#, safe-html, strict-same
msgctxt ":846"
msgid ""
"Only participates in overload resolution if "
"`std::is_constructible<value_type, P&&>::value` is `true`."
msgstr ""
"仅在 `std::is_constructible<value_type, p&&=\"\">::value` 为 `true` 时参与重"
"载决议。</value_type,>"

#: :848
#, safe-html, strict-same
msgctxt ":848"
msgid "`hint` is a suggestion to where the element should be inserted."
msgstr "`hint` 是关于元素插入位置的建议。"

#: :851
#, safe-html, strict-same
msgid ""
"Returns:;; An iterator pointing to the inserted element. 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 ""
"返回：指向已插入元素的迭代器。  \n"
"注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 "
"Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。  \n"
"可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。  "
"\n"
"指向元素的指针和引用永远不会失效。"

#: :858
#, safe-html, strict-same
msgctxt ":858"
msgid "---"
msgstr "---"

#: :860
#, safe-html, strict-same
msgid "Insert Iterator Range"
msgstr "迭代器范围插入"

#: :861
#, safe-html, strict-same
msgid ""
"```c++ template<class InputIterator> void insert(InputIterator first, "
"InputIterator last); ```"
msgstr ""
"```c++ template<class inputiterator=\"\"> void insert(InputIterator first, "
"InputIterator last); ```</class>"

#: :865
#, safe-html, strict-same
msgctxt ":865"
msgid "Inserts a range of elements into the container."
msgstr "将一个范围内的元素插入容器中。"

#: :868
#, 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[可原位构造^]。  \n"
"抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效"
"果。  \n"
"注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发"
"生。  \n"
"指向元素的指针和引用永远不会失效。"

#: :874
#, safe-html, strict-same
msgctxt ":874"
msgid "---"
msgstr "---"

#: :876
#, safe-html, strict-same
msgid "Insert Initializer List"
msgstr "初始化列表插入"

#: :877
#, safe-html, strict-same
msgid "```c++ void insert(std::initializer_list<value_type> il); ```"
msgstr ""
"```c++ void insert(std::initializer_list<value_type> il); ```</value_type>"

#: :881
#, safe-html, strict-same
msgctxt ":881"
msgid "Inserts a range of elements into the container."
msgstr "将一个范围内的元素插入容器中。"

#: :884
#, 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[可拷贝插入^]。  \n"
"抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效"
"果。  \n"
"注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发"
"生。  \n"
"指向元素的指针和引用永远不会失效。"

#: :890
#, safe-html, strict-same
msgctxt ":890"
msgid "---"
msgstr "---"

#: :892
#, safe-html, strict-same
msgid "Extract by Iterator"
msgstr "通过迭代器提取"

#: :893
#, safe-html, strict-same
msgid "```c++ node_type extract(const_iterator position); ```"
msgstr "```c++ node_type extract(const_iterator position); ```"

#: :897
#, safe-html, strict-same
msgid "Removes the element pointed to by `position`."
msgstr "移除 `position` 所指向的元素。"

#: :900
#, safe-html, strict-same
msgid ""
"Returns:;; A `node_type` owning the element. Notes:;; A node extracted using "
"this method can be inserted into a compatible `unordered_map`."
msgstr ""
"返回：一个拥有该元素的 `node_type`。  \n"
"注意：通过此方法提取的节点可以插入到兼容的 `unordered_map` 中。"

#: :903
#, safe-html, strict-same
msgctxt ":903"
msgid "---"
msgstr "---"

#: :905
#, safe-html, strict-same
msgid "Extract by Key"
msgstr "通过键提取"

#: :906
#, safe-html, strict-same
msgid ""
"```c++ node_type extract(const key_type& k); template<class K> node_type "
"extract(K&& k); ```"
msgstr ""
"```c++ node_type extract(const key_type&amp; k); template<class k=\"\"> "
"node_type extract(K&amp;&amp; k); ```</class>"

#: :911
#, safe-html, strict-same
msgid "Removes an element with key equivalent to `k`."
msgstr "移除一个键与 `k` 等价的元素。"

#: :914
#, 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:;; A node extracted using this method can be inserted "
"into a compatible `unordered_map`. + + The `template<class K>` 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`。  \n"
"抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。  \n"
"注意：通过此方法提取的节点可以插入到兼容的 `unordered_map` 中。  \n"
"\n"
"`template<class k=\"\">` 重载仅在 `Hash::is_transparent` 和 "
"`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 "
"`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使"
"用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 "
"`Key` 类型对象的开销。</class>"

#: :920
#, safe-html, strict-same
msgctxt ":920"
msgid "---"
msgstr "---"

#: :922
#, safe-html, strict-same
msgid "Insert with `node_handle`"
msgstr "通过 `node_handle` 插入"

#: :923
#, safe-html, strict-same
msgid "```c++ iterator insert(node_type&& nh); ```"
msgstr "```c++ iterator insert(node_type&amp;&amp; nh); ```"

#: :927
#, safe-html, strict-same
msgctxt ":927"
msgid "If `nh` is empty, has no effect."
msgstr "如果 `nh` 为空，则无效果。"

#: :929
#, safe-html, strict-same
msgctxt ":929"
msgid "Otherwise inserts the element owned by `nh`."
msgstr "否则，插入 `nh` 所拥有的元素。"

#: :932
#, 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()`. + + "
"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:;; 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_map`."
msgstr ""
"要求：`nh` 为空，或者 `nh.get_allocator()` 等于容器的分配器。  \n"
"返回：如果 `nh` 为空，则返回 `end()`。  \n"
"否则，返回指向新插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发"
"生。  \n"
"指向元素的指针和引用永远不会失效。  \n"
"此函数可用于插入从兼容的 `unordered_map` 中提取的节点。"

#: :943
#, safe-html, strict-same
msgctxt ":943"
msgid "---"
msgstr "---"

#: :945
#, safe-html, strict-same
msgid "Insert with Hint and `node_handle`"
msgstr "带提示和 `node_handle` 的插入"

#: :946
#, safe-html, strict-same
msgid "```c++ iterator insert(const_iterator hint, node_type&& nh); ```"
msgstr ""
"```c++ iterator insert(const_iterator hint, node_type&amp;&amp; nh); ```"

#: :950
#, safe-html, strict-same
msgctxt ":950"
msgid "If `nh` is empty, has no effect."
msgstr "如果 `nh` 为空，则无效果。"

#: :952
#, safe-html, strict-same
msgctxt ":952"
msgid "Otherwise inserts the element owned by `nh`."
msgstr "否则，插入 `nh` 所拥有的元素。"

#: :954
#, safe-html, strict-same
msgctxt ":954"
msgid "`hint` is a suggestion to where the element should be inserted."
msgstr "`hint` 是关于元素插入位置的建议。"

#: :957
#, 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()`. + + "
"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_map`."
msgstr ""
"要求：`nh` 为空，或者 `nh.get_allocator()` 等于容器的分配器。  \n"
"返回：如果 `nh` 为空，则返回 `end()`；否则，返回指向新插入元素的迭代器。  \n"
"抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。  \n"
"注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 "
"Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。  \n"
"可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。  "
"\n"
"指向元素的指针和引用永远不会失效。  \n"
"此函数可用于插入从兼容的 `unordered_map` 中提取的节点。"

#: :970
#, safe-html, strict-same
msgctxt ":970"
msgid "---"
msgstr "---"

#: :972
#, safe-html, strict-same
msgid "Erase by Position"
msgstr "通过位置擦除"

#: :974
#, 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); ```"

#: :979
#, safe-html, strict-same
msgctxt ":979"
msgid "Erase the element pointed to by `position`."
msgstr "擦除 `position` 所指向的元素。"

#: :982
#, 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` 在被擦除之前的后一个迭代器。  \n"
"抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。  \n"
"注意：在旧版本中，此操作可能效率较低，因为它需要搜索多个桶以找到返回迭代器的"
"位置。数据结构已经更改，不再是这种情况，并且备用的擦除方法已被弃用。"

#: :986
#, safe-html, strict-same
msgctxt ":986"
msgid "---"
msgstr "---"

#: :988
#, safe-html, strict-same
msgid "Erase by Key"
msgstr "通过键擦除"

#: :989
#, safe-html, strict-same
msgid ""
"```c++ size_type erase(const key_type& k); template<class K> size_type erase"
"(K&& k); ```"
msgstr ""
"```c++ size_type erase(const key_type&amp; k); template<class k=\"\"> "
"size_type erase(K&amp;&amp; k); ```</class>"

#: :994
#, safe-html, strict-same
msgid "Erase all elements with key equivalent to `k`."
msgstr "擦除所有键与 `k` 等价的元素。"

#: :997
#, 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<class K>` "
"overload only participates in overload resolution if `Hash::is_transparent` "
"and `Pred::is_transparent` are valid member typedefs and neither `iterator` "
"nor `const_iterator` are implicitly convertible from `K`. The library "
"assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is "
"transparent. This enables heterogeneous lookup which avoids the cost of "
"instantiating an instance of the `Key` type."
msgstr ""
"返回：被擦除的元素数量。  \n"
"抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。  \n"
"注意：`template<class k=\"\">` 重载仅在 `Hash::is_transparent` 和 "
"`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 "
"`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使"
"用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 "
"`Key` 类型对象的开销。</class>"

#: :1001
#, safe-html, strict-same
msgctxt ":1001"
msgid "---"
msgstr "---"

#: :1003
#, safe-html, strict-same
msgid "Erase Range"
msgstr "范围擦除"

#: :1005
#, safe-html, strict-same
msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```"
msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```"

#: :1009
#, safe-html, strict-same
msgid "Erases the elements in the range from `first` to `last`."
msgstr "擦除从 `first` 到 `last` 范围内的元素。"

#: :1012
#, 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`。  \n"
"抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。  \n"
"在此实现中，此重载不会调用任何函数对象的方法，因此不会抛出异常，但这在其他实"
"现中可能并不成立。"

#: :1017
#, safe-html, strict-same
msgctxt ":1017"
msgid "---"
msgstr "---"

#: :1019
#, safe-html, strict-same
msgid "quick_erase"
msgstr "quick_erase"

#: :1020
#, safe-html, strict-same
msgid "```c++ void quick_erase(const_iterator position); ```"
msgstr "```c++ void quick_erase(const_iterator position); ```"

#: :1024
#, safe-html, strict-same
msgctxt ":1024"
msgid "Erase the element pointed to by `position`."
msgstr "擦除 `position` 所指向的元素。"

#: :1027
#, safe-html, strict-same
msgctxt ":1027"
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` 返回指向下一个元素的迭代器成本较高，但容器已"
"经过重新设计，不再存在这种情况。因此，此方法现已弃用。"

#: :1032
#, safe-html, strict-same
msgctxt ":1032"
msgid "---"
msgstr "---"

#: :1034
#, safe-html, strict-same
msgid "erase_return_void"
msgstr "erase_return_void"

#: :1035
#, safe-html, strict-same
msgid "```c++ void erase_return_void(const_iterator position); ```"
msgstr "```c++ void erase_return_void(const_iterator position); ```"

#: :1039
#, safe-html, strict-same
msgctxt ":1039"
msgid "Erase the element pointed to by `position`."
msgstr "擦除 position 所指向的元素。"

#: :1042
#, safe-html, strict-same
msgctxt ":1042"
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"
"在此实现中，此重载不会调用任何函数对象的方法，因此不会抛出异常，但这在其他实"
"现中可能并不成立。  \n"
"\n"
"注意：引入此方法是因为从 `erase` 返回指向下一个元素的迭代器成本较高，但容器已"
"经过重新设计，不再存在这种情况。因此，此方法现已弃用。"

#: :1047
#, safe-html, strict-same
msgctxt ":1047"
msgid "---"
msgstr "---"

#: :1049
#, safe-html, strict-same
msgid "swap"
msgstr "交换"

#: :1050
#, safe-html, strict-same
msgid ""
"```c++ void swap(unordered_multimap& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value && "
"boost::is_nothrow_swappable_v<Hash> && boost::is_nothrow_swappable_v<Pred>); "
"```"
msgstr ""
"```c++ void swap(unordered_multimap&amp; other) noexcept"
"(boost::allocator_traits<allocator>::is_always_equal::value &amp;&amp; "
"boost::is_nothrow_swappable_v<hash> &amp;&amp; "
"boost::is_nothrow_swappable_v<pred>); ```</pred></hash></allocator>"

#: :1057
#, safe-html, strict-same
msgid "Swaps the contents of the container with the parameter."
msgstr "交换容器的内容与参数的内容。"

#: :1059
#, safe-html, strict-same
msgctxt ":1059"
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`，则交换容器的分配器"
"。否则，使用不相等的分配器进行交换将导致未定义行为。"

#: :1062
#, 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` 的拷贝构造函数或拷贝赋值运算符抛出异常，否"
"则不抛出任何异常。  \n"
"注意：异常规范与 C++11 标准不完全相同，因为相等谓词和哈希函数是使用其拷贝构造"
"函数进行交换的。"

#: :1065
#, safe-html, strict-same
msgctxt ":1065"
msgid "---"
msgstr "---"

#: :1067
#, safe-html, strict-same
msgid "clear"
msgstr "清空"

#: :1068
#, safe-html, strict-same
msgid "```c++ void clear() noexcept; ```"
msgstr "```c++ void clear() noexcept; ```"

#: :1072
#, safe-html, strict-same
msgid "Erases all elements in the container."
msgstr "擦除容器中的所有元素。"

#: :1075
#, safe-html, strict-same
msgid "Postconditions:;; `size() == 0` Throws:;; Never throws an exception."
msgstr ""
"后置条件：`size() == 0`  \n"
"抛出：永不抛出异常。"

#: :1078
#, safe-html, strict-same
msgctxt ":1078"
msgid "---"
msgstr "---"

#: :1080
#, safe-html, strict-same
msgid "merge"
msgstr "合并"

#: :1081
#, safe-html, strict-same
msgid ""
"```c++ template<class H2, class P2> void merge(unordered_multimap<Key, T, "
"H2, P2, Allocator>& source); template<class H2, class P2> void merge"
"(unordered_multimap<Key, T, H2, P2, Allocator>&& source); template<class H2, "
"class P2> void merge(unordered_map<Key, T, H2, P2, Allocator>& source); "
"template<class H2, class P2> void merge(unordered_map<Key, T, H2, P2, "
"Allocator>&& source); ```"
msgstr ""
"```c++ template<class h2,=\"\" class=\"\" p2=\"\"> void merge"
"(unordered_multimap<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">&amp; "
"source); template<class h2,=\"\" class=\"\" p2=\"\"> void merge"
"(unordered_multimap<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">&amp;&amp; "
"source); template<class h2,=\"\" class=\"\" p2=\"\"> void merge"
"(unordered_map<key, t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">&amp; source); "
"template<class h2,=\"\" class=\"\" p2=\"\"> void merge(unordered_map<key, "
"t,=\"\" h2,=\"\" p2,=\"\" allocator=\"\">&amp;&amp; source); ```</key,></"
"class></key,></class></key,></class></key,></class>"

#: :1092
#, safe-html, strict-same
msgid ""
"Attempt to \"merge\" two containers by iterating `source` and extracting all "
"nodes in `source` and inserting them into `*this`."
msgstr ""
"尝试“合并”两个容器：遍历 `source`，提取 `source` 中的所有节点，并将它们插入"
"到 `*this` 中。"

#: :1094
#, 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` 可能具有不同的哈希函数和键相等谓词，因此 `source` 中每个节点的"
"键都会使用 `this-&gt;hash_function()` 重新计算哈希值，然后在必要时使用 `this-"
"&gt;key_eq()` 进行比较。"

#: :1097
#, safe-html, strict-same
msgid ""
"The behavior of this function is undefined if `this\\->get_allocator() != "
"source.get_allocator()`."
msgstr ""
"如果 `this-&gt;get_allocator() != source.get_allocator()`，则此函数的行为未定"
"义。"

#: :1099
#, 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` 中"
"。"

#: :1103
#, safe-html, strict-same
msgid "Notes:;; + --"
msgstr "注意:;; + --"

#: :1106
#, safe-html, strict-same
msgid "Pointers and references to transferred elements remain valid."
msgstr "指向被转移元素的指针和引用保持有效。"

#: :1107
#, safe-html, strict-same
msgid "Invalidates iterators to transferred elements."
msgstr "使被转移元素的迭代器失效。"

#: :1108
#, safe-html, strict-same
msgid "Invalidates iterators belonging to `*this`."
msgstr "使属于 `*this` 的迭代器失效。"

#: :1109
#, safe-html, strict-same
msgid "Iterators to non-transferred elements in `source` remain valid."
msgstr "指向 `source` 中未被转移元素的迭代器保持有效。"

#: :1110
#, safe-html, strict-same
msgid "--"
msgstr "--"

#: :1112
#, safe-html, strict-same
msgctxt ":1112"
msgid "---"
msgstr "---"

#: :1114
#, safe-html, strict-same
msgid "Observers"
msgstr "观察器"

#: :1116
#, safe-html, strict-same
msgid "get_allocator"
msgstr "get_allocator"

#: :1117
#, safe-html, strict-same
msgid "``` allocator_type get_allocator() const; ```"
msgstr "``` allocator_type get_allocator() const; ```"

#: :1121
#, safe-html, strict-same
msgctxt ":1121"
msgid "---"
msgstr "---"

#: :1123
#, safe-html, strict-same
msgid "hash_function"
msgstr "哈希函数"

#: :1124
#, safe-html, strict-same
msgid "``` hasher hash_function() const; ```"
msgstr "``` hasher hash_function() const; ```"

#: :1129
#, safe-html, strict-same
msgid "Returns:;; The container's hash function."
msgstr "返回：容器的哈希函数。"

#: :1131
#, safe-html, strict-same
msgctxt ":1131"
msgid "---"
msgstr "---"

#: :1133
#, safe-html, strict-same
msgid "key_eq"
msgstr "key_eq"

#: :1134
#, safe-html, strict-same
msgid "``` key_equal key_eq() const; ```"
msgstr "``` key_equal key_eq() const; ```"

#: :1139
#, safe-html, strict-same
msgid "Returns:;; The container's key equality predicate"
msgstr "返回：容器的键相等谓词。"

#: :1141
#, safe-html, strict-same
msgctxt ":1141"
msgid "---"
msgstr "---"

#: :1143
#, safe-html, strict-same
msgid "Lookup"
msgstr "查找"

#: :1145
#, safe-html, strict-same
msgid "find"
msgstr "find"

#: :1146
#, safe-html, strict-same
msgid ""
"```c++ iterator         find(const key_type& k); const_iterator   find(const "
"key_type& k) const; template<class K> iterator       find(const K& k); "
"template<class K> const_iterator find(const K& k) const; template<typename "
"CompatibleKey, typename CompatibleHash, typename CompatiblePredicate> "
"iterator       find(CompatibleKey const& k, CompatibleHash const& hash, "
"CompatiblePredicate const& eq); template<typename CompatibleKey, typename "
"CompatibleHash, typename CompatiblePredicate> const_iterator find"
"(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate "
"const& eq) const;"
msgstr ""
"```c++ iterator         find(const key_type&amp; k); const_iterator   find"
"(const key_type&amp; k) const; template<class k=\"\"> iterator       find"
"(const K&amp; k); template<class k=\"\"> const_iterator find(const K&amp; k) "
"const; template<typename compatiblekey,=\"\" typename=\"\" "
"compatiblehash,=\"\" compatiblepredicate=\"\"> iterator       find"
"(CompatibleKey const&amp; k, CompatibleHash const&amp; hash, "
"CompatiblePredicate const&amp; eq); template<typename compatiblekey,=\"\" "
"typename=\"\" compatiblehash,=\"\" compatiblepredicate=\"\"> const_iterator "
"find(CompatibleKey const&amp; k, CompatibleHash const&amp; hash, "
"CompatiblePredicate const&amp; eq) const;</typename></typename></class></"
"class>"

#: :1160
#, safe-html, strict-same
msgid "```"
msgstr "```"

#: :1163
#, 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<class K>` "
"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()"
"`。  \n"
"注意：包含 `CompatibleKey`、`CompatibleHash` 和 `CompatiblePredicate` 的模板"
"化重载是非标准扩展，允许您为不同类型的键使用兼容的哈希函数和相等谓词，以避免"
"昂贵的类型转换。通常不鼓励使用它们，而应使用 `K` 成员函数模板。  "
"`template<class k=\"\">` 重载仅在 `Hash::is_transparent` "
"`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可"
"同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了"
"实例化 `Key` 类型对象的开销。</class>"

#: :1168
#, safe-html, strict-same
msgctxt ":1168"
msgid "---"
msgstr "---"

#: :1170
#, safe-html, strict-same
msgid "count"
msgstr "count"

#: :1171
#, safe-html, strict-same
msgid ""
"```c++ size_type        count(const key_type& k) const; template<class K> "
"size_type      count(const K& k) const; ```"
msgstr ""
"```c++ size_type        count(const key_type&amp; k) const; template<class "
"k=\"\"> size_type      count(const K&amp; k) const; ```</class>"

#: :1178
#, safe-html, strict-same
msgid ""
"Returns:;; The number of elements with key equivalent to `k`. Notes:;; The "
"`template<class K>` overload only participates in overload resolution if "
"`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. "
"The library assumes that `Hash` is callable with both `K` and `Key` and that "
"`Pred` is transparent. This enables heterogeneous lookup which avoids the "
"cost of instantiating an instance of the `Key` type."
msgstr ""
"返回：键与 `k` 等价的元素数量。  \n"
"注意：`template<class k=\"\">` 重载仅在 `Hash::is_transparent` 和 "
"`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可"
"同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了"
"实例化 `Key` 类型对象的开销。</class>"

#: :1181
#, safe-html, strict-same
msgctxt ":1181"
msgid "---"
msgstr "---"

#: :1183
#, safe-html, strict-same
msgid "contains"
msgstr "包含"

#: :1184
#, safe-html, strict-same
msgid ""
"```c++ bool             contains(const key_type& k) const; template<class K> "
"bool           contains(const K& k) const; ```"
msgstr ""
"```c++ bool             contains(const key_type&amp; k) const; "
"template<class k=\"\"> bool           contains(const K&amp; k) const; ```</"
"class>"

#: :1191
#, 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<class K>` overload "
"only participates in overload resolution if `Hash::is_transparent` and "
"`Pred::is_transparent` are valid member typedefs. The library assumes that "
"`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. "
"This enables heterogeneous lookup which avoids the cost of instantiating an "
"instance of the `Key` type."
msgstr ""
"返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。  \n"
"注意：`template<class k=\"\">` 重载仅在 `Hash::is_transparent` 和 "
"`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可"
"同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了"
"实例化 `Key` 类型对象的开销。</class>"

#: :1194
#, safe-html, strict-same
msgctxt ":1194"
msgid "---"
msgstr "---"

#: :1196
#, safe-html, strict-same
msgid "equal_range"
msgstr "equal_range"

#: :1197
#, safe-html, strict-same
msgid ""
"```c++ std::pair<iterator, iterator>               equal_range(const "
"key_type& k); std::pair<const_iterator, const_iterator>   equal_range(const "
"key_type& k) const; template<class K> std::pair<iterator, iterator>"
"             equal_range(const K& k); template<class K> "
"std::pair<const_iterator, const_iterator> equal_range(const K& k) const; ```"
msgstr ""
"```c++ std::pair<iterator, iterator=\"\">               equal_range(const "
"key_type&amp; k); std::pair<const_iterator, const_iterator=\"\">   "
"equal_range(const key_type&amp; k) const; template<class k=\"\"> "
"std::pair<iterator, iterator=\"\">             equal_range(const K&amp; k); "
"template<class k=\"\"> std::pair<const_iterator, const_iterator=\"\"> "
"equal_range(const K&amp; k) const; ```</const_iterator,></class></iterator,>"
"</class></const_iterator,></iterator,>"

#: :1207
#, 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<class K>` overloads only "
"participate in overload resolution if `Hash::is_transparent` and "
"`Pred::is_transparent` are valid member typedefs. The library assumes that "
"`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. "
"This enables heterogeneous lookup which avoids the cost of instantiating an "
"instance of the `Key` type."
msgstr ""
"返回：包含所有键与 `k` 等价的元素的范围。如果容器不包含任何此类元素，则返回 "
"`std::make_pair(b.end(), b.end())`。  \n"
"注意：`template<class k=\"\">` 重载仅在 `Hash::is_transparent` 和 "
"`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可"
"同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了"
"实例化 `Key` 类型对象的开销。</class>"

#: :1210
#, safe-html, strict-same
msgctxt ":1210"
msgid "---"
msgstr "---"

#: :1212
#, safe-html, strict-same
msgid "Bucket Interface"
msgstr "桶接口"

#: :1214
#, safe-html, strict-same
msgid "bucket_count"
msgstr "bucket_count"

#: :1215
#, safe-html, strict-same
msgid "```c++ size_type bucket_count() const noexcept; ```"
msgstr "```c++ size_type bucket_count() const noexcept; ```"

#: :1220
#, safe-html, strict-same
msgid "Returns:;; The number of buckets."
msgstr "返回：桶的数量。"

#: :1222
#, safe-html, strict-same
msgctxt ":1222"
msgid "---"
msgstr "---"

#: :1224
#, safe-html, strict-same
msgid "max_bucket_count"
msgstr "max_bucket_count"

#: :1225
#, safe-html, strict-same
msgid "```c++ size_type max_bucket_count() const noexcept; ```"
msgstr "```c++ size_type max_bucket_count() const noexcept; ```"

#: :1230
#, safe-html, strict-same
msgid "Returns:;; An upper bound on the number of buckets."
msgstr "返回：桶数量的上界。"

#: :1232
#, safe-html, strict-same
msgctxt ":1232"
msgid "---"
msgstr "---"

#: :1234
#, safe-html, strict-same
msgid "bucket_size"
msgstr "桶大小"

#: :1235
#, safe-html, strict-same
msgid "```c++ size_type bucket_size(size_type n) const; ```"
msgstr "```c++ size_type bucket_size(size_type n) const; ```"

#: :1240
#, safe-html, strict-same
msgid ""
"Requires:;; `n < bucket_count()` Returns:;; The number of elements in bucket "
"`n`."
msgstr ""
"要求：`n &lt; bucket_count()`  \n"
"返回：桶 `n` 中的元素数量。"

#: :1243
#, safe-html, strict-same
msgctxt ":1243"
msgid "---"
msgstr "---"

#: :1245
#, safe-html, strict-same
msgid "bucket"
msgstr "桶"

#: :1246
#, safe-html, strict-same
msgid ""
"```c++ size_type bucket(const key_type& k) const; template<class K> "
"size_type bucket(const K& k) const; ```"
msgstr ""
"```c++ size_type bucket(const key_type&amp; k) const; template<class k=\"\"> "
"size_type bucket(const K&amp; k) const; ```</class>"

#: :1252
#, 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<class K>` overload only participates in overload "
"resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid "
"member typedefs. The library assumes that `Hash` is callable with both `K` "
"and `Key` and that `Pred` is transparent. This enables heterogeneous lookup "
"which avoids the cost of instantiating an instance of the `Key` type."
msgstr ""
"返回：将包含键为 `k` 的元素的桶的索引。  \n"
"后置条件：返回值小于 `bucket_count()`。  \n"
"\n"
"注意：`template<class k=\"\">` 重载仅在 `Hash::is_transparent` 和 "
"`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可"
"同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了"
"实例化 `Key` 类型对象的开销。</class>"

#: :1256
#, safe-html, strict-same
msgctxt ":1256"
msgid "---"
msgstr "---"

#: :1258
#, safe-html, strict-same
msgctxt ":1258"
msgid "begin"
msgstr "开始"

#: :1260
#, 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; ```"

#: :1266
#, 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"
"返回：指向索引为 `n` 的桶中第一个元素的局部迭代器。"

#: :1269
#, safe-html, strict-same
msgctxt ":1269"
msgid "---"
msgstr "---"

#: :1271
#, safe-html, strict-same
msgctxt ":1271"
msgid "end"
msgstr "结束"

#: :1272
#, 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; ```"

#: :1278
#, 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"
"返回：指向索引为 `n` 的桶中“尾后”元素的局部迭代器。"

#: :1281
#, safe-html, strict-same
msgctxt ":1281"
msgid "---"
msgstr "---"

#: :1283
#, safe-html, strict-same
msgctxt ":1283"
msgid "cbegin"
msgstr "cbegin"

#: :1284
#, safe-html, strict-same
msgid "```c++ const_local_iterator cbegin(size_type n) const; ```"
msgstr "```c++ const_local_iterator cbegin(size_type n) const; ```"

#: :1289
#, 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"
"返回：指向索引为 `n` 的桶中第一个元素的常量局部迭代器。"

#: :1292
#, safe-html, strict-same
msgctxt ":1292"
msgid "---"
msgstr "---"

#: :1294
#, safe-html, strict-same
msgctxt ":1294"
msgid "cend"
msgstr "cend"

#: :1295
#, safe-html, strict-same
msgid "```c++ const_local_iterator cend(size_type n) const; ```"
msgstr "```c++ const_local_iterator cend(size_type n) const; ```"

#: :1300
#, 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"
"返回：指向索引为 `n` 的桶中“尾后”元素的常量局部迭代器。"

#: :1303
#, safe-html, strict-same
msgctxt ":1303"
msgid "---"
msgstr "---"

#: :1305
#, safe-html, strict-same
msgid "Hash Policy"
msgstr "哈希策略"

#: :1307
#, safe-html, strict-same
msgid "load_factor"
msgstr "负载因子"

#: :1308
#, safe-html, strict-same
msgid "```c++ float load_factor() const noexcept; ```"
msgstr "```c++ float load_factor() const noexcept; ```"

#: :1313
#, safe-html, strict-same
msgid "Returns:;; The average number of elements per bucket."
msgstr "返回：每个桶的平均元素数量。"

#: :1315
#, safe-html, strict-same
msgctxt ":1315"
msgid "---"
msgstr "---"

#: :1317
#, safe-html, strict-same
msgid "max_load_factor"
msgstr "max_load_factor"

#: :1319
#, safe-html, strict-same
msgid "```c++ float max_load_factor() const noexcept; ```"
msgstr "```c++ float max_load_factor() const noexcept; ```"

#: :1324
#, safe-html, strict-same
msgid "Returns:;; Returns the current maximum load factor."
msgstr "返回：当前最大负载因子。"

#: :1326
#, safe-html, strict-same
msgctxt ":1326"
msgid "---"
msgstr "---"

#: :1328
#, safe-html, strict-same
msgid "Set max_load_factor"
msgstr "设置最大负载因子"

#: :1329
#, safe-html, strict-same
msgid "```c++ void max_load_factor(float z); ```"
msgstr "```c++ void max_load_factor(float z); ```"

#: :1334
#, safe-html, strict-same
msgid ""
"Effects:;; Changes the container's maximum load factor, using `z` as a hint."
msgstr "效果：使用 `z` 作为提示，更改容器的最大负载因子。"

#: :1336
#, safe-html, strict-same
msgctxt ":1336"
msgid "---"
msgstr "---"

#: :1339
#, safe-html, strict-same
msgid "rehash"
msgstr "重哈希"

#: :1340
#, safe-html, strict-same
msgid "```c++ void rehash(size_type n); ```"
msgstr "```c++ void rehash(size_type n); ```"

#: :1344
#, 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()`。"

#: :1346
#, safe-html, strict-same
msgid ""
"When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array."
msgstr "当 `size() == 0` 时，`rehash(0)` 将释放底层的桶数组。"

#: :1348
#, safe-html, strict-same
msgctxt ":1348"
msgid ""
"Invalidates iterators, and changes the order of elements. Pointers and "
"references to elements are not invalidated."
msgstr "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。"

#: :1351
#, safe-html, strict-same
msgctxt ":1351"
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 ""
"抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果"
"。"

#: :1353
#, safe-html, strict-same
msgctxt ":1353"
msgid "---"
msgstr "---"

#: :1355
#, safe-html, strict-same
msgid "reserve"
msgstr "保留"

#: :1356
#, safe-html, strict-same
msgid "```c++ void reserve(size_type n); ```"
msgstr "```c++ void reserve(size_type n); ```"

#: :1360
#, 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<float>::infinity()`."
msgstr ""
"等价于 `a.rehash(ceil(n / a.max_load_factor()))`；如果 `n &gt; 0` 且 "
"`a.max_load_factor() == std::numeric_limits<float>::infinity()`，则等价于 "
"`a.rehash(1)`。</float>"

#: :1362
#, 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` 类似，此函数可用于增大或缩小容器中的桶数量。"

#: :1364
#, safe-html, strict-same
msgctxt ":1364"
msgid ""
"Invalidates iterators, and changes the order of elements. Pointers and "
"references to elements are not invalidated."
msgstr "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。"

#: :1367
#, safe-html, strict-same
msgctxt ":1367"
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 ""
"抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果"
"。"

#: :1369
#, safe-html, strict-same
msgctxt ":1369"
msgid "---"
msgstr "---"

#: :1371
#, safe-html, strict-same
msgid "Deduction Guides"
msgstr "推导指引"

#: :1372
#, safe-html, strict-same
msgid ""
"A deduction guide will not participate in overload resolution if any of the "
"following are true:"
msgstr "如果满足以下任一条件，则推导指引不会参与重载决议："

#: :1374
#, safe-html, strict-same
msgid ""
"- It has an `InputIterator` template parameter and a type that does not "
"qualify as an input iterator is deduced for that parameter. - It has an "
"`Allocator` template parameter and a type that does not qualify as an "
"allocator is deduced for that parameter. - It has a `Hash` template "
"parameter and an integral type or a type that qualifies as an allocator is "
"deduced for that parameter. - It has a `Pred` template parameter and a type "
"that qualifies as an allocator is deduced for that parameter."
msgstr ""
"- 它具有一个 `InputIterator` 模板参数，并且为该参数推导出的类型不符合输入迭代"
"器的要求。\n"
"- 它具有一个 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要求"
"。\n"
"- 它具有一个 `Hash` 模板参数，并且为该参数推导出的类型是整数类型或符合分配器"
"的要求。\n"
"- 它具有一个 `Pred` 模板参数，并且为该参数推导出的类型符合分配器的要求。"

#: :1379
#, 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` 成员类型。其默认值与所选构造函数的默认值一致。"

#: :1383
#, safe-html, strict-same
msgid "__iter-value-type__"
msgstr "_iter-value-type_"

#: :1391
#, safe-html, strict-same
msgid "__iter-key-type__"
msgstr "__iter-key-type__"

#: :1399
#, safe-html, strict-same
msgid "__iter-mapped-type__"
msgstr "__iter-mapped-type__"

#: :1407
#, safe-html, strict-same
msgid "__iter-to-alloc-type__"
msgstr "__iter-to-alloc-type__"

#: :1416
#, safe-html, strict-same
msgid "Equality Comparisons"
msgstr "相等性比较"

#: :1418
#, safe-html, strict-same
msgid "operator"
msgstr "运算符"

#: :1419
#, safe-html, strict-same
msgid ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x, "
"const unordered_multimap<Key, T, Hash, Pred, Alloc>& y); ```"
msgstr ""
"```c++ template<class key,=\"\" class=\"\" t,=\"\" hash,=\"\" pred,=\"\" "
"alloc=\"\"> bool operator==(const unordered_multimap<key, t,=\"\" hash,=\"\" "
"pred,=\"\" alloc=\"\">&amp; x, const unordered_multimap<key, t,=\"\" "
"hash,=\"\" pred,=\"\" alloc=\"\">&amp; y); ```</key,></key,></class>"

#: :1425
#, safe-html, strict-same
msgid ""
"Return `true` if `x.size() == y.size()` and for every equivalent key group "
"in `x`, there is a group in `y` for the same key, which is a permutation "
"(using `operator==` to compare the value types)."
msgstr ""
"若 `x.size() == y.size()` 且对于 `x` 中的每个等价键组，在 `y` 中均存在一个具"
"有相同键的组，并且该组是 `x` 中对应组的置换（使用 `operator==` 比较值类型），"
"则返回 `true`。"

#: :1428
#, safe-html, strict-same
msgctxt ":1428"
msgid ""
"Notes:;; Behavior is undefined if the two containers don't have equivalent "
"equality predicates."
msgstr "注意：如果两个容器不具有等价的相等谓词，则行为未定义。"

#: :1430
#, safe-html, strict-same
msgctxt ":1430"
msgid "---"
msgstr "---"

#: :1432
#, safe-html, strict-same
msgid "operator!"
msgstr "operator!"

#: :1433
#, safe-html, strict-same
msgid ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"bool operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x, "
"const unordered_multimap<Key, T, Hash, Pred, Alloc>& y); ```"
msgstr ""
"```c++ template<class key,=\"\" class=\"\" t,=\"\" hash,=\"\" pred,=\"\" "
"alloc=\"\"> bool operator!=(const unordered_multimap<key, t,=\"\" hash,=\"\" "
"pred,=\"\" alloc=\"\">&amp; x, const unordered_multimap<key, t,=\"\" "
"hash,=\"\" pred,=\"\" alloc=\"\">&amp; y); ```</key,></key,></class>"

#: :1439
#, safe-html, strict-same
msgid ""
"Return `false` if `x.size() == y.size()` and for every equivalent key group "
"in `x`, there is a group in `y` for the same key, which is a permutation "
"(using `operator==` to compare the value types)."
msgstr ""
"若 `x.size() == y.size()` 且对于 `x` 中的每个等价键组，在 `y` 中均存在一个具"
"有相同键的组，并且该组是 `x` 中对应组的置换（使用 `operator==` 比较值类型），"
"则返回 `false`。"

#: :1442
#, safe-html, strict-same
msgctxt ":1442"
msgid ""
"Notes:;; Behavior is undefined if the two containers don't have equivalent "
"equality predicates."
msgstr "注意：如果两个容器不具有等价的相等谓词，则行为未定义。"

#: :1444
#, safe-html, strict-same
msgctxt ":1444"
msgid "---"
msgstr "---"

#: :1446
#, safe-html, strict-same
msgid "Swap"
msgstr "交换"

#: :1447
#, safe-html, strict-same
msgid ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, "
"unordered_multimap<Key, T, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap"
"(y))); ```"
msgstr ""
"```c++ template<class key,=\"\" class=\"\" t,=\"\" hash,=\"\" pred,=\"\" "
"alloc=\"\"> void swap(unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" "
"alloc=\"\">&amp; x, unordered_multimap<key, t,=\"\" hash,=\"\" pred,=\"\" "
"alloc=\"\">&amp; y) noexcept(noexcept(x.swap(y))); ```</key,></key,></class>"

#: :1454
#, safe-html, strict-same
msgid "Swaps the contents of `x` and `y`."
msgstr "交换 x 和 y 的内容。"

#: :1456
#, safe-html, strict-same
msgctxt ":1456"
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`，则交换容器的分配器"
"。否则，使用不相等的分配器进行交换将导致未定义行为。"

#: :1459
#, 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)`  \n"
"抛出：除非 `key_equal` 或 `hasher` 的拷贝构造函数或拷贝赋值运算符抛出异常，否"
"则不抛出任何异常。  \n"
"注意：异常规范与 C++11 标准不完全相同，因为相等谓词和哈希函数是使用其拷贝构造"
"函数进行交换的。"

#: :1463
#, safe-html, strict-same
msgctxt ":1463"
msgid "---"
msgstr "---"

#: :1465
#, safe-html, strict-same
msgid "erase_if"
msgstr "erase_if"

#: :1466
#, safe-html, strict-same
msgid ""
"```c++ template<class K, class T, class H, class P, class A, class "
"Predicate> typename unordered_multimap<K, T, H, P, A>::size_type erase_if"
"(unordered_multimap<K, T, H, P, A>& c, Predicate pred); ```"
msgstr ""
"```c++ template<class k,=\"\" class=\"\" t,=\"\" h,=\"\" p,=\"\" a,=\"\" "
"predicate=\"\"> typename unordered_multimap<k, t,=\"\" h,=\"\" p,=\"\" "
"a=\"\">::size_type erase_if(unordered_multimap<k, t,=\"\" h,=\"\" p,=\"\" "
"a=\"\">&amp; c, Predicate pred); ```</k,></k,></class>"

#: :1472
#, safe-html, strict-same
msgid ""
"Traverses the container `c` and removes all elements for which the supplied "
"predicate returns `true`."
msgstr "遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。"

#: :1475
#, 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(); ``` + Note that the references passed to `pred` "
"are non-const."
msgstr ""
"返回：被擦除的元素数量。  注意：等价于：  \n"
"```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();\n"
"```  注意，传递给 `pred` 的引用是非常量的。"

#: :1492
#, safe-html, strict-same
msgid "Serialization"
msgstr "序列化"

#: :1494
#, safe-html, strict-same
msgid ""
"``unordered_multimap``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_multimap` 可以通过本库提供的 API，借助 link:../../../../../"
"serialization/index.html[Boost.Serialization^] 进行归档/恢复。支持常规归档和 "
"XML 归档。"

#: :1498
#, safe-html, strict-same
msgid "Saving an unordered_multimap to an archive"
msgstr "将 unordered_multimap 保存到归档"

#: :1500
#, safe-html, strict-same
msgid ""
"Saves all the elements of an `unordered_multimap` `x` to an archive (XML "
"archive) `ar`."
msgstr "将 `unordered_multimap` 容器 `x` 的所有元素保存到归档（XML 归档） `ar` 中。"

#: :1503
#, safe-html, strict-same
msgid ""
"Requires:;; `std::remove_const<key_type>::type` and "
"`std::remove_const<mapped_type>::type` are serializable (XML serializable), "
"and they do support Boost.Serialization `save_construct_data`/"
"`load_construct_data` protocol (automatically suported by https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^] types)."
msgstr ""
"要求：`std::remove_const<key_type>::type` 和 `std::remove_const<mapped_type>"
"::type` 必须是可序列化的（对于 XML 归档需支持 XML 序列化），并且它们必须支持 "
"Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（该协"
"议由满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可"
"默认构造^] 的类型自动支持）。</mapped_type></key_type>"

#: :1509
#, safe-html, strict-same
msgctxt ":1509"
msgid "---"
msgstr "---"

#: :1511
#, safe-html, strict-same
msgid "Loading an unordered_multimap from an archive"
msgstr "从归档加载 unordered_multimap"

#: :1513
#, safe-html, strict-same
msgid ""
"Deletes all preexisting elements of an `unordered_multimap` `x` and inserts "
"from an archive (XML archive) `ar` restored copies of the elements of the "
"original `unordered_multimap` `other` saved to the storage read by `ar`."
msgstr ""
"删除 `unordered_multimap` 容器 `x` 中所有已存在的元素，并从归档（XML 归档"
"）`ar` 中插入从原始 `unordered_multimap` 容器 `other` 保存到 `ar` 所读取存储"
"中的元素恢复出的副本。"

#: :1518
#, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `"
"(std::remove_const<key_type>::type&&, std::remove_const<mapped_type>::type&&)"
"`. `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` 必须可以从 `(std::remove_const<key_type>::type&amp;&amp;, "
"std::remove_const<mapped_type>::type&amp;&amp;)` 进行 https://"
"en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构"
"造^]。`x.key_equal()` 在功能上必须等价于 `other.key_equal()`。  \n"
"注意：如果归档是使用 Boost 1.84 之前版本的 Boost 保存的，则必须全局定义配置"
"宏 `BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0` 才能使此操作成功；"
"否则，将抛出异常。</mapped_type></key_type>"

#: :1525
#, safe-html, strict-same
msgctxt ":1525"
msgid "---"
msgstr "---"

#: :1527
#, safe-html, strict-same
msgid "Saving an iterator/const_iterator to an archive"
msgstr "将迭代器/常量迭代器保存到归档"

#: :1529
#, safe-html, strict-same
msgid ""
"Saves the positional information of an `iterator` (`const_iterator`) `it` to "
"an archive (XML archive) `ar`. `it` can be and `end()` iterator."
msgstr ""
"将迭代器（或常量迭代器）`it` 的位置信息保存到归档（XML 归档）`ar` 中。`it` 可"
"以是一个 `end()` 迭代器。"

#: :1533
#, safe-html, strict-same
msgid ""
"Requires:;; The `unordered_multimap` `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_multimap` 容器 `x` 必须先被保存到 `ar` 中，并"
"且在保存 `x` 和保存 `it` 之间，不能对 `x` 执行任何修改操作。"

#: :1537
#, safe-html, strict-same
msgctxt ":1537"
msgid "---"
msgstr "---"

#: :1539
#, safe-html, strict-same
msgid "Loading an iterator/const_iterator from an archive"
msgstr "从归档加载迭代器/常量迭代器"

#: :1541
#, safe-html, strict-same
msgid ""
"Makes an `iterator` (`const_iterator`) `it` point to the restored position "
"of the original `iterator` (`const_iterator`) saved to the storage read by "
"an archive (XML archive) `ar`."
msgstr ""
"使迭代器（或常量迭代器）`it` 指向原始迭代器（或常量迭代器）被保存到归档（XML "
"归档）`ar` 所读取存储中的位置恢复后的位置。"

#: :1546
#, safe-html, strict-same
msgid ""
"Requires:;; If `x` is the `unordered_multimap` `it` points to, no modifying "
"operations have been issued on `x` between loading of `x` and loading of "
"`it`."
msgstr ""
"要求：如果 `x` 是 `it` 所指向的 `unordered_multimap` 容器，则在加载 `x` 和加"
"载 `it` 之间，不能对 `x` 执行任何修改操作。"