msgid "" msgstr "" "Project-Id-Version: Chinese (Simplified Han script) (Boost Unordered " "Translation (zh_Hans))\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-06-07 06:46+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: Chinese (Simplified Han script) \n" "Language: zh_Hans\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" "X-Generator: Weblate 2026.5\n" #: :2 #, safe-html, strict-same msgid "Class Template unordered_map" msgstr "类模板 unordered_map" #: :4 #, safe-html, strict-same msgid ":idprefix: unordered_map_" msgstr ":idprefix: unordered_map_" #: :6 #, safe-html, strict-same msgid "" "`boost::unordered_map` — An unordered associative container that associates " "unique keys with another value." msgstr "`boost::unordered_map` — 一个无序关联容器，用于将唯一的键与另一个值关联起来。" #: :8 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :280 #, safe-html, strict-same msgctxt ":280" msgid "---" msgstr "---" #: :282 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :284 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :287 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :287 #, 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` 能够销毁它）。" #: :287 #, safe-html, strict-same msgid "_T_" msgstr "_T_" #: :287 #, 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` 可以销毁它）。" #: :287 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :287 #, 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` 类型的值。" #: :287 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :287 #, 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` 类型的值。" #: :287 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :287 #, safe-html, strict-same msgid "" "An allocator whose value type is the same as the container's value type." msgstr "一种分配器，其值类型与容器的值类型相同。" #: :303 #, 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[异" "形指针] 的分配器。" #: :307 #, safe-html, strict-same msgid "" "The elements are organized into buckets. Keys with the same hash code are " "stored in the same bucket." msgstr "元素被组织到桶中。具有相同哈希码的键存储在同一桶中。" #: :309 #, 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 的结果。" #: :311 #, safe-html, strict-same msgid "Configuration macros" msgstr "配置宏" #: :313 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`" msgstr "`BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0`" #: :315 #, safe-html, strict-same msgid "" "Globally define this macro to support loading of ``unordered_map``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_map`。" #: :318 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :325 #, safe-html, strict-same msgid "An iterator whose value type is `value_type`." msgstr "一个迭代器，其值类型为 `value_type`。" #: :327 #, safe-html, strict-same msgctxt ":327" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :329 #, safe-html, strict-same msgid "Convertible to `const_iterator`." msgstr "可转换为 `const_iterator` 。" #: :331 #, safe-html, strict-same msgctxt ":331" msgid "---" msgstr "---" #: :338 #, safe-html, strict-same msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value_type` 。" #: :340 #, safe-html, strict-same msgctxt ":340" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :342 #, safe-html, strict-same msgctxt ":342" msgid "---" msgstr "---" #: :349 #, safe-html, strict-same msgid "" "An iterator with the same value type, difference type and pointer and " "reference type as iterator." msgstr "一种迭代器，其值类型、差值类型以及指针和引用类型均与 iterator 相同。" #: :351 #, safe-html, strict-same msgid "" "A `local_iterator` object can be used to iterate through a single bucket." msgstr "`local_iterator` 对象可用于遍历单个桶内的元素。" #: :353 #, safe-html, strict-same msgctxt ":353" msgid "---" msgstr "---" #: :360 #, 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 相同" "。" #: :362 #, safe-html, strict-same msgid "" "A const_local_iterator object can be used to iterate through a single bucket." msgstr "`const_local_iterator` 对象可用于遍历单个桶。" #: :364 #, safe-html, strict-same msgctxt ":364" msgid "---" msgstr "---" #: :371 #, safe-html, strict-same msgid "" "A class for holding extracted container elements, modelling https://" "en.cppreference.com/w/cpp/container/node_handle[NodeHandle]." msgstr "" "一个用于存放被提取容器元素的类，符合 https://en.cppreference.com/w/cpp/" "container/node_handle[NodeHandle] 模型。" #: :374 #, safe-html, strict-same msgctxt ":374" msgid "---" msgstr "---" #: :381 #, safe-html, strict-same msgid "A specialization of an internal class template:" msgstr "一个内部类模板的特化：" #: :394 #, safe-html, strict-same msgid "with `Iterator` = `iterator` and `NodeType` = `node_type`." msgstr "其中 `Iterator` = `iterator`，`NodeType` = `node_type`。" #: :396 #, safe-html, strict-same msgctxt ":396" msgid "---" msgstr "---" #: :398 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :400 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :401 #, safe-html, strict-same msgid "```c++ unordered_map(); ```" msgstr "```c++ unordered_map(); ```" #: :405 #, 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` 构造一个空容器。" #: :410 #, safe-html, strict-same msgctxt ":410" 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[可默认构" "造^]。" #: :413 #, safe-html, strict-same msgctxt ":413" msgid "---" msgstr "---" #: :415 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :416 #, safe-html, strict-same msgid "" "```c++ explicit unordered_map(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = allocator_type" "()); ```" msgstr "" "```c++ explicit unordered_map(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" #: :423 #, 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`。" #: :428 #, safe-html, strict-same msgctxt ":428" 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[可默认构" "造^]。" #: :431 #, safe-html, strict-same msgctxt ":431" msgid "---" msgstr "---" #: :433 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :444 #, 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)` 范围内的元素插入其" "中。" #: :447 #, safe-html, strict-same msgctxt ":447" 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[可默认构" "造^]。" #: :449 #, safe-html, strict-same msgctxt ":449" msgid "---" msgstr "---" #: :451 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :452 #, safe-html, strict-same msgid "```c++ unordered_map(unordered_map const& other); ```" msgstr "```c++ unordered_map(unordered_map const& other); ```" #: :456 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate, maximum load factor and allocator." msgstr "拷贝构造函数。拷贝所包含的元素、哈希函数、谓词、最大负载因子和分配器。" #: :458 #, 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` 存在且具有正确的签名" "，则分配器将根据其结果进行构造。" #: :461 #, safe-html, strict-same msgctxt ":461" msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：`value_type` 可拷贝构造。" #: :463 #, safe-html, strict-same msgctxt ":463" msgid "---" msgstr "---" #: :465 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :466 #, safe-html, strict-same msgid "```c++ unordered_map(unordered_map&& other); ```" msgstr "```c++ unordered_map(unordered_map&& other); ```" #: :470 #, safe-html, strict-same msgid "The move constructor." msgstr "移动构造函数。" #: :473 #, safe-html, strict-same msgid "" "Notes:;; This is implemented using Boost.Move. Requires:;; `value_type` is " "move-constructible." msgstr "" "注意：此函数使用 Boost.Move 实现。 \n" "要求：`value_type` 可移动构造。" #: :476 #, safe-html, strict-same msgctxt ":476" msgid "---" msgstr "---" #: :478 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器区间构造函数" #: :479 #, safe-html, strict-same msgid "" "```c++ template unordered_map(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template unordered_map(InputIterator f, " "InputIterator l, const allocator_type& a); ```" #: :484 #, 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)` 范围内的元素插入其中。" #: :487 #, safe-html, strict-same msgctxt ":487" 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[可默认构造^]。" #: :489 #, safe-html, strict-same msgctxt ":489" msgid "---" msgstr "---" #: :491 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :492 #, safe-html, strict-same msgid "```c++ explicit unordered_map(Allocator const& a); ```" msgstr "```c++ explicit unordered_map(Allocator const& a); ```" #: :496 #, safe-html, strict-same msgid "Constructs an empty container, using allocator `a`." msgstr "使用分配器 `a` 构造一个空容器。" #: :498 #, safe-html, strict-same msgctxt ":498" msgid "---" msgstr "---" #: :500 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :501 #, safe-html, strict-same msgid "" "```c++ unordered_map(unordered_map const& other, Allocator const& a); ```" msgstr "" "```c++ unordered_map(unordered_map const& other, Allocator const& a)" "; ```" #: :505 #, 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`。" #: :507 #, safe-html, strict-same msgctxt ":507" msgid "---" msgstr "---" #: :509 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :510 #, safe-html, strict-same msgid "```c++ unordered_map(unordered_map&& other, Allocator const& a); ```" msgstr "" "```c++ unordered_map(unordered_map&& other, Allocator const& a); " "```" #: :514 #, 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。" #: :517 #, safe-html, strict-same msgid "" "Notes:;; This is implemented using Boost.Move. Requires:;; `value_type` is " "move insertable." msgstr "注意：此函数使用 Boost.Move 实现。 要求：`value_type` 可移动插入。" #: :520 #, safe-html, strict-same msgctxt ":520" msgid "---" msgstr "---" #: :522 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :532 #, 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 中的元素插入其中。" #: :535 #, safe-html, strict-same msgctxt ":535" 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[可默认构" "造^]。" #: :537 #, safe-html, strict-same msgctxt ":537" msgid "---" msgstr "---" #: :539 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :540 #, safe-html, strict-same msgid "```c++ unordered_map(size_type n, allocator_type const& a); ```" msgstr "```c++ unordered_map(size_type n, allocator_type const& a); ```" #: :544 #, 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。" #: :547 #, 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[可默认构造^]。" #: :550 #, safe-html, strict-same msgctxt ":550" msgid "---" msgstr "---" #: :552 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :553 #, safe-html, strict-same msgid "" "```c++ unordered_map(size_type n, hasher const& hf, allocator_type const& a)" "; ```" msgstr "" "```c++ unordered_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :557 #, 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。" #: :560 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` 要求：`key_equal` 需要满足 https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^]。" #: :563 #, safe-html, strict-same msgctxt ":563" msgid "---" msgstr "---" #: :565 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :572 #, 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)` 范围内的元素插入其中。" #: :575 #, safe-html, strict-same msgctxt ":575" 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[可默认构造^]。" #: :577 #, safe-html, strict-same msgctxt ":577" msgid "---" msgstr "---" #: :579 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :587 #, 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)` 范围内的元素插入其" "中。" #: :590 #, safe-html, strict-same msgctxt ":590" 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[可默认构造^]。" #: :592 #, safe-html, strict-same msgctxt ":592" msgid "---" msgstr "---" #: :594 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :596 #, safe-html, strict-same msgid "" "```c++ unordered_map(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ unordered_map(std::initializer_list il, const " "allocator_type& a); ```" #: :600 #, 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 中的元素插入其" "中。" #: :603 #, safe-html, strict-same msgctxt ":603" 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[可默认构造^]。" #: :605 #, safe-html, strict-same msgctxt ":605" msgid "---" msgstr "---" #: :607 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :609 #, safe-html, strict-same msgid "" "```c++ unordered_map(std::initializer_list il, size_type n, " "const allocator_type& a); ```" msgstr "" "```c++ unordered_map(std::initializer_list il, size_type n, " "const allocator_type& a); ```" #: :613 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` as the " "allocator and a maximum load factor of 1.0 and inserts the elements from " "`il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器，最大负载因子为 " "`1.0`，并将 `il` 中的元素插入其中。" #: :616 #, safe-html, strict-same msgctxt ":616" 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[可默认构造^]。" #: :618 #, safe-html, strict-same msgctxt ":618" msgid "---" msgstr "---" #: :620 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :622 #, safe-html, strict-same msgid "" "```c++ unordered_map(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ unordered_map(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" #: :627 #, 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 中的元素插入其中。" #: :630 #, safe-html, strict-same msgctxt ":630" 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[可默认构造^]。" #: :632 #, safe-html, strict-same msgctxt ":632" msgid "---" msgstr "---" #: :634 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :636 #, safe-html, strict-same msgid "```c++ ~unordered_map(); ```" msgstr "```c++ ~unordered_map(); ```" #: :641 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：析构函数会应用于每个元素，并且所有内存都会被释放。" #: :643 #, safe-html, strict-same msgctxt ":643" msgid "---" msgstr "---" #: :645 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :647 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :649 #, safe-html, strict-same msgid "```c++ unordered_map& operator=(unordered_map const& other); ```" msgstr "" "```c++ unordered_map& operator=(unordered_map const& other); ```" #: :653 #, safe-html, strict-same msgid "" "The assignment operator. Copies the contained elements, hash function, " "predicate and maximum load factor but not the allocator." msgstr "赋值运算符。拷贝所包含的元素、哈希函数、谓词和最大负载因子，但不拷贝分配器。" #: :655 #, 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`，则分配器会" "被覆盖；否则，拷贝的元素将使用现有的分配器创建。" #: :658 #, safe-html, strict-same msgctxt ":658" msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：`value_type` 可拷贝构造。" #: :660 #, safe-html, strict-same msgctxt ":660" msgid "---" msgstr "---" #: :662 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :663 #, safe-html, strict-same msgid "" "```c++ unordered_map& operator=(unordered_map&& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_move_assignable_v && " "boost::is_nothrow_move_assignable_v); ``` The move assignment operator." msgstr "" "```c++ unordered_map& operator=(unordered_map&& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_move_assignable_v && " "boost::is_nothrow_move_assignable_v); ``` The move assignment " "operator." #: :671 #, 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`，则分配器会" "被覆盖；否则，移动的元素将使用现有的分配器创建。" #: :674 #, safe-html, strict-same msgid "Requires:;; `value_type` is move constructible." msgstr "要求：`value_type` 可移动构造。" #: :676 #, safe-html, strict-same msgctxt ":676" msgid "---" msgstr "---" #: :678 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :679 #, safe-html, strict-same msgid "" "```c++ unordered_map& operator=(std::initializer_list il); ```" msgstr "" "```c++ unordered_map& operator=(std::initializer_list il); " "```" #: :683 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All existing elements are either " "overwritten by the new elements or destroyed." msgstr "从初始化列表中的值进行赋值。所有现有元素要么被新元素覆盖，要么被销毁。" #: :686 #, 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[可拷贝赋值^]。" #: :688 #, safe-html, strict-same msgid "Iterators" msgstr "迭代器" #: :690 #, safe-html, strict-same msgctxt ":690" msgid "begin" msgstr "begin" #: :691 #, safe-html, strict-same msgid "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" msgstr "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" #: :697 #, 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 "返回：指向容器第一个元素的迭代器，如果容器为空则返回容器的尾后迭代器。" #: :699 #, safe-html, strict-same msgctxt ":699" msgid "---" msgstr "---" #: :701 #, safe-html, strict-same msgctxt ":701" msgid "end" msgstr "end" #: :702 #, safe-html, strict-same msgid "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" msgstr "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" #: :708 #, safe-html, strict-same msgid "" "Returns:;; An iterator which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后值的迭代器。" #: :710 #, safe-html, strict-same msgctxt ":710" msgid "---" msgstr "---" #: :712 #, safe-html, strict-same msgctxt ":712" msgid "cbegin" msgstr "cbegin" #: :713 #, safe-html, strict-same msgid "```c++ const_iterator cbegin() const noexcept; ```" msgstr "```c++ const_iterator cbegin() const noexcept; ```" #: :718 #, 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`，如果容器为空则返回容器的尾后值。" #: :720 #, safe-html, strict-same msgctxt ":720" msgid "---" msgstr "---" #: :722 #, safe-html, strict-same msgctxt ":722" msgid "cend" msgstr "cend" #: :723 #, safe-html, strict-same msgid "```c++ const_iterator cend() const noexcept; ```" msgstr "```c++ const_iterator cend() const noexcept; ```" #: :728 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后值的 `const_iterator`。" #: :730 #, safe-html, strict-same msgctxt ":730" msgid "---" msgstr "---" #: :732 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :734 #, safe-html, strict-same msgid "empty" msgstr "空" #: :736 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :741 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "返回：`size() == 0`。" #: :743 #, safe-html, strict-same msgctxt ":743" msgid "---" msgstr "---" #: :745 #, safe-html, strict-same msgid "size" msgstr "大小" #: :747 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :752 #, safe-html, strict-same msgid "Returns:;; `std::distance(begin(), end())`" msgstr "返回：`std::distance(begin(), end())`。" #: :754 #, safe-html, strict-same msgctxt ":754" msgid "---" msgstr "---" #: :756 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :758 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :763 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible container." msgstr "返回：可能的最大容器的 `size()`。" #: :765 #, safe-html, strict-same msgctxt ":765" msgid "---" msgstr "---" #: :767 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :769 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :770 #, safe-html, strict-same msgid "" "```c++ template std::pair emplace(Args&&... " "args); ```" msgstr "" "```c++ template std::pair emplace" "(Args&&... args); ```" #: :774 #, safe-html, strict-same msgctxt ":774" msgid "" "Inserts an object, constructed with the arguments `args`, in the container " "if and only if there is no element in the container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。" #: :777 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into `X` from `args`. Returns:;; " "The bool component of the return type is true if an insert took place. + + " "If an insert took place, then the iterator points to the newly inserted " "element. Otherwise, it points to the element with equivalent key. Throws:;; " "If an exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load factor to be greater to or equal to the maximum load " "factor. + + Pointers and references to elements are never invalidated. + + " "If `args...` is of the form `k,v`, it delays constructing the whole object " "until it is certain that an element should be inserted, using only the `k` " "argument to check. This optimization happens when the map's `key_type` is " "move constructible or when the `k` argument is a `key_type`." msgstr "" "要求：`value_type` 必须可以从 `args` 出发在 `X` 中进行 https://" "en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 返回" "：如果发生了插入，则返回类型的 bool 分量为 true。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发" "生。 指向元素的指针和引用永远不会失效。 \n" "如果 `args...` 的形式为 `k,v`，则该函数会延迟构造整个对象，直到确定应该插入元" "素为止，仅使用 `k` 参数进行检查。当映射的 `key_type` 可移动构造或 `k` 参数本" "身就是 `key_type` 类型时，此优化生效。" #: :788 #, safe-html, strict-same msgctxt ":788" msgid "---" msgstr "---" #: :790 #, safe-html, strict-same msgid "emplace_hint" msgstr "emplace_hint" #: :791 #, safe-html, strict-same msgid "" "```c++ template iterator emplace_hint(const_iterator " "position, Args&&... args); ```" msgstr "" "```c++ template iterator emplace_hint(const_iterator " "position, Args&&... args); ```" #: :795 #, safe-html, strict-same msgctxt ":795" msgid "" "Inserts an object, constructed with the arguments `args`, in the container " "if and only if there is no element in the container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才插入一个使用参数 `args` 构造的对象。" #: :797 #, safe-html, strict-same msgid "`position` is a suggestion to where the element should be inserted." msgstr "`position` 是关于元素插入位置的建议。" #: :800 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into `X` from `args`. Returns:;; " "If an insert took place, then the iterator points to the newly inserted " "element. Otherwise, it points to the element with equivalent key. Throws:;; " "If an exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; The standard is fairly vague on the meaning " "of the hint. But the only practical way to use it, and the only way that " "Boost.Unordered supports is to point to an existing element with the same " "key. + + Can invalidate iterators, but only if the insert causes the load " "factor to be greater to or equal to the maximum load factor. + + Pointers " "and references to elements are never invalidated. + + If `args...` is of the " "form `k,v`, it delays constructing the whole object until it is certain that " "an element should be inserted, using only the `k` argument to check. This " "optimization happens when the map's `key_type` is move constructible or when " "the `k` argument is a `key_type`." msgstr "" "要求：`value_type` 必须可以从 `args` 出发在 `X` 中进行 https://" "en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 返回" "：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 " "Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 " "\n" "指向元素的指针和引用永远不会失效。 \n" "如果 `args...` 的形式为 `k,v`，则该函数会延迟构造整个对象，直到确定应该插入元" "素为止，仅使用 `k` 参数进行检查。当映射的 `key_type` 可移动构造或 `k` 参数本" "身就是 `key_type` 类型时，此优化生效。" #: :811 #, safe-html, strict-same msgctxt ":811" msgid "---" msgstr "---" #: :813 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :814 #, safe-html, strict-same msgid "```c++ std::pair insert(const value_type& obj); ```" msgstr "" "```c++ std::pair insert(const value_type& obj); " "```" #: :818 #, safe-html, strict-same msgctxt ":818" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :821 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The bool component of the return " "type is true if an insert took place. + + If an insert took place, then the " "iterator points to the newly inserted element. Otherwise, it points to the " "element with equivalent key. Throws:;; If an exception is thrown by an " "operation other than a call to `hasher` the function has no effect. Notes:;; " "Can invalidate iterators, but only if the insert causes the load factor to " "be greater to or equal to the maximum load factor. + + Pointers and " "references to elements are never invalidated." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可拷贝插入^]。 \n" "返回：返回类型的 bool 分量为 true 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发" "生。 \n" "指向元素的指针和引用永远不会失效。" #: :830 #, safe-html, strict-same msgctxt ":830" msgid "---" msgstr "---" #: :832 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :833 #, safe-html, strict-same msgid "```c++ std::pair insert(value_type&& obj); ```" msgstr "" "```c++ std::pair insert(value_type&& obj); ```" #: :837 #, safe-html, strict-same msgctxt ":837" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 obj 插入容器。" #: :840 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The bool component of the return " "type is true if an insert took place. + + If an insert took place, then the " "iterator points to the newly inserted element. Otherwise, it points to the " "element with equivalent key. Throws:;; If an exception is thrown by an " "operation other than a call to `hasher` the function has no effect. Notes:;; " "Can invalidate iterators, but only if the insert causes the load factor to " "be greater to or equal to the maximum load factor. + + Pointers and " "references to elements are never invalidated." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^]。 \n" "返回：返回类型的 bool 分量为 true 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发" "生。 \n" "指向元素的指针和引用永远不会失效。" #: :849 #, safe-html, strict-same msgctxt ":849" msgid "---" msgstr "---" #: :851 #, safe-html, strict-same msgid "Emplace Insert" msgstr "原地插入" #: :852 #, safe-html, strict-same msgid "```c++ template std::pair insert(P&& obj); ```" msgstr "" "```c++ template std::pair insert" "(P&& obj); ```" #: :856 #, safe-html, strict-same msgid "" "Inserts an element into the container by performing `emplace(std::forward

" "(value))`." msgstr "通过执行 `emplace(std::forward

(value))` 向容器中插入一个元素。

" #: :858 #, safe-html, strict-same msgctxt ":858" msgid "" "Only participates in overload resolution if " "`std::is_constructible::value` is `true`." msgstr "" "仅当 std::is_constructible::value 为 true 时参与重载决" "议。" #: :861 #, safe-html, strict-same msgid "" "Returns:;; The bool component of the return type is true if an insert took " "place. + + If an insert took place, then the iterator points to the newly " "inserted element. Otherwise, it points to the element with equivalent key." msgstr "" "返回：返回类型的 bool 分量为 true 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" #: :865 #, safe-html, strict-same msgctxt ":865" msgid "---" msgstr "---" #: :867 #, safe-html, strict-same msgid "Copy Insert with Hint" msgstr "带提示的复制插入" #: :868 #, safe-html, strict-same msgid "" "```c++ iterator insert(const_iterator hint, const value_type& obj); ``` " "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "" "```c++iterator insert(const_iterator hint, const value_type& obj);```\n" "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :873 #, safe-html, strict-same msgctxt ":873" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是关于元素插入位置的建议。" #: :876 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; If an insert took place, then " "the iterator points to the newly inserted element. Otherwise, it points to " "the element with equivalent key. Throws:;; If an exception is thrown by an " "operation other than a call to `hasher` the function has no effect. Notes:;; " "The standard is fairly vague on the meaning of the hint. But the only " "practical way to use it, and the only way that Boost.Unordered supports is " "to point to an existing element with the same key. + + Can invalidate " "iterators, but only if the insert causes the load factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可拷贝插入^]。 \n" "返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" " \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 " "Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 " "\n" "指向元素的指针和引用永远不会失效。" #: :885 #, safe-html, strict-same msgctxt ":885" msgid "---" msgstr "---" #: :887 #, safe-html, strict-same msgid "Move Insert with Hint" msgstr "带提示的移动插入" #: :888 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" msgstr "" "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" #: :892 #, safe-html, strict-same msgctxt ":892" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :894 #, safe-html, strict-same msgctxt ":894" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是关于元素插入位置的建议。" #: :897 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; If an insert took place, then " "the iterator points to the newly inserted element. Otherwise, it points to " "the element with equivalent key. Throws:;; If an exception is thrown by an " "operation other than a call to `hasher` the function has no effect. Notes:;; " "The standard is fairly vague on the meaning of the hint. But the only " "practical way to use it, and the only way that Boost.Unordered supports is " "to point to an existing element with the same key. + + Can invalidate " "iterators, but only if the insert causes the load factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated." msgstr "" "要求：`value_type` 满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^]。 \n" "返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" " \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 " "Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 " "\n" "指向元素的指针和引用永远不会失效。" #: :906 #, safe-html, strict-same msgctxt ":906" msgid "---" msgstr "---" #: :908 #, safe-html, strict-same msgid "Emplace Insert with Hint" msgstr "带提示的原地插入" #: :910 #, safe-html, strict-same msgid "" "```c++ template iterator insert(const_iterator hint, P&& obj); ```" msgstr "" "```c++ template iterator insert(const_iterator hint, " "P&& obj); ```" #: :914 #, safe-html, strict-same msgid "" "Inserts an element into the container by performing `emplace_hint(hint, " "std::forward

(value))`." msgstr "" "通过执行 `emplace_hint(hint, std::forward

(value))` 向容器中插入一个元素" "。

" #: :916 #, safe-html, strict-same msgctxt ":916" msgid "" "Only participates in overload resolution if " "`std::is_constructible::value` is `true`." msgstr "" "仅当 `std::is_constructible::value` 为 `true` 时参与重" "载决议。" #: :918 #, safe-html, strict-same msgctxt ":918" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是关于元素插入位置的建议。" #: :921 #, safe-html, strict-same msgid "" "Returns:;; If an insert took place, then the iterator points to the newly " "inserted element. Otherwise, it points to the element with equivalent key. " "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" "指向元素的指针和引用永远不会失效。" #: :928 #, safe-html, strict-same msgctxt ":928" msgid "---" msgstr "---" #: :930 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :931 #, safe-html, strict-same msgid "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" #: :935 #, safe-html, strict-same msgctxt ":935" msgid "" "Inserts a range of elements into the container. Elements are inserted if and " "only if there is no element in the container with an equivalent key." msgstr "" "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入" "这些元素。" #: :938 #, 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" "指向元素的指针和引用永远不会失效。" #: :944 #, safe-html, strict-same msgctxt ":944" msgid "---" msgstr "---" #: :946 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :947 #, safe-html, strict-same msgid "```c++ void insert(std::initializer_list); ```" msgstr "```c++ void insert(std::initializer_list); ```" #: :951 #, safe-html, strict-same msgctxt ":951" msgid "" "Inserts a range of elements into the container. Elements are inserted if and " "only if there is no element in the container with an equivalent key." msgstr "" "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入" "这些元素。" #: :954 #, 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" "指向元素的指针和引用永远不会失效。" #: :960 #, safe-html, strict-same msgctxt ":960" msgid "---" msgstr "---" #: :962 #, safe-html, strict-same msgid "try_emplace" msgstr "try_emplace" #: :963 #, safe-html, strict-same msgid "" "```c++ template std::pair try_emplace(const " "key_type& k, Args&&... args); template std::pair try_emplace(key_type&& k, Args&&... args); template std::pair try_emplace(K&& k, Args&&... args) ```" msgstr "" "```c++ template std::pair " "try_emplace(const key_type& k, Args&&... args); " "template std::pair try_emplace" "(key_type&& k, Args&&... args); template std::pair try_emplace" "(K&& k, Args&&... args) ```" #: :972 #, safe-html, strict-same msgctxt ":972" msgid "" "Inserts a new element into the container if there is no existing element " "with key `k` contained within it." msgstr "如果容器中不存在键为 `k` 的元素，则插入一个新元素。" #: :974 #, safe-html, strict-same msgctxt ":974" msgid "" "If there is an existing element with key `k` this function does nothing." msgstr "如果已存在键为 `k` 的元素，则该函数不执行任何操作。" #: :977 #, safe-html, strict-same msgid "" "Returns:;; The bool component of the return type is true if an insert took " "place. + + If an insert took place, then the iterator points to the newly " "inserted element. Otherwise, it points to the element with equivalent key. " "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` the function has no effect. Notes:;; This function is similiar to " "xref:#unordered_map_emplace[emplace] except the `value_type` is constructed " "using: + + -- ```c++" msgstr "" "返回：返回类型的 bool 分量为 true 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：此函数类似于 xref:#unordered_map_emplace[emplace]，区别在于 " "`value_type` 的构造方式如下： ```c++" #: :986 #, safe-html, strict-same msgctxt ":986" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" #: :991 #, safe-html, strict-same msgctxt ":991" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" #: :996 #, safe-html, strict-same msgid "" "instead of xref:#unordered_map_emplace[emplace] which simply forwards all " "arguments to ``value_type``'s constructor." msgstr "" "而不是像 xref:#unordered_map_emplace[emplace] 那样简单地将所有参数转发给 " "`value_type` 的构造函数。" #: :998 #, safe-html, strict-same msgctxt ":998" msgid "" "Can invalidate iterators, but only if the insert causes the load factor to " "be greater to or equal to the maximum load factor." msgstr "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。" #: :1000 #, safe-html, strict-same msgctxt ":1000" msgid "Pointers and references to elements are never invalidated." msgstr "指向元素的指针和引用永远不会失效。" #: :1002 #, safe-html, strict-same msgctxt ":1002" msgid "" "The `template` overload only participates in " "overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are " "valid member typedefs and neither `iterator` nor `const_iterator` are " "implicitly convertible from `K`. The library assumes that `Hash` is callable " "with both `K` and `Key` and that `Pred` is transparent. This enables " "heterogeneous lookup which avoids the cost of instantiating an instance of " "the `Key` type. --" msgstr "" "`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 " "`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使" "用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :1005 #, safe-html, strict-same msgctxt ":1005" msgid "---" msgstr "---" #: :1007 #, safe-html, strict-same msgid "try_emplace with Hint" msgstr "带提示位置的 `try_emplace`" #: :1008 #, safe-html, strict-same msgid "" "```c++ template iterator try_emplace(const_iterator hint, " "const key_type& k, Args&&... args); template iterator " "try_emplace(const_iterator hint, key_type&& k, Args&&... args); " "template iterator try_emplace(const_iterator hint, " "K&& k, Args&&... args); ```" msgstr "" "```c++ template iterator try_emplace(const_iterator " "hint, const key_type& k, Args&&... args); template iterator try_emplace(const_iterator hint, key_type&& k, " "Args&&... args); template " "iterator try_emplace(const_iterator hint, K&& k, Args&&... " "args); ```" #: :1017 #, safe-html, strict-same msgctxt ":1017" msgid "" "Inserts a new element into the container if there is no existing element " "with key `k` contained within it." msgstr "如果容器中不存在键为 `k` 的元素，则插入一个新元素。" #: :1019 #, safe-html, strict-same msgctxt ":1019" msgid "" "If there is an existing element with key `k` this function does nothing." msgstr "如果已存在键为 `k` 的元素，则该函数不执行任何操作。" #: :1021 #, safe-html, strict-same msgctxt ":1021" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是关于元素插入位置的建议。" #: :1024 #, safe-html, strict-same msgid "" "Returns:;; If an insert took place, then the iterator points to the newly " "inserted element. Otherwise, it points to the element with equivalent key. " "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` the function has no effect. Notes:;; This function is similiar to " "xref:#unordered_map_emplace_hint[emplace_hint] except the `value_type` is " "constructed using: + + -- ```c++" msgstr "" "返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" " 抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：此函数类似于 xref:#unordered_map_emplace_hint[emplace_hint]，区别在于 " "`value_type` 的构造方式如下： \n" "```c++" #: :1031 #, safe-html, strict-same msgctxt ":1031" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" #: :1036 #, safe-html, strict-same msgctxt ":1036" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" #: :1041 #, safe-html, strict-same msgid "" "instead of xref:#unordered_map_emplace_hint[emplace_hint] which simply " "forwards all arguments to ``value_type``'s constructor." msgstr "" "而不是像 xref:#unordered_map_emplace_hint[emplace_hint] 那样简单地将所有参数" "转发给 `value_type` 的构造函数。" #: :1043 #, safe-html, strict-same msgid "" "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." msgstr "" "标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 " "Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。" #: :1045 #, safe-html, strict-same msgctxt ":1045" msgid "" "Can invalidate iterators, but only if the insert causes the load factor to " "be greater to or equal to the maximum load factor." msgstr "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。" #: :1047 #, safe-html, strict-same msgctxt ":1047" msgid "Pointers and references to elements are never invalidated." msgstr "指向元素的指针和引用永远不会失效。" #: :1049 #, safe-html, strict-same msgctxt ":1049" msgid "" "The `template` overload only participates in " "overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are " "valid member typedefs and neither `iterator` nor `const_iterator` are " "implicitly convertible from `K`. The library assumes that `Hash` is callable " "with both `K` and `Key` and that `Pred` is transparent. This enables " "heterogeneous lookup which avoids the cost of instantiating an instance of " "the `Key` type. --" msgstr "" "`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 " "`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使" "用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :1052 #, safe-html, strict-same msgctxt ":1052" msgid "---" msgstr "---" #: :1054 #, safe-html, strict-same msgid "insert_or_assign" msgstr "insert_or_assign" #: :1055 #, safe-html, strict-same msgid "" "```c++ template std::pair insert_or_assign(const " "key_type& k, M&& obj); template std::pair " "insert_or_assign(key_type&& k, M&& obj); template " "std::pair insert_or_assign(K&& k, M&& obj); ```" msgstr "" "```c++ template std::pair insert_or_assign" "(const key_type& k, M&& obj); template " "std::pair insert_or_assign(key_type&& k, " "M&& obj); template " "std::pair insert_or_assign(K&& k, M&& " "obj); ```" #: :1064 #, safe-html, strict-same msgctxt ":1064" msgid "" "Inserts a new element into the container or updates an existing one by " "assigning to the contained value." msgstr "向容器中插入一个新元素，或通过赋值更新现有元素的值。" #: :1066 #, safe-html, strict-same msgctxt ":1066" msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "如果存在键为 `k` 的元素，则通过赋值 `std::forward(obj)` 来更新它。" #: :1068 #, safe-html, strict-same msgctxt ":1068" msgid "If there is no such element, it is added to the container as: ```c++" msgstr "" "如果不存在这样的元素，则将其添加到容器中，形式为： \n" "```c++" #: :1071 #, safe-html, strict-same msgctxt ":1071" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" #: :1076 #, safe-html, strict-same msgctxt ":1076" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj))) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj))) ```" #: :1082 #, safe-html, strict-same msgid "" "Returns:;; The bool component of the return type is true if an insert took " "place. + + If an insert took place, then the iterator points to the newly " "inserted element. Otherwise, it points to the element with equivalent key. " "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` the function has no effect. Notes:;; Can invalidate iterators, but " "only if the insert causes the load factor to be greater to or equal to the " "maximum load factor. + + Pointers and references to elements are never " "invalidated. + + The `template` only participates in " "overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are " "valid member typedefs. The library assumes that `Hash` is callable with both " "`K` and `Key` and that `Pred` is transparent. This enables heterogeneous " "lookup which avoids the cost of instantiating an instance of the `Key` type." msgstr "" "返回：返回类型的 bool 分量为 true 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发" "生。 \n" "指向元素的指针和引用永远不会失效。 \n" "\n" "`template` 仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1092 #, safe-html, strict-same msgctxt ":1092" msgid "---" msgstr "---" #: :1094 #, safe-html, strict-same msgid "insert_or_assign with Hint" msgstr "带提示位置的 `insert_or_assign`" #: :1095 #, safe-html, strict-same msgid "" "```c++ template iterator insert_or_assign(const_iterator hint, " "const key_type& k, M&& obj); template iterator insert_or_assign" "(const_iterator hint, key_type&& k, M&& obj); template " "iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); ```" msgstr "" "```c++ template iterator insert_or_assign(const_iterator hint, " "const key_type& k, M&& obj); template iterator " "insert_or_assign(const_iterator hint, key_type&& k, M&& obj)" "; template iterator insert_or_assign" "(const_iterator hint, K&& k, M&& obj); ```" #: :1104 #, safe-html, strict-same msgctxt ":1104" msgid "" "Inserts a new element into the container or updates an existing one by " "assigning to the contained value." msgstr "向容器中插入一个新元素，或通过赋值更新现有元素的值。" #: :1106 #, safe-html, strict-same msgctxt ":1106" msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "如果存在键为 `k` 的元素，则通过赋值 `std::forward(obj)` 来更新它。" #: :1108 #, safe-html, strict-same msgctxt ":1108" msgid "If there is no such element, it is added to the container as: ```c++" msgstr "向容器中插入新元素，或通过赋值给已存在的元素值来更新该元素。" #: :1111 #, safe-html, strict-same msgctxt ":1111" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" #: :1116 #, safe-html, strict-same msgctxt ":1116" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj))) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj))) ```" #: :1121 #, safe-html, strict-same msgctxt ":1121" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是关于元素插入位置的建议。" #: :1124 #, safe-html, strict-same msgid "" "Returns:;; If an insert took place, then the iterator points to the newly " "inserted element. Otherwise, it points to the element with equivalent key. " "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` the function has no effect. Notes:;; The standard is fairly vague " "on the meaning of the hint. But the only practical way to use it, and the " "only way that Boost.Unordered supports is to point to an existing element " "with the same key. + + Can invalidate iterators, but only if the insert " "causes the load factor to be greater to or equal to the maximum load factor. " "+ + Pointers and references to elements are never invalidated. + + The " "`template` only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" " \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 " "Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 " "指向元素的指针和引用永远不会失效。 \n" "`template` 仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1134 #, safe-html, strict-same msgctxt ":1134" msgid "---" msgstr "---" #: :1136 #, safe-html, strict-same msgid "Extract by Iterator" msgstr "通过迭代器提取" #: :1137 #, safe-html, strict-same msgid "```c++ node_type extract(const_iterator position); ```" msgstr "```c++ node_type extract(const_iterator position); ```" #: :1141 #, safe-html, strict-same msgid "Removes the element pointed to by `position`." msgstr "移除 `position` 所指向的元素。" #: :1144 #, 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_multimap`." msgstr "" "返回：一个拥有该元素的 `node_type`。 \n" "注意：通过此方法提取的节点可以插入到兼容的 `unordered_multimap` 中。" #: :1147 #, safe-html, strict-same msgctxt ":1147" msgid "---" msgstr "---" #: :1149 #, safe-html, strict-same msgid "Extract by Key" msgstr "通过键提取" #: :1150 #, safe-html, strict-same msgid "" "```c++ node_type extract(const key_type& k); template node_type " "extract(K&& k); ```" msgstr "" "```c++ node_type extract(const key_type& k); template " "node_type extract(K&& k); ```" #: :1155 #, safe-html, strict-same msgid "Removes an element with key equivalent to `k`." msgstr "移除一个键与 `k` 等价的元素。" #: :1158 #, 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_multimap`. + + The `template` " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. The library " "assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：如果找到该元素，则返回一个拥有该元素的 `node_type`；否则返回一个空的 " "`node_type`。 \n" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n" "注意：通过此方法提取的节点可以插入到兼容的 `unordered_multimap` 中。 \n" "`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 " "`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使" "用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :1164 #, safe-html, strict-same msgctxt ":1164" msgid "---" msgstr "---" #: :1166 #, safe-html, strict-same msgid "Insert with `node_handle`" msgstr "通过 `node_handle` 插入" #: :1167 #, safe-html, strict-same msgid "```c++ insert_return_type insert(node_type&& nh); ```" msgstr "```c++ insert_return_type insert(node_type&& nh); ```" #: :1171 #, safe-html, strict-same msgctxt ":1171" msgid "If `nh` is empty, has no effect." msgstr "如果 `nh` 为空，则无效果。" #: :1173 #, safe-html, strict-same msgctxt ":1173" msgid "" "Otherwise inserts the element owned by `nh` if and only if there is no " "element in the container with an equivalent key." msgstr "否则，当且仅当容器中没有具有等价键的元素时，才插入 `nh` 所拥有的元素。" #: :1176 #, safe-html, strict-same msgid "" "Requires:;; `nh` is empty or `nh.get_allocator()` is equal to the " "container's allocator. Returns:;; If `nh` was empty, returns an " "`insert_return_type` with: `inserted` equal to `false`, `position` equal to " "`end()` and `node` empty. + + Otherwise if there was already an element with " "an equivalent key, returns an `insert_return_type` with: `inserted` equal to " "`false`, `position` pointing to a matching element and `node` contains the " "node from `nh`. + + Otherwise if the insertion succeeded, returns an " "`insert_return_type` with: `inserted` equal to `true`, `position` pointing " "to the newly inserted element and `node` empty. Throws:;; If an exception is " "thrown by an operation other than a call to `hasher` the function has no " "effect. Notes:;; Can invalidate iterators, but only if the insert causes the " "load factor to be greater to or equal to the maximum load factor. + + " "Pointers and references to elements are never invalidated. + + This can be " "used to insert a node extracted from a compatible `unordered_multimap`." msgstr "" "要求：`nh` 为空或 `nh.get_allocator()` 等于容器的分配器。 \n" "返回：如果 `nh` 为空，则返回一个 `insert_return_type`，其中 `inserted` 为 " "`false`，`position` 等于 `end()`，`node` 为空。 \n" "否则如果已存在具有等价键的元素，则返回一个 `insert_return_type`，其中 " "`inserted` 为 `false`，`position` 指向匹配的元素，`node` 包含 `nh` 中的节点。" " \n" "否则如果插入成功，则返回一个 `insert_return_type`，其中 `inserted` 为 " "`true`，`position` 指向新插入的元素，`node` 为空。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发" "生。 \n" "指向元素的指针和引用永远不会失效。 \n" "此函数可用于插入从兼容的 `unordered_multimap` 中提取的节点。" #: :1189 #, safe-html, strict-same msgctxt ":1189" msgid "---" msgstr "---" #: :1191 #, safe-html, strict-same msgid "Insert with Hint and `node_handle`" msgstr "带提示和 `node_handle` 的插入" #: :1192 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" msgstr "" "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" #: :1196 #, safe-html, strict-same msgctxt ":1196" msgid "If `nh` is empty, has no effect." msgstr "如果 `nh` 为空，则无效果。" #: :1198 #, safe-html, strict-same msgctxt ":1198" msgid "" "Otherwise inserts the element owned by `nh` if and only if there is no " "element in the container with an equivalent key." msgstr "否则，当且仅当容器中没有具有等价键的元素时，才插入 `nh` 所拥有的元素。" #: :1200 #, safe-html, strict-same msgid "" "If there is already an element in the container with an equivalent key has " "no effect on `nh` (i.e. `nh` still contains the node.)" msgstr "" "如果容器中已存在具有等价键的元素，则对 `nh` 无影响（即 `nh` 仍然包含该节点）" "。" #: :1202 #, safe-html, strict-same msgctxt ":1202" msgid "`hint` is a suggestion to where the element should be inserted." msgstr "`hint` 是关于元素插入位置的建议。" #: :1205 #, safe-html, strict-same msgid "" "Requires:;; `nh` is empty or `nh.get_allocator()` is equal to the " "container's allocator. Returns:;; If `nh` was empty returns `end()`. + + If " "there was already an element in the container with an equivalent key returns " "an iterator pointing to that. + + Otherwise returns an iterator pointing to " "the newly inserted element. Throws:;; If an exception is thrown by an " "operation other than a call to hasher the function has no effect. Notes:;; " "The standard is fairly vague on the meaning of the hint. But the only " "practical way to use it, and the only way that Boost.Unordered supports is " "to point to an existing element with the same key. + + Can invalidate " "iterators, but only if the insert causes the load factor to be greater to or " "equal to the maximum load factor. + + Pointers and references to elements " "are never invalidated. + + This can be used to insert a node extracted from " "a compatible `unordered_multimap`." msgstr "" "要求：`nh` 为空或 `nh.get_allocator()` 等于容器的分配器。 \n" "返回：如果 `nh` 为空，则返回 `end()`。 \n" "如果容器中已存在具有等价键的元素，则返回指向该元素的迭代器。 \n" "否则返回指向新插入元素的迭代器。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 " "Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。 \n" "可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 " "\n" "指向元素的指针和引用永远不会失效。 \n" "此函数可用于插入从兼容的 `unordered_multimap` 中提取的节点。" #: :1220 #, safe-html, strict-same msgctxt ":1220" msgid "---" msgstr "---" #: :1222 #, safe-html, strict-same msgid "Erase by Position" msgstr "通过位置擦除" #: :1224 #, 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); ```" #: :1229 #, safe-html, strict-same msgctxt ":1229" msgid "Erase the element pointed to by `position`." msgstr "擦除 `position` 所指向的元素。" #: :1232 #, 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" "注意：在旧版本中，此操作可能效率较低，因为它需要搜索多个桶以找到返回迭代器的" "位置。数据结构已经更改，不再是这种情况，并且备用的擦除方法已被弃用。" #: :1236 #, safe-html, strict-same msgctxt ":1236" msgid "---" msgstr "---" #: :1238 #, safe-html, strict-same msgid "Erase by Key" msgstr "通过键擦除" #: :1239 #, safe-html, strict-same msgid "" "```c++ size_type erase(const key_type& k); template size_type erase" "(K&& k); ```" msgstr "" "```c++ size_type erase(const key_type& k); template " "size_type erase(K&& k); ```" #: :1244 #, safe-html, strict-same msgid "Erase all elements with key equivalent to `k`." msgstr "擦除所有键与 `k` 等价的元素。" #: :1247 #, safe-html, strict-same msgid "" "Returns:;; The number of elements erased. Throws:;; Only throws an exception " "if it is thrown by `hasher` or `key_equal`. Notes:;; The `template` " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. The library " "assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：被擦除的元素数量。 \n" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 " "`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使" "用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :1251 #, safe-html, strict-same msgctxt ":1251" msgid "---" msgstr "---" #: :1253 #, safe-html, strict-same msgid "Erase Range" msgstr "范围擦除" #: :1255 #, safe-html, strict-same msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```" msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```" #: :1259 #, safe-html, strict-same msgid "Erases the elements in the range from `first` to `last`." msgstr "擦除从 `first` 到 `last` 范围内的元素。" #: :1262 #, 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" "在此实现中，此重载不会调用任何函数对象的方法，因此不会抛出异常，但这在其他实" "现中可能并不成立。" #: :1267 #, safe-html, strict-same msgctxt ":1267" msgid "---" msgstr "---" #: :1269 #, safe-html, strict-same msgid "quick_erase" msgstr "quick_erase" #: :1270 #, safe-html, strict-same msgid "```c++ void quick_erase(const_iterator position); ```" msgstr "```c++ void quick_erase(const_iterator position); ```" #: :1274 #, safe-html, strict-same msgctxt ":1274" msgid "Erase the element pointed to by `position`." msgstr "擦除 `position` 所指向的元素。" #: :1277 #, safe-html, strict-same msgctxt ":1277" 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` 返回下一个元素的迭代器开销较大，" "但容器已经过重新设计，情况不再如此。因此，此方法现已废弃。" #: :1282 #, safe-html, strict-same msgctxt ":1282" msgid "---" msgstr "---" #: :1284 #, safe-html, strict-same msgid "erase_return_void" msgstr "erase_return_void" #: :1285 #, safe-html, strict-same msgid "```c++ void erase_return_void(const_iterator position); ```" msgstr "```c++ void erase_return_void(const_iterator position); ```" #: :1289 #, safe-html, strict-same msgctxt ":1289" msgid "Erase the element pointed to by `position`." msgstr "删除 `position` 所指向的元素。" #: :1292 #, safe-html, strict-same msgctxt ":1292" 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` 返回下一个元素的迭代器开销较大，" "但容器已经过重新设计，情况不再如此。因此，此方法现已废弃。" #: :1297 #, safe-html, strict-same msgctxt ":1297" msgid "---" msgstr "---" #: :1299 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :1300 #, safe-html, strict-same msgid "" "```c++ void swap(unordered_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_swappable_v && boost::is_nothrow_swappable_v); " "```" msgstr "" "```c++ void swap(unordered_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value && " "boost::is_nothrow_swappable_v && " "boost::is_nothrow_swappable_v); ```" #: :1307 #, safe-html, strict-same msgid "Swaps the contents of the container with the parameter." msgstr "将容器的内容与参数进行交换。" #: :1309 #, safe-html, strict-same msgctxt ":1309" 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`，则交换两个容器的分" "配器。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1312 #, 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 标准不完全相同，因为相等谓词和哈希函数是通过它们的" "复制构造函数进行交换的。" #: :1315 #, safe-html, strict-same msgctxt ":1315" msgid "---" msgstr "---" #: :1317 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1318 #, safe-html, strict-same msgid "```c++ void clear(); ```" msgstr "```c++ void clear(); ```" #: :1322 #, safe-html, strict-same msgid "Erases all elements in the container." msgstr "清除容器中的所有元素。" #: :1325 #, safe-html, strict-same msgid "Postconditions:;; `size() == 0` Throws:;; Never throws an exception." msgstr "后置条件：;; `size() == 0`抛出：;; 永不抛出异常。" #: :1328 #, safe-html, strict-same msgctxt ":1328" msgid "---" msgstr "---" #: :1330 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1331 #, safe-html, strict-same msgid "" "```c++ template void merge(unordered_map& source); template void merge" "(unordered_map&& source); template void merge(unordered_multimap& source); " "template void merge(unordered_multimap&& source); ```" msgstr "" "```c++ template void merge" "(unordered_map& source); " "template void merge(unordered_map&& source); template void merge(unordered_multimap& source); template void merge(unordered_multimap&& source); ```" "" #: :1342 #, safe-html, strict-same msgid "" "Attempt to \"merge\" two containers by iterating `source` and extracting any " "node in `source` that is not contained in `*this` and then inserting it into " "`*this`." msgstr "" "尝试通过迭代 `source` 并提取 `source` 中不包含在 `*this` 内的任何节点，然后将" "其插入到 `*this` 中，从而实现两个容器的“合并”。" #: :1345 #, 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->hash_function()` 重新计算哈希值，然后根据需要再使用 " "`this->key_eq()` 进行比较。" #: :1348 #, safe-html, strict-same msgid "" "The behavior of this function is undefined if `this\\->get_allocator() != " "source.get_allocator()`." msgstr "" "如果 `this->get_allocator() != source.get_allocator()`，则此函数的行为未定" "义。" #: :1350 #, 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` 中。" #: :1354 #, safe-html, strict-same msgid "Notes:;; + --" msgstr "注意:;; + --" #: :1357 #, safe-html, strict-same msgid "Pointers and references to transferred elements remain valid." msgstr "指向被转移元素的指针和引用保持有效。" #: :1358 #, safe-html, strict-same msgid "Invalidates iterators to transferred elements." msgstr "使指向被转移元素的迭代器失效。" #: :1359 #, safe-html, strict-same msgid "Invalidates iterators belonging to `*this`." msgstr "使属于 `*this` 的迭代器失效。" #: :1360 #, safe-html, strict-same msgid "Iterators to non-transferred elements in `source` remain valid." msgstr "`source` 中未被转移的元素的迭代器保持有效。" #: :1361 #, safe-html, strict-same msgid "--" msgstr "--" #: :1363 #, safe-html, strict-same msgctxt ":1363" msgid "---" msgstr "---" #: :1365 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1367 #, safe-html, strict-same msgid "get_allocator" msgstr "get_allocator" #: :1368 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const; ```" msgstr "``` allocator_type get_allocator() const; ```" #: :1372 #, safe-html, strict-same msgctxt ":1372" msgid "---" msgstr "---" #: :1374 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1375 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :1380 #, safe-html, strict-same msgid "Returns:;; The container's hash function." msgstr "返回：;; 容器的哈希函数。" #: :1382 #, safe-html, strict-same msgctxt ":1382" msgid "---" msgstr "---" #: :1384 #, safe-html, strict-same msgid "key_eq" msgstr "key_eq" #: :1385 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1390 #, safe-html, strict-same msgid "Returns:;; The container's key equality predicate" msgstr "返回：;; 容器的键相等谓词。" #: :1392 #, safe-html, strict-same msgctxt ":1392" msgid "---" msgstr "---" #: :1394 #, safe-html, strict-same msgid "Lookup" msgstr "查找" #: :1396 #, safe-html, strict-same msgid "find" msgstr "find" #: :1397 #, safe-html, strict-same msgid "" "```c++ iterator find(const key_type& k); const_iterator find(const " "key_type& k) const; template iterator find(const K& k); " "template const_iterator find(const K& k) const; template " "iterator find(CompatibleKey const& k, CompatibleHash const& hash, " "CompatiblePredicate const& eq); template const_iterator find" "(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate " "const& eq) const;" msgstr "" "```c++ iterator find(const key_type& k); const_iterator find" "(const key_type& k) const; template iterator find" "(const K& k); template const_iterator find(const K& k) " "const; template iterator find" "(CompatibleKey const& k, CompatibleHash const& hash, " "CompatiblePredicate const& eq); template const_iterator " "find(CompatibleKey const& k, CompatibleHash const& hash, " "CompatiblePredicate const& eq) const;" #: :1411 #, safe-html, strict-same msgid "```" msgstr "```" #: :1414 #, safe-html, strict-same msgid "" "Returns:;; An iterator pointing to an element with key equivalent to `k`, or " "`b.end()` if no such element exists. Notes:;; The templated overloads " "containing `CompatibleKey`, `CompatibleHash` and `CompatiblePredicate` are " "non-standard extensions which allow you to use a compatible hash function " "and equality predicate for a key of a different type in order to avoid an " "expensive type cast. In general, its use is not encouraged and instead the " "`K` member function templates should be used. + + The `template` " "overloads only participate in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs. The library assumes " "that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：;; 指向键与 `k` 等价之元素的迭代器；若无此元素，则返回 `b.end()`。\n" "备注：;; 包含 `CompatibleKey`、`CompatibleHash` 和 `CompatiblePredicate` 的模" "板重载属于非标准扩展，允许使用兼容的哈希函数和相等谓词来处理不同类型的键，从" "而避免昂贵的类型转换。通常不建议使用它们，而应使用 `K` 成员函数模板。\n" "此外，仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1419 #, safe-html, strict-same msgctxt ":1419" msgid "---" msgstr "---" #: :1421 #, safe-html, strict-same msgid "count" msgstr "count" #: :1422 #, safe-html, strict-same msgid "" "```c++ size_type count(const key_type& k) const; template " "size_type count(const K& k) const; ```" msgstr "" "```c++ size_type count(const key_type& k) const; template size_type count(const K& k) const; ```" #: :1429 #, safe-html, strict-same msgid "" "Returns:;; The number of elements with key equivalent to `k`. Notes:;; The " "`template` overload only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：;; 键与 `k` 等价的元素个数。\n" "备注：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1432 #, safe-html, strict-same msgctxt ":1432" msgid "---" msgstr "---" #: :1434 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1435 #, safe-html, strict-same msgid "" "```c++ bool contains(const key_type& k) const; template " "bool contains(const K& k) const; ```" msgstr "" "```c++ bool contains(const key_type& k) const; " "template bool contains(const K& k) const; ```" #: :1442 #, safe-html, strict-same msgid "" "Returns:;; A boolean indicating whether or not there is an element with key " "equal to `key` in the container Notes:;; The `template` overload " "only participates in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：;; 一个布尔值，指示容器中是否存在键等于 `key` 的元素。\n" "备注：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1445 #, safe-html, strict-same msgctxt ":1445" msgid "---" msgstr "---" #: :1447 #, safe-html, strict-same msgid "equal_range" msgstr "equal_range" #: :1448 #, safe-html, strict-same msgid "" "```c++ std::pair equal_range(const " "key_type& k); std::pair equal_range(const " "key_type& k) const; template std::pair" " equal_range(const K& k); template " "std::pair equal_range(const K& k) const; ```" msgstr "" "```c++ std::pair equal_range(const " "key_type& k); std::pair " "equal_range(const key_type& k) const; template " "std::pair equal_range(const K& k); " "template std::pair " "equal_range(const K& k) const; ```" "" #: :1458 #, safe-html, strict-same msgid "" "Returns:;; A range containing all elements with key equivalent to `k`. If " "the container doesn't contain any such elements, returns `std::make_pair" "(b.end(), b.end())`. Notes:;; The `template` overloads only " "participate in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：;; 一个范围，包含所有键与 `k` 等价的元素。若容器中不包含任何此类元素，" "则返回 `std::make_pair(b.end(), b.end())`。\n" "备注：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1461 #, safe-html, strict-same msgctxt ":1461" msgid "---" msgstr "---" #: :1463 #, safe-html, strict-same msgid "operator++[++++]++" msgstr "operator++[++++]++" #: :1464 #, safe-html, strict-same msgid "" "```c++ mapped_type& operator[](const key_type& k); mapped_type& operator[]" "(key_type&& k); template mapped_type& operator[](K&& k); ```" msgstr "" "```c++ mapped_type& operator[](const key_type& k); mapped_type& " "operator[](key_type&& k); template mapped_type& " "operator[](K&& k); ```" #: :1471 #, safe-html, strict-same msgid "" "Effects:;; If the container does not already contain an elements with a key " "equivalent to `k`, inserts the value `std::pair" "(k, mapped_type())`. Returns:;; A reference to `x.second` where `x` is the " "element already in the container, or the newly inserted element with a key " "equivalent to `k`. 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. + + The `template` overload only " "participates in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "效果：;; 如果容器中尚不存在键与 `k` 等价的元素，则插入值 `std::pair(k, mapped_type())`。\n" "返回：;; 指向 `x.second` 的引用，其中 `x` 是容器中已存在的元素，或者是键与 " "`k` 等价的新插入元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会" "发生。\n" "此外，指向元素的指针和引用永远不会失效。\n" "另外，仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1480 #, safe-html, strict-same msgctxt ":1480" msgid "---" msgstr "---" #: :1482 #, safe-html, strict-same msgid "at" msgstr "at" #: :1483 #, safe-html, strict-same msgid "" "```c++ mapped_type& at(const key_type& k); const mapped_type& at(const " "key_type& k) const; template mapped_type& at(const K& k); " "template const mapped_type& at(const K& k) const; ```" msgstr "" "```c++ mapped_type& at(const key_type& k); const mapped_type& at" "(const key_type& k) const; template mapped_type& at" "(const K& k); template const mapped_type& at(const " "K& k) const; ```" #: :1491 #, safe-html, strict-same msgid "" "Returns:;; A reference to `x.second` where `x` is the (unique) element whose " "key is equivalent to `k`. Throws:;; An exception object of type " "`std::out_of_range` if no such element is present. Notes:;; The " "`template` overloads only participate in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：;; 指向 `x.second` 的引用，其中 `x` 是键与 `k` 等价的（唯一）元素。\n" "抛出：;; 如果不存在这样的元素，则抛出 `std::out_of_range` 类型的异常对象。\n" "备注：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1495 #, safe-html, strict-same msgctxt ":1495" msgid "---" msgstr "---" #: :1497 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1499 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1500 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1505 #, safe-html, strict-same msgid "Returns:;; The number of buckets." msgstr "返回：;; 桶的数量。" #: :1507 #, safe-html, strict-same msgctxt ":1507" msgid "---" msgstr "---" #: :1509 #, safe-html, strict-same msgid "max_bucket_count" msgstr "max_bucket_count" #: :1510 #, safe-html, strict-same msgid "```c++ size_type max_bucket_count() const noexcept; ```" msgstr "```c++ size_type max_bucket_count() const noexcept; ```" #: :1515 #, safe-html, strict-same msgid "Returns:;; An upper bound on the number of buckets." msgstr "返回：;; 桶数量的上限。" #: :1517 #, safe-html, strict-same msgctxt ":1517" msgid "---" msgstr "---" #: :1519 #, safe-html, strict-same msgid "bucket_size" msgstr "桶大小" #: :1520 #, safe-html, strict-same msgid "```c++ size_type bucket_size(size_type n) const; ```" msgstr "```c++ size_type bucket_size(size_type n) const; ```" #: :1525 #, safe-html, strict-same msgid "" "Requires:;; `n < bucket_count()` Returns:;; The number of elements in bucket " "`n`." msgstr "要求：;; `n < bucket_count()`返回：;; 桶 `n` 中的元素个数。" #: :1528 #, safe-html, strict-same msgctxt ":1528" msgid "---" msgstr "---" #: :1530 #, safe-html, strict-same msgid "bucket" msgstr "桶" #: :1531 #, safe-html, strict-same msgid "" "```c++ size_type bucket(const key_type& k) const; template " "size_type bucket(const K& k) const; ```" msgstr "" "```c++ size_type bucket(const key_type& k) const; template " "size_type bucket(const K& k) const; ```" #: :1537 #, safe-html, strict-same msgid "" "Returns:;; The index of the bucket which would contain an element with key " "`k`. Postconditions:;; The return value is less than `bucket_count()`. " "Notes:;; The `template` overload only participates in overload " "resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid " "member typedefs. The library assumes that `Hash` is callable with both `K` " "and `Key` and that `Pred` is transparent. This enables heterogeneous lookup " "which avoids the cost of instantiating an instance of the `Key` type." msgstr "" "返回：;; 包含键 `k` 的元素的桶索引。\n" "后置条件：;; 返回值小于 `bucket_count()`。\n" "备注：;; 仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时，`template` 重载才会参与重载决议。库假定 `Hash` 可同" "时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型的开销。" #: :1541 #, safe-html, strict-same msgctxt ":1541" msgid "---" msgstr "---" #: :1543 #, safe-html, strict-same msgctxt ":1543" msgid "begin" msgstr "begin" #: :1545 #, 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; ```" #: :1551 #, 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` 的桶中第一个元素的局部迭代器。" #: :1554 #, safe-html, strict-same msgctxt ":1554" msgid "---" msgstr "---" #: :1556 #, safe-html, strict-same msgctxt ":1556" msgid "end" msgstr "end" #: :1557 #, 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; ```" #: :1563 #, 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` 的桶中“尾后”元素的局部迭代器。" #: :1566 #, safe-html, strict-same msgctxt ":1566" msgid "---" msgstr "---" #: :1568 #, safe-html, strict-same msgctxt ":1568" msgid "cbegin" msgstr "cbegin" #: :1569 #, safe-html, strict-same msgid "```c++ const_local_iterator cbegin(size_type n) const; ```" msgstr "```c++ const_local_iterator cbegin(size_type n) const; ```" #: :1574 #, 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` 的桶中第一个元素的常量局部迭代器。" #: :1577 #, safe-html, strict-same msgctxt ":1577" msgid "---" msgstr "---" #: :1579 #, safe-html, strict-same msgctxt ":1579" msgid "cend" msgstr "cend" #: :1580 #, safe-html, strict-same msgid "```c++ const_local_iterator cend(size_type n) const; ```" msgstr "```c++ const_local_iterator cend(size_type n) const; ```" #: :1585 #, 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` 的桶中“尾后”元素的常量局部迭代器。" #: :1588 #, safe-html, strict-same msgctxt ":1588" msgid "---" msgstr "---" #: :1590 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1592 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1593 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1598 #, safe-html, strict-same msgid "Returns:;; The average number of elements per bucket." msgstr "返回：;; 每个桶的平均元素个数。" #: :1600 #, safe-html, strict-same msgctxt ":1600" msgid "---" msgstr "---" #: :1602 #, safe-html, strict-same msgid "max_load_factor" msgstr "max_load_factor" #: :1604 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1609 #, safe-html, strict-same msgid "Returns:;; Returns the current maximum load factor." msgstr "返回：;; 返回当前的最大负载因子。" #: :1611 #, safe-html, strict-same msgctxt ":1611" msgid "---" msgstr "---" #: :1613 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1614 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1619 #, safe-html, strict-same msgid "" "Effects:;; Changes the container's maximum load factor, using `z` as a hint." msgstr "效果：;; 改变容器的最大负载因子，以 `z` 作为提示。" #: :1621 #, safe-html, strict-same msgctxt ":1621" msgid "---" msgstr "---" #: :1624 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1625 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1629 #, 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()`。" #: :1631 #, safe-html, strict-same msgid "" "When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array." msgstr "当 `size() == 0` 时，`rehash(0)` 将释放底层桶数组的内存。" #: :1633 #, safe-html, strict-same msgctxt ":1633" msgid "" "Invalidates iterators, and changes the order of elements. Pointers and " "references to elements are not invalidated." msgstr "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。" #: :1636 #, safe-html, strict-same msgctxt ":1636" 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 "抛出：;; 如果抛出异常（除非是由容器的哈希函数或比较函数抛出），则该函数无效。" #: :1638 #, safe-html, strict-same msgctxt ":1638" msgid "---" msgstr "---" #: :1640 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1641 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1645 #, safe-html, strict-same msgid "" "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`, or `a.rehash(1)` if " "`n > 0` and `a.max_load_factor() == std::numeric_limits::infinity()`." msgstr "" "等价于 `a.rehash(ceil(n / a.max_load_factor()))`；如果 `n > 0` 且 " "`a.max_load_factor() == std::numeric_limits::infinity()`，则等价于 " "`a.rehash(1)`。" #: :1647 #, 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` 类似，此函数可用于增加或减少容器中桶的数量。" #: :1649 #, safe-html, strict-same msgctxt ":1649" msgid "" "Invalidates iterators, and changes the order of elements. Pointers and " "references to elements are not invalidated." msgstr "使迭代器失效，并改变元素的顺序。指向元素的指针和引用不会失效。" #: :1652 #, safe-html, strict-same msgctxt ":1652" 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 "抛出：;; 如果抛出异常（除非是由容器的哈希函数或比较函数抛出），则该函数无效。" #: :1654 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1655 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "在以下任一条件成立时，推导指引将不参与重载决议：" #: :1657 #, 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` 模板参数，并且为该参数推导出的是符合分配器要求的类型。" #: :1662 #, 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` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1666 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "_iter-value-type_" #: :1674 #, safe-html, strict-same msgid "__iter-key-type__" msgstr "__iter-key-type__" #: :1682 #, safe-html, strict-same msgid "__iter-mapped-type__" msgstr "__iter-mapped-type__" #: :1690 #, safe-html, strict-same msgid "__iter-to-alloc-type__" msgstr "__iter-to-alloc-type__" #: :1699 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1701 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1702 #, safe-html, strict-same msgid "" "```c++ template " "bool operator==(const unordered_map& x, const " "unordered_map& y); ```" msgstr "" "```c++ template bool operator==(const unordered_map& x, const unordered_map& y); ```" #: :1708 #, safe-html, strict-same msgid "" "Return `true` if `x.size() == y.size()` and for every element in `x`, there " "is an element in `y` with the same key, with an equal value (using " "`operator==` to compare the value types)." msgstr "" "如果 `x.size() == y.size()` 并且对于 `x` 中的每个元素，在 `y` 中都有一个具有" "相同键且值相等的元素（使用 `operator==` 比较值类型），则返回 `true`。" #: :1711 #, safe-html, strict-same msgctxt ":1711" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "备注：;; 如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1713 #, safe-html, strict-same msgctxt ":1713" msgid "---" msgstr "---" #: :1715 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1716 #, safe-html, strict-same msgid "" "```c++ template " "bool operator!=(const unordered_map& x, const " "unordered_map& y); ```" msgstr "" "```c++ template bool operator!=(const unordered_map& x, const unordered_map& y); ```" #: :1722 #, safe-html, strict-same msgid "" "Return `false` if `x.size() == y.size()` and for every element in `x`, there " "is an element in `y` with the same key, with an equal value (using " "`operator==` to compare the value types)." msgstr "" "如果 `x.size() == y.size()` 并且对于 `x` 中的每个元素，在 `y` 中都有一个具有" "相同键且值相等的元素（使用 `operator==` 比较值类型），则返回 `false`。" #: :1725 #, safe-html, strict-same msgctxt ":1725" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "备注：;; 如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1727 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1728 #, safe-html, strict-same msgid "" "```c++ template " "void swap(unordered_map& x, unordered_map& y) noexcept(noexcept(x.swap(y))); ```" msgstr "" "```c++ template void swap(unordered_map& x, unordered_map& y) noexcept(noexcept(x.swap(y))); ```" #: :1735 #, safe-html, strict-same msgid "Swaps the contents of `x` and `y`." msgstr "交换 `x` 和 `y` 的内容。" #: :1737 #, safe-html, strict-same msgctxt ":1737" 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`，则交换两个容器的分" "配器。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1740 #, 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 标准不完全相同，因为相等谓词和哈希函数是通过它们的" "复制构造函数进行交换的。" #: :1744 #, safe-html, strict-same msgctxt ":1744" msgid "---" msgstr "---" #: :1746 #, safe-html, strict-same msgid "erase_if" msgstr "erase_if" #: :1747 #, safe-html, strict-same msgid "" "```c++ template typename unordered_map::size_type erase_if" "(unordered_map& c, Predicate pred); ```" msgstr "" "```c++ template typename unordered_map" "::size_type erase_if(unordered_map& " "c, Predicate pred); ```" #: :1753 #, safe-html, strict-same msgid "" "Traverses the container `c` and removes all elements for which the supplied " "predicate returns `true`." msgstr "遍历容器 `c` 并移除所有使给定谓词返回 `true` 的元素。" #: :1756 #, 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 "" "返回：;; 被移除的元素数量。备注：;; 等价于：```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();```注意，传递给 `pred` 的引用是非常量的。" #: :1773 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1775 #, safe-html, strict-same msgid "" "``unordered_map``s can be archived/retrieved by means of link:../../../../../" "serialization/index.html[Boost.Serialization^] using the API provided by " "this library. Both regular and XML archives are supported." msgstr "" "`unordered_map` 可以通过本库提供的 API，使用 link:../../../../../" "serialization/index.html[Boost.Serialization^] 进行归档/恢复。支持常规归档和 " "XML 归档。" #: :1779 #, safe-html, strict-same msgid "Saving an unordered_map to an archive" msgstr "将 unordered_map 保存到归档" #: :1781 #, safe-html, strict-same msgid "" "Saves all the elements of an `unordered_map` `x` to an archive (XML archive) " "`ar`." msgstr "将 `unordered_map` `x` 的所有元素保存到归档（XML 归档）`ar` 中。" #: :1784 #, safe-html, strict-same msgid "" "Requires:;; `std::remove_const::type` and " "`std::remove_const::type` are serializable (XML serializable), " "and they do support Boost.Serialization `save_construct_data`/" "`load_construct_data` protocol (automatically suported by https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^] types)." msgstr "" "要求：;; `std::remove_const::type` 和 " "`std::remove_const::type` 必须是可序列化的（支持 XML 序列化），" "并且它们支持 Boost.Serialization 的 `save_construct_data`/" "`load_construct_data` 协议（该协议由 https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[DefaultConstructible^] 类型的自动支持）。" #: :1790 #, safe-html, strict-same msgctxt ":1790" msgid "---" msgstr "---" #: :1792 #, safe-html, strict-same msgid "Loading an unordered_map from an archive" msgstr "从归档中加载 unordered_map" #: :1794 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of an `unordered_map` `x` and inserts from " "an archive (XML archive) `ar` restored copies of the elements of the " "original `unordered_map` `other` saved to the storage read by `ar`." msgstr "" "删除 `unordered_map` `x` 中所有已存在的元素，并从归档（XML 归档）`ar` 中插入" "由 `ar` 所读取存储中保存的原始 `unordered_map` `other` 元素的恢复副本。" #: :1799 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `" "(std::remove_const::type&&, std::remove_const::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::type&&, " "std::remove_const::type&&)` 进行 https://" "en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^]。`x.key_equal()` 在功能上等价于 " "`other.key_equal()`。\n" "注意：;; 如果归档是使用 Boost 1.84 之前的 Boost 版本保存的，则必须全局定义配" "置宏 `BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0` 才能使此操作成功" "；否则将抛出异常。" #: :1806 #, safe-html, strict-same msgctxt ":1806" msgid "---" msgstr "---" #: :1808 #, safe-html, strict-same msgid "Saving an iterator/const_iterator to an archive" msgstr "将迭代器/常量迭代器保存到归档中" #: :1810 #, safe-html, strict-same msgid "" "Saves the positional information of an `iterator` (`const_iterator`) `it` to " "an archive (XML archive) `ar`. `it` can be and `end()` iterator." msgstr "" "将 `iterator`（`const_iterator`）`it` 的位置信息保存到归档（XML 归档）`ar` 中" "。`it` 可以是 `end()` 迭代器。" #: :1814 #, safe-html, strict-same msgid "" "Requires:;; The `unordered_map` `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_map` `x` 此前已保存至 `ar`，并且在保存 `x` " "和保存 `it` 之间未对 `x` 执行任何修改操作。" #: :1818 #, safe-html, strict-same msgctxt ":1818" msgid "---" msgstr "---" #: :1820 #, safe-html, strict-same msgid "Loading an iterator/const_iterator from an archive" msgstr "从归档中加载迭代器/常量迭代器" #: :1822 #, safe-html, strict-same msgid "" "Makes an `iterator` (`const_iterator`) `it` point to the restored position " "of the original `iterator` (`const_iterator`) saved to the storage read by " "an archive (XML archive) `ar`." msgstr "" "使 `iterator`（`const_iterator`）`it` 指向保存到由归档（XML 归档）`ar` 读取的" "存储中的原始 `iterator`（`const_iterator`）的被恢复位置。" #: :1827 #, safe-html, strict-same msgid "" "Requires:;; If `x` is the `unordered_map` `it` points to, no modifying " "operations have been issued on `x` between loading of `x` and loading of " "`it`." msgstr "" "要求：;; 如果 `x` 是 `it` 所指向的 `unordered_map`，则在加载 `x` 和加载 `it` " "之间未对 `x` 执行任何修改操作。"