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 03:13+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_flat_map" msgstr "类模板 unordered++_++flat++_++map" #: :4 #, safe-html, strict-same msgid ":idprefix: unordered_flat_map_" msgstr ":idprefix: unordered_flat_map_" #: :6 #, safe-html, strict-same msgid "" "`boost::unordered_flat_map` — An open-addressing unordered associative " "container that associates unique keys with another value." msgstr "" "`boost::unordered++_++flat++_++map` —— 一种开放寻址的无序关联容器，用于将唯一" "键与另一个值关联。" #: :8 #, safe-html, strict-same msgid "" "The performance of `boost::unordered_flat_map` is much better than that of " "`boost::unordered_map` or other implementations of `std::unordered_map`. " "Unlike standard unordered associative containers, which are node-based, the " "elements of a `boost::unordered_flat_map` are held directly in the bucket " "array, and insertions into an already occupied bucket are diverted to " "available buckets in the vicinity of the original position. This type of " "data layout is known as _open addressing_." msgstr "" "`boost::unordered++_++flat++_++map` 的性能远优于 `boost::unordered++_++map` " "或其他 `std::unordered++_++map` 的实现。与基于节点的标准无序关联容器不同， " "`boost::unordered++_++flat++_++map` 的元素直接存储在桶数组中，且当元素被插入" "到已被占用的桶时，会将其重定向到原始位置附近的可用桶。这种数据布局类型称" "为__开放寻址法__。" #: :14 #, safe-html, strict-same msgid "" "As a result of its using open addressing, the interface of " "`boost::unordered_flat_map` deviates in a number of aspects from that of " "`boost::unordered_map`/`std::unordered_map`:" msgstr "" "由于采用开放寻址法， `boost::unordered++_++flat++_++map` 的接口在多个方面与 " "`boost::unordered++_++map` / `std::unordered++_++map` 不同：" #: :17 #, safe-html, strict-same msgid "" "- `value_type` must be move-constructible. - Pointer stability is not kept " "under rehashing. - `begin()` is not constant-time. - There is no API for " "bucket handling (except `bucket_count`) or node extraction/insertion. - The " "maximum load factor of the container is managed internally and can't be set " "by the user." msgstr "" "- `value++_++type` 必须支持移动构造。 - 在重哈希的过程中，指针稳定性无法保持" "。 - `begin()` 不是常数时间复杂度操作。 - 未提供用于桶管理（除 " "`bucket++_++count` 外）或节点提取/插入的 API。 - 容器的最大负载因子由内部管理" "，用户无法进行设置。" #: :23 #, safe-html, strict-same msgid "" "Other than this, `boost::unordered_flat_map` is mostly a drop-in replacement " "of node-based standard unordered associative containers." msgstr "" "除此之外， `boost::unordered++_++flat++_++map` 基本可完全替代基于节点的标准无" "序关联容器。" #: :26 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :282 #, safe-html, strict-same msgctxt ":282" msgid "---" msgstr "---" #: :284 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :286 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :289 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :293 #, safe-html, strict-same msgid "" "`std::pair` must be https://en.cppreference.com/w/cpp/" "named_req/EmplaceConstructible[EmplaceConstructible^] into the container " "from any `std::pair` object convertible to it, and it also must be https://" "en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the container." msgstr "" "`std::pair` 必须能从任何可转换为它的 `std::pair` 对象" "满足对容器的 https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[可原位构造^] 要求，并且还必须满足对容器的 https://" "en.cppreference.com/w/cpp/named_req/Erasable[可擦除^] 要求。" #: :297 #, safe-html, strict-same msgid "_T_" msgstr "_T_" #: :297 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :297 #, 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` 类型的值。" #: :297 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :297 #, safe-html, strict-same msgid "" "A binary function object that induces an equivalence relation on values of " "type `Key`. It takes two arguments of type `Key` and returns a value of type " "`bool`." msgstr "" "一个二元函数对象，在 `Key` 类型的值上诱导出等价关系。它接受两个 `Key` 类型的" "参数并返回 `bool` 类型的值。" #: :297 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :297 #, safe-html, strict-same msgid "" "An allocator whose value type is the same as the container's value type." msgstr "一个分配器，其值类型与容器的值类型相同。" #: :307 #, 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[花式指针^] 的分配器。" #: :311 #, safe-html, strict-same msgid "" "The elements of the container are held into an internal _bucket array_. An " "element is inserted into a bucket determined by its hash code, but if the " "bucket is already occupied (a _collision_), an available one in the vicinity " "of the original position is used." msgstr "" "容器的元素存储在内部的__桶数组__中。元素根据其哈希码被插入到对应的桶中，但如" "果该桶已被占用（即发生__冲突__），则会使用原始位置附近可用的桶。" #: :315 #, safe-html, strict-same msgid "" "The size of the bucket array can be automatically increased by a call to " "`insert`/`emplace`, or as a result of calling `rehash`/`reserve`. The _load " "factor_ of the container (number of elements divided by number of buckets) " "is never greater than `max_load_factor()`, except possibly for small sizes " "where the implementation may decide to allow for higher loads." msgstr "" "桶数组的大小可通过调用 `insert` / `emplace` 自动增加，也可通过调用 " "`rehash` / `reserve` 来调整。容器的__负载因子__（元素数量与桶数量的比值）始终" "不会超过 `max++_++load++_++factor()` ，但在小规模数据情况下，实现可能允许更高" "的负载因子。" #: :320 #, safe-html, strict-same msgid "" "If `link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]::value` is " "`true`, the hash function is used as-is; otherwise, a bit-mixing post-" "processing stage is added to increase the quality of hashing at the expense " "of extra computational cost." msgstr "" "若 link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanchinghash[`hash++_++is++_++avalanching`]`++<++Hash++>++::value` " "为 `true` ，则直接使用哈希函数；否则，会添加一个位混合后处理阶段以提高哈希质" "量，但会牺牲额外的计算成本。" #: :324 #, safe-html, strict-same msgctxt ":324" msgid "---" msgstr "" "若 link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanchinghash[`hash++_++is++_++avalanching`]`++<++Hash++>++::value` " "为 `true` ，则直接使用哈希函数；否则，会添加一个位混合后处理阶段以提高哈希质" "量，但会牺牲额外的计算成本。" #: :326 #, safe-html, strict-same msgid "Configuration Macros" msgstr "配置宏" #: :328 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_STATS`" msgstr "`BOOST++_++UNORDERED++_++ENABLE++_++STATS`" #: :330 #, safe-html, strict-same msgid "" "Globally define this macro to enable xref:reference/" "stats.adoc#stats[statistics calculation] for the container. Note that this " "option decreases the overall performance of many operations." msgstr "" "全局定义此宏，以启用容器的 xref:reference/stats.adoc#stats[统计计算] 功能。请" "注意，此选项会降低许多操作的总体性能。" #: :333 #, safe-html, strict-same msgctxt ":333" msgid "---" msgstr "---" #: :335 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :342 #, safe-html, strict-same msgid "An iterator whose value type is `value_type`." msgstr "一种迭代器，其值类型为 `value++_++type` 。" #: :344 #, safe-html, strict-same msgctxt ":344" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :346 #, safe-html, strict-same msgid "Convertible to `const_iterator`." msgstr "可转换为 `const++_++iterator` 。" #: :348 #, safe-html, strict-same msgctxt ":348" msgid "---" msgstr "---" #: :355 #, safe-html, strict-same msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value++_++type` 。" #: :357 #, safe-html, strict-same msgctxt ":357" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :359 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :361 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :362 #, safe-html, strict-same msgid "```c++ unordered_flat_map(); ```" msgstr "```c++ unordered_flat_map(); ```" #: :366 #, safe-html, strict-same msgid "" "Constructs an empty container using `hasher()` as the hash function, " "`key_equal()` as the key equality predicate and `allocator_type()` as the " "allocator." msgstr "" "构造一个空容器，使用 `hasher()` 作为哈希函数、 `key++_++equal()` 作为键相等性" "谓词、以及 `allocator++_++type()` 作为分配器。" #: :370 #, safe-html, strict-same msgctxt ":370" msgid "" "Postconditions:;; `size() == 0` Requires:;; If the defaults are used, " "`hasher`, `key_equal` and `allocator_type` need to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` 要求：若使用默认参数，则 `hasher`、`key_equal` 和 " "`allocator_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[可默认构造^] 要求。" #: :373 #, safe-html, strict-same msgctxt ":373" msgid "---" msgstr "---" #: :375 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :376 #, safe-html, strict-same msgid "" "```c++ explicit unordered_flat_map(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = allocator_type" "()); ```" msgstr "" "```c++ explicit unordered_flat_map(size_type n, const hasher& hf = hasher" "(), const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" #: :383 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, `eql` as the key equality predicate, and `a` as the allocator." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、以及 `a` 作为分配器。" #: :387 #, safe-html, strict-same msgctxt ":387" msgid "" "Postconditions:;; `size() == 0` Requires:;; If the defaults are used, " "`hasher`, `key_equal` and `allocator_type` need to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` 要求：若使用默认参数，则 `hasher`、`key_equal` 和 " "`allocator_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[可默认构造^] 要求。" #: :390 #, safe-html, strict-same msgctxt ":390" msgid "---" msgstr "---" #: :392 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :403 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, `eql` as the key equality predicate and `a` as the allocator, " "and inserts the elements from `[f, l)` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、 `a` 作为分配器，并将区间 `++[++f, l)` 中的元素插入其中。" #: :406 #, safe-html, strict-same msgctxt ":406" 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[可默" "认构造] 要求。" #: :408 #, safe-html, strict-same msgctxt ":408" msgid "---" msgstr "---" #: :410 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :411 #, safe-html, strict-same msgid "```c++ unordered_flat_map(unordered_flat_map const& other); ```" msgstr "```c++ unordered_flat_map(unordered_flat_map const& other); ```" #: :415 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate and allocator." msgstr "复制构造函数。复制所含元素、哈希函数、谓词和分配器。" #: :417 #, 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` 存在且" "签名正确，则将根据其结果来构造分配器。" #: :420 #, safe-html, strict-same msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：`value_type` 需满足可复制构造要求。" #: :422 #, safe-html, strict-same msgctxt ":422" msgid "---" msgstr "---" #: :424 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :425 #, safe-html, strict-same msgid "```c++ unordered_flat_map(unordered_flat_map&& other); ```" msgstr "```c++ unordered_flat_map(unordered_flat_map&& other); ```" #: :429 #, safe-html, strict-same msgid "" "The move constructor. The internal bucket array of `other` is transferred " "directly to the new container. The hash function, predicate and allocator " "are moved-constructed from `other`. If statistics are " "xref:unordered_flat_map_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "移动构造函数。`other` 的内部桶数组直接转移到新容器中。哈希函数、谓词和分配器" "通过移动构造从 `other` 获得。若统计功能已启用（参见 " "xref:unordered_flat_map_boost_unordered_enable_stats[相关说明]），则转移 " "`other` 的内部统计信息并调用 `other.reset_stats()`。" #: :434 #, safe-html, strict-same msgctxt ":434" msgid "---" msgstr "---" #: :436 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器范围构造函数" #: :437 #, safe-html, strict-same msgid "" "```c++ template unordered_flat_map(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template unordered_flat_map(InputIterator " "f, InputIterator l, const allocator_type& a); ```" #: :442 #, safe-html, strict-same msgid "" "Constructs an empty container using `a` as the allocator, with the default " "hash function and key equality predicate and inserts the elements from `[f, " "l)` into it." msgstr "" "使用 `a` 作为分配器构造一个空容器，使用默认的哈希函数和键相等谓词，并将 `[f, " "l)` 中的元素插入其中。" #: :445 #, safe-html, strict-same msgctxt ":445" 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[可默认构造^] 要求。" #: :447 #, safe-html, strict-same msgctxt ":447" msgid "---" msgstr "---" #: :449 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :450 #, safe-html, strict-same msgid "```c++ explicit unordered_flat_map(Allocator const& a); ```" msgstr "```c++ explicit unordered_flat_map(Allocator const& a); ```" #: :454 #, safe-html, strict-same msgid "Constructs an empty container, using allocator `a`." msgstr "使用分配器 a 构造一个空容器。" #: :456 #, safe-html, strict-same msgctxt ":456" msgid "---" msgstr "---" #: :458 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :459 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(unordered_flat_map const& other, Allocator const& " "a); ```" msgstr "" "```c++ unordered_flat_map(unordered_flat_map const& other, Allocator " "const& a); ```" #: :463 #, safe-html, strict-same msgid "" "Constructs a container, copying ``other``'s contained elements, hash " "function, and predicate, but using allocator `a`." msgstr "构造一个容器，复制 `other` 所包含的元素、哈希函数和谓词，但使用分配器 `a`。" #: :465 #, safe-html, strict-same msgctxt ":465" msgid "---" msgstr "---" #: :467 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :468 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(unordered_flat_map&& other, Allocator const& a); " "```" msgstr "" "```c++ unordered_flat_map(unordered_flat_map&& other, Allocator " "const& a); ```" #: :472 #, safe-html, strict-same msgid "" "If `a == other.get_allocator()`, the elements of `other` are transferred " "directly to the new container; otherwise, elements are moved-constructed " "from those of `other`. The hash function and predicate are moved-constructed " "from `other`, and the allocator is copy-constructed from `a`. If statistics " "are xref:unordered_flat_map_boost_unordered_enable_stats[enabled], transfers " "the internal statistical information from `other` iff `a == " "other.get_allocator()`, and always calls `other.reset_stats()`." msgstr "" "若 `a == other.get_allocator()`，则 `other` 的元素直接转移到新容器中；否则，" "将通过移动构造从 `other` 的元素创建新元素。哈希函数和谓词通过移动构造从 " "`other` 获得，分配器则通过复制构造从 `a` 获得。若统计功能已启用（参见 " "xref:unordered_flat_map_boost_unordered_enable_stats[相关说明]），则仅当 `a " "== other.get_allocator()` 时转移 `other` 的内部统计信息，且始终会调用 " "`other.reset_stats()`。" #: :479 #, safe-html, strict-same msgctxt ":479" msgid "---" msgstr "---" #: :481 #, safe-html, strict-same msgid "Move Constructor from concurrent_flat_map" msgstr "从 concurrent++_++flat++_++map 的移动构造函数" #: :483 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(concurrent_flat_map" "&& other); ```" msgstr "" "```c++ unordered_flat_map(concurrent_flat_map&& other); ```" #: :487 #, safe-html, strict-same msgid "" "Move construction from a xref:#concurrent_flat_map[`concurrent_flat_map`]. " "The internal bucket array of `other` is transferred directly to the new " "container. The hash function, predicate and allocator are moved-constructed " "from `other`. If statistics are " "xref:unordered_flat_map_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "从 " "xref:#concurrent_flat_map[`concurrent_flat_map`][`concurrent++_++flat++_++map`] " "移动构造。 `other` 的内部桶数组直接转移至新容器。哈希函数、谓词和分配器均从 " "`other` 移动构造。若统计功能 " "xref:#unordered_flat_map_boost_unordered_enable_stats[已启用] ，则转移 " "`other` 的内部统计信息，并调用 `other.reset++_++stats()` 。" #: :494 #, safe-html, strict-same msgid "Complexity:;; Constant time. Concurrency:;; Blocking on `other`." msgstr "复杂度：常数时间。并发：阻塞 `other`。" #: :497 #, safe-html, strict-same msgctxt ":497" msgid "---" msgstr "---" #: :499 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :509 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, `eql` as the key equality predicate and `a`, and inserts the " "elements from `il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `eql` 作为键相等" "性谓词、以及 `a` 作为分配器，并将 `il` 中的元素插入其中。" #: :512 #, safe-html, strict-same msgctxt ":512" 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[可默" "认构造] 要求。" #: :514 #, safe-html, strict-same msgctxt ":514" msgid "---" msgstr "---" #: :516 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :517 #, safe-html, strict-same msgid "```c++ unordered_flat_map(size_type n, allocator_type const& a); ```" msgstr "" "```c++ unordered_flat_map(size_type n, allocator_type const& a); ```" #: :521 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, the default hash function and key equality predicate and `a` " "as the allocator." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，使用默认的键相等谓" "词，以及 `a` 作为分配器。" #: :524 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to " "be https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` 要求：`hasher` 和 `key_equal` 需满足 https://" "en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构造^] 要求。" #: :527 #, safe-html, strict-same msgctxt ":527" msgid "---" msgstr "---" #: :529 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :530 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" msgstr "" "```c++ unordered_flat_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :534 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, the default key equality predicate and `a` as the allocator." msgstr "" "unordered_flat_map(size_type n, hasher const& hf, allocator_type " "const& a);" #: :537 #, 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[可默认构造^] 要求。" #: :540 #, safe-html, strict-same msgctxt ":540" msgid "---" msgstr "---" #: :542 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :549 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` as the " "allocator and default hash function and key equality predicate, and inserts " "the elements from `[f, l)` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器、以及默认的哈希函数和" "键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。" #: :552 #, safe-html, strict-same msgctxt ":552" 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[可默认构造] 要求。" #: :554 #, safe-html, strict-same msgctxt ":554" msgid "---" msgstr "---" #: :556 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :564 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, `a` as the allocator, with the default key equality " "predicate, and inserts the elements from `[f, l)` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、 `a` 作为分配器以" "及默认的键相等性谓词，并将 `++[++f, l)` 范围内的元素插入其中。" #: :567 #, safe-html, strict-same msgctxt ":567" 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[可默认构造] 要求。" #: :569 #, safe-html, strict-same msgctxt ":569" msgid "---" msgstr "---" #: :571 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :573 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ unordered_flat_map(std::initializer_list il, const " "allocator_type& a); ```" #: :577 #, safe-html, strict-same msgid "" "Constructs an empty container using `a` and default hash function and key " "equality predicate, and inserts the elements from `il` into it." msgstr "" "构造一个空容器，使用 `a` 作为分配器、以及默认的哈希函数和键相等性谓词，并将 " "`il` 中的元素插入其中。" #: :580 #, safe-html, strict-same msgctxt ":580" msgid "" "Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/" "w/cpp/named_req/DefaultConstructible[DefaultConstructible^]." msgstr "" "要求：`hasher` 和 `key_equal` 需满足 https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[可默认构造^] 要求。" #: :582 #, safe-html, strict-same msgctxt ":582" msgid "---" msgstr "---" #: :584 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :586 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(std::initializer_list il, size_type n, " "const allocator_type& a); ```" msgstr "" "```c++ unordered_flat_map(std::initializer_list il, size_type n, " "const allocator_type& a); ```" #: :590 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` and " "default hash function and key equality predicate, and inserts the elements " "from `il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 作为分配器以及默认的哈希函数和键" "相等谓词，并将 `il` 中的元素插入其中。" #: :593 #, safe-html, strict-same msgctxt ":593" 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[可默认构造^] 要求。" #: :595 #, safe-html, strict-same msgctxt ":595" msgid "---" msgstr "---" #: :597 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :599 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ unordered_flat_map(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" #: :604 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, `a` as the allocator and default key equality predicate,and " "inserts the elements from `il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数、`a` 作为分配器以及" "默认的键相等谓词，并将 `il` 中的元素插入其中。" #: :607 #, safe-html, strict-same msgctxt ":607" 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[可默认构造^] 要求。" #: :609 #, safe-html, strict-same msgctxt ":609" msgid "---" msgstr "---" #: :611 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :613 #, safe-html, strict-same msgid "```c++ ~unordered_flat_map(); ```" msgstr "```c++ ~unordered_flat_map(); ```" #: :618 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：析构函数会应用于每个元素，并且所有内存都会被释放。" #: :620 #, safe-html, strict-same msgctxt ":620" msgid "---" msgstr "---" #: :622 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :624 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :626 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map& operator=(unordered_flat_map const& other); ```" msgstr "" "```c++ unordered_flat_map& operator=(unordered_flat_map const& other)" "; ```" #: :630 #, safe-html, strict-same msgid "" "The assignment operator. Destroys previously existing elements, copy-assigns " "the hash function and predicate from `other`, copy-assigns the allocator " "from `other` if `Alloc::propagate_on_container_copy_assignment` exists and " "`Alloc::propagate_on_container_copy_assignment::value` is `true`, and " "finally inserts copies of the elements of `other`." msgstr "" "赋值操作符。该操作会销毁容器中原有的元素，并从 other 复制赋值哈希函数与键相等" "性谓词。若 Alloc::propagate_on_container_copy_assignment 存在，且 " "Alloc::propagate_on_container_copy_assignment::value 为 true，则从 other 复制" "赋值分配器，最后插入 other 中所有元素的副本。" #: :635 #, safe-html, strict-same msgctxt ":635" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]" msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。" #: :637 #, safe-html, strict-same msgctxt ":637" msgid "---" msgstr "---" #: :639 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :640 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map& operator=(unordered_flat_map&& other) noexcept(" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && std::is_same::value); ``` The move assignment operator. Destroys previously " "existing elements, swaps the hash function and predicate from `other`, and " "move-assigns the allocator from `other` if " "`Alloc::propagate_on_container_move_assignment` exists and " "`Alloc::propagate_on_container_move_assignment::value` is `true`. If at this " "point the allocator is equal to `other.get_allocator()`, the internal bucket " "array of `other` is transferred directly to the new container; otherwise, " "inserts move-constructed copies of the elements of `other`. If statistics " "are xref:unordered_flat_map_boost_unordered_enable_stats[enabled], transfers " "the internal statistical information from `other` iff the final allocator is " "equal to `other.get_allocator()`, and always calls `other.reset_stats()`." msgstr "" "```c++ unordered_flat_map& operator=(unordered_flat_map&& other) " "noexcept((boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && " "std::is_same::value); ``` 移动赋值运算符。销毁之前" "存在的元素，交换 other 中的哈希函数和谓词，若 " "Alloc::propagate_on_container_move_assignment 存在且 " "Alloc::propagate_on_container_move_assignment::value 为 true，则从 other 移动" "赋值分配器。若此时分配器与 other.get_allocator() 相等，则将 other 的内部桶数" "组直接转移至当前容器；否则，插入通过移动构造从 other 元素创建的副本。若统计功" "能已启用（参见 xref:unordered_flat_map_boost_unordered_enable_stats[相关说" "明]），则仅当最终分配器与 other.get_allocator() 相等时转移 other 的内部统计信" "息，且始终会调用 other.reset_stats()。" #: :654 #, safe-html, strict-same msgctxt ":654" msgid "---" msgstr "---" #: :656 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :657 #, safe-html, strict-same msgid "" "```c++ unordered_flat_map& operator=(std::initializer_list il); " "```" msgstr "" "```c++ unordered_flat_map& operator=(std::initializer_list " "il); ```" #: :661 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All previously existing elements are " "destroyed." msgstr "从初始化列表中的值进行赋值。所有之前存在的元素均被销毁。" #: :664 #, safe-html, strict-same msgctxt ":664" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]" msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。" #: :666 #, safe-html, strict-same msgid "Iterators" msgstr "迭代器" #: :668 #, safe-html, strict-same msgid "begin" msgstr "begin" #: :669 #, safe-html, strict-same msgid "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" msgstr "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" #: :675 #, safe-html, strict-same msgid "" "Returns:;; An iterator referring to the first element of the container, or " "if the container is empty the past-the-end value for the container. " "Complexity:;; O(`bucket_count()`)" msgstr "" "返回：指向容器第一个元素的迭代器，若容器为空则返回容器尾后迭代器。复杂度：O" "(`bucket_count()`)" #: :678 #, safe-html, strict-same msgctxt ":678" msgid "---" msgstr "---" #: :680 #, safe-html, strict-same msgid "end" msgstr "end" #: :681 #, safe-html, strict-same msgid "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" msgstr "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" #: :687 #, safe-html, strict-same msgid "" "Returns:;; An iterator which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后位置的迭代器。" #: :689 #, safe-html, strict-same msgctxt ":689" msgid "---" msgstr "---" #: :691 #, safe-html, strict-same msgid "cbegin" msgstr "cbegin" #: :692 #, safe-html, strict-same msgid "```c++ const_iterator cbegin() const noexcept; ```" msgstr "```c++ const_iterator cbegin() const noexcept; ```" #: :697 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` referring to the first element of the " "container, or if the container is empty the past-the-end value for the " "container. Complexity:;; O(`bucket_count()`)" msgstr "" "返回：指向容器第一个元素的 `const_iterator`，若容器为空，则返回容器尾后迭代器" "。复杂度：O(`bucket_count()`)" #: :700 #, safe-html, strict-same msgctxt ":700" msgid "---" msgstr "---" #: :702 #, safe-html, strict-same msgid "cend" msgstr "cend" #: :703 #, safe-html, strict-same msgid "```c++ const_iterator cend() const noexcept; ```" msgstr "```c++ const_iterator cend() const noexcept; ```" #: :708 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后位置的 `const_iterator`。" #: :710 #, safe-html, strict-same msgctxt ":710" msgid "---" msgstr "---" #: :712 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :714 #, safe-html, strict-same msgid "empty" msgstr "空" #: :716 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :721 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "返回: `size() == 0`" #: :723 #, safe-html, strict-same msgctxt ":723" msgid "---" msgstr "---" #: :725 #, safe-html, strict-same msgid "size" msgstr "大小" #: :727 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :732 #, safe-html, strict-same msgid "Returns:;; `std::distance(begin(), end())`" msgstr "返回：`std::distance(begin(), end())`" #: :734 #, safe-html, strict-same msgctxt ":734" msgid "---" msgstr "---" #: :736 #, safe-html, strict-same msgid "max_size" msgstr "max++_++size" #: :738 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :743 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible container." msgstr "返回：可能的最大容器的 `size()`。" #: :745 #, safe-html, strict-same msgctxt ":745" msgid "---" msgstr "---" #: :747 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :749 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :750 #, safe-html, strict-same msgid "" "```c++ template std::pair emplace(Args&&... " "args); ```" msgstr "" "```c++ template std::pair emplace" "(Args&&... args); ```" #: :754 #, safe-html, strict-same msgctxt ":754" 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` 构造的对象。" #: :757 #, safe-html, strict-same msgctxt ":757" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, pointers and " "references, but only if the insert causes the load to be greater than the " "maximum load. + + 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." msgstr "" "要求：`value_type` 可从 `args` 构造。返回：若执行了插入，则返回类型中的 " "`bool` 分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价" "的元素。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使" "迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会发生。+ +若 " "`args...` 的形式为 `k,v`，则仅在确定应插入元素时才构造整个对象，检查时仅使用 " "`k` 参数。" #: :766 #, safe-html, strict-same msgctxt ":766" msgid "---" msgstr "---" #: :768 #, safe-html, strict-same msgid "emplace_hint" msgstr "emplace++_++hint" #: :769 #, 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); ```" #: :773 #, safe-html, strict-same msgctxt ":773" 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` 构造的对象。" #: :775 #, safe-html, strict-same msgid "" "`position` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`position` 是一个关于元素应插入位置的建议。此实现会忽略该建议。" #: :778 #, safe-html, strict-same msgctxt ":778" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, pointers and " "references, but only if the insert causes the load to be greater than the " "maximum load. + + 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." msgstr "" "要求：`value_type` 可从 `args` 构造。返回：若执行了插入，则返回类型中的 " "`bool` 分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价" "的元素。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使" "迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会发生。+ +若 " "`args...` 的形式为 `k,v`，则仅在确定应插入元素时才构造整个对象，检查时仅使用 " "`k` 参数。" #: :787 #, safe-html, strict-same msgctxt ":787" msgid "---" msgstr "---" #: :789 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :790 #, safe-html, strict-same msgid "" "```c++ std::pair insert(const value_type& obj); " "std::pair insert(const init_type& obj); ```" msgstr "" "```c++ std::pair insert(const value_type& obj); " "std::pair insert(const init_type& obj); ```" #: :795 #, safe-html, strict-same msgctxt ":795" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有等价的键时，将 `obj` 插入容器。" #: :798 #, 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, pointers and references, but only if the " "insert causes the load to be greater than the maximum load. + + A call of " "the form `insert(x)`, where `x` is equally convertible to both `const " "value_type&` and `const init_type&`, is not ambiguous and selects the " "`init_type` overload." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。返回：若执行了插入，则返回类型中的 `bool` " "分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素" "。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使迭代器" "、指针和引用失效，但仅当插入导致负载大于最大负载时才会发生。+ +形式为 `insert" "(x)` 的调用（其中 `x` 可同等转换为 `const value_type&` 和 `const " "init_type&`）不会产生歧义，并且会选择 `init_type` 重载。" #: :807 #, safe-html, strict-same msgctxt ":807" msgid "---" msgstr "---" #: :809 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :810 #, safe-html, strict-same msgid "" "```c++ std::pair insert(value_type&& obj); " "std::pair insert(init_type&& obj); ```" msgstr "" "```c++ std::pair insert(value_type&& obj); " "std::pair insert(init_type&& obj); ```" #: :815 #, safe-html, strict-same msgctxt ":815" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有等价的键时，将 `obj` 插入容器。" #: :818 #, 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, pointers and references, but only if the " "insert causes the load to be greater than the maximum load. + + A call of " "the form `insert(x)`, where `x` is equally convertible to both " "`value_type&&` and `init_type&&`, is not ambiguous and selects the " "`init_type` overload." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^] 要求。返回：若执行了插入，则返回类型中的 `bool` " "分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素" "。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使迭代器" "、指针和引用失效，但仅当插入导致负载大于最大负载时才会发生。+ +形式为 `insert" "(x)` 的调用（其中 `x` 可同等转换为 `value_type&&` 和 " "`init_type&&`）不会产生歧义，并且会选择 `init_type` 重载。" #: :827 #, safe-html, strict-same msgctxt ":827" msgid "---" msgstr "---" #: :829 #, safe-html, strict-same msgid "Copy Insert with Hint" msgstr "带提示的复制插入" #: :830 #, safe-html, strict-same msgid "" "```c++ iterator insert(const_iterator hint, const value_type& obj); iterator " "insert(const_iterator hint, const init_type& obj); ``` Inserts `obj` in the " "container if and only if there is no element in the container with an " "equivalent key." msgstr "" "`iterator insert(const_iterator hint, const value_type& obj); iterator " "insert(const_iterator hint, const init_type& obj);` 当且仅当容器中没有等" "价的键时，将 `obj` 插入容器。" #: :836 #, safe-html, strict-same msgctxt ":836" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是一个关于元素插入位置的提示，本实现将忽略该提示。" #: :839 #, 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, pointers and references, but only if the " "insert causes the load to be greater than the maximum load. + + A call of " "the form `insert(hint, x)`, where `x` is equally convertible to both `const " "value_type&` and `const init_type&`, is not ambiguous and selects the " "`init_type` overload." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[可复制插入^] 要求。返回：若执行了插入，则返回类型中的 `bool` " "分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素" "。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使迭代器" "、指针和引用失效，但仅当插入导致负载大于最大负载时才会发生。+ +形式为 `insert" "(hint, x)` 的调用（其中 `x` 可同等转换为 `const value_type&` 和 `const " "init_type&`）不会产生歧义，并且会选择 `init_type` 重载。" #: :848 #, safe-html, strict-same msgctxt ":848" msgid "---" msgstr "---" #: :850 #, safe-html, strict-same msgid "Move Insert with Hint" msgstr "带提示的移动插入" #: :851 #, safe-html, strict-same msgid "" "```c++ iterator insert(const_iterator hint, value_type&& obj); iterator " "insert(const_iterator hint, init_type&& obj); ```" msgstr "" "```c++ iterator insert(const_iterator hint, value_type&& obj); " "iterator insert(const_iterator hint, init_type&& obj); ```" #: :856 #, safe-html, strict-same msgctxt ":856" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中不存在等价键时，将 `obj` 对象插入到容器中。" #: :858 #, safe-html, strict-same msgctxt ":858" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是一个关于元素应插入位置的建议。此实现会忽略该建议。" #: :861 #, 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, pointers and references, but only if the " "insert causes the load to be greater than the maximum load. + + A call of " "the form `insert(hint, x)`, where `x` is equally convertible to both " "`value_type&&` and `init_type&&`, is not ambiguous and selects the " "`init_type` overload." msgstr "" "要求：`value_type` 需满足 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[可移动插入^] 要求。返回：若执行了插入，则返回类型中的 `bool` " "分量为 `true`。+ +若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素" "。抛出：若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使迭代器" "、指针和引用失效，但仅当插入导致负载大于最大负载时才会发生。+ +形式为 `insert" "(hint, x)` 的调用（其中 `x` 可同等转换为 `value_type&&` 和 " "`init_type&&`）不会产生歧义，并且会选择 `init_type` 重载。" #: :870 #, safe-html, strict-same msgctxt ":870" msgid "---" msgstr "---" #: :872 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :873 #, safe-html, strict-same msgid "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" #: :877 #, safe-html, strict-same msgctxt ":877" 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 "将元素范围插入容器中。仅当容器中不存在等价键的元素时，才会插入相应元素。" #: :880 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into the container from " "`*first`. Throws:;; When inserting a single element, if an exception is " "thrown by an operation other than a call to `hasher` the function has no " "effect. Notes:;; Can invalidate iterators, pointers and references, but only " "if the insert causes the load to be greater than the maximum load." msgstr "" "要求：`value_type` 需从 `*first` 处满足对容器的 https://en.cppreference.com/" "w/cpp/named_req/EmplaceConstructible[可原位构造^] 要求。抛出：当插入单个元素" "时，若调用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能使迭代器、指" "针和引用失效，但仅当插入导致负载大于最大负载时才会发生。" #: :884 #, safe-html, strict-same msgctxt ":884" msgid "---" msgstr "---" #: :886 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :887 #, safe-html, strict-same msgid "```c++ void insert(std::initializer_list); ```" msgstr "```c++ void insert(std::initializer_list); ```" #: :891 #, safe-html, strict-same msgctxt ":891" 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 "将范围内的元素插入容器中。当且仅当容器中没有等价的键时，才会插入元素。" #: :894 #, 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, pointers and references, but only if the insert causes the load " "to be greater than the maximum load." msgstr "" "要求：`value_type` 需满足对容器而言的 https://en.cppreference.com/w/cpp/" "named_req/CopyInsertable[可复制插入^] 要求。抛出：当插入单个元素时，若调用 " "`hasher` 以外的操作抛出异常，则函数无效果。注意：可能使迭代器、指针和引用失效" "，但仅当插入导致负载大于最大负载时才会发生。" #: :898 #, safe-html, strict-same msgctxt ":898" msgid "---" msgstr "---" #: :900 #, safe-html, strict-same msgid "try_emplace" msgstr "try++_++emplace" #: :901 #, 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); ```" "" #: :910 #, safe-html, strict-same msgctxt ":910" msgid "" "Inserts a new element into the container if there is no existing element " "with key `k` contained within it." msgstr "如果容器中不存在键为 `k` 的元素，则向容器中插入一个新元素。" #: :912 #, safe-html, strict-same msgctxt ":912" msgid "" "If there is an existing element with key `k` this function does nothing." msgstr "若容器中不存在键为 `k` 的元素，则插入一个新元素。" #: :915 #, 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_flat_map_emplace[emplace], with the difference that no " "`value_type` is constructed if there is an element with an equivalent key; " "otherwise, the construction is of the form: + + -- ```c++" msgstr "" "返回：若执行了插入，则返回类型中的 `bool` 分量为 `true`。+ +若执行了插入，则" "迭代器指向新插入的元素；否则指向等价的元素。抛出：若调用 `hasher` 以外的操作" "抛出异常，则函数无效果。注意：此函数与 " "xref:#unordered_flat_map_emplace[emplace] 类似，区别在于：若存在等价的键，则" "不构造 `value_type`；否则，构造形式如下：+ + -- `c++`" #: :925 #, safe-html, strict-same msgctxt ":925" 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)...))" #: :930 #, safe-html, strict-same msgctxt ":930" 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)...)) ```" #: :935 #, safe-html, strict-same msgid "" "unlike xref:#unordered_flat_map_emplace[emplace], which simply forwards all " "arguments to ``value_type``'s constructor." msgstr "" "与 xref:#unordered_flat_map_emplace[emplace] 不同，后者只是将所有参数转发给 " "`value_type` 的构造函数。" #: :937 #, safe-html, strict-same msgctxt ":937" msgid "" "Can invalidate iterators pointers and references, but only if the insert " "causes the load to be greater than the maximum load." msgstr "" "可能会导致迭代器、指针和引用失效，但仅当插入操作导致负载因子超过最大负载因子" "时才会发生。" #: :939 #, safe-html, strict-same msgctxt ":939" 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` 类型对象的开销。" #: :941 #, safe-html, strict-same msgctxt ":941" msgid "--" msgstr "--" #: :943 #, safe-html, strict-same msgctxt ":943" msgid "---" msgstr "---" #: :945 #, safe-html, strict-same msgid "try_emplace with Hint" msgstr "带提示的 try++_++emplace" #: :946 #, 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); ```" #: :955 #, safe-html, strict-same msgctxt ":955" msgid "" "Inserts a new element into the container if there is no existing element " "with key `k` contained within it." msgstr "如果容器中不存在键为 `k` 的元素，则向容器中插入一个新元素。" #: :957 #, safe-html, strict-same msgctxt ":957" msgid "" "If there is an existing element with key `k` this function does nothing." msgstr "如果存在键为 `k` 的元素，则该函数不执行任何操作。" #: :959 #, safe-html, strict-same msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是一个关于元素应插入位置的建议。此实现会忽略该建议。" #: :962 #, 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_flat_map_emplace_hint[emplace_hint], with the difference " "that no `value_type` is constructed if there is an element with an " "equivalent key; otherwise, the construction is of the form: + + -- ```c++" msgstr "" "返回：若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素。抛出：若调" "用 `hasher` 以外的操作抛出异常，则函数无效果。注意：此函数与 " "xref:#unordered_flat_map_emplace_hint[emplace_hint] 类似，区别在于：若存在等" "价的键，则不构造 `value_type`；否则，构造形式如下：+ + -- `c++`" #: :970 #, safe-html, strict-same msgctxt ":970" 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)...))" #: :975 #, safe-html, strict-same msgctxt ":975" 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)...)) ```" #: :980 #, safe-html, strict-same msgid "" "unlike xref:#unordered_flat_map_emplace_hint[emplace_hint], which simply " "forwards all arguments to ``value_type``'s constructor." msgstr "" "而非像 xref:#unordered_flat_map_emplace_hint[emplace_hint] 只是简单地将所有参" "数转发给 value_type 的构造函数。" #: :982 #, safe-html, strict-same msgctxt ":982" msgid "" "Can invalidate iterators pointers and references, but only if the insert " "causes the load to be greater than the maximum load." msgstr "" "可能会导致迭代器、指针和引用失效，但仅当插入操作导致负载因子超过最大负载因子" "时才会发生。" #: :984 #, safe-html, strict-same msgctxt ":984" 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` 类型实例的开销。" #: :986 #, safe-html, strict-same msgctxt ":986" msgid "--" msgstr "--" #: :988 #, safe-html, strict-same msgctxt ":988" msgid "---" msgstr "---" #: :990 #, safe-html, strict-same msgid "insert_or_assign" msgstr "insert++_++or++_++assign" #: :991 #, 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); ```" #: :1000 #, safe-html, strict-same msgctxt ":1000" msgid "" "Inserts a new element into the container or updates an existing one by " "assigning to the contained value." msgstr "向容器中插入一个新元素，或通过赋值给已包含的值来更新现有元素。" #: :1002 #, safe-html, strict-same msgctxt ":1002" msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "如果存在键为 k 的元素，则通过赋值 std::forward(obj) 来更新该元素" #: :1004 #, safe-html, strict-same msgctxt ":1004" msgid "If there is no such element, it is added to the container as: ```c++" msgstr "如果不存在这样的元素，则将其添加到容器中，形式如下：```c++" #: :1007 #, safe-html, strict-same msgctxt ":1007" 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)))" #: :1012 #, safe-html, strict-same msgctxt ":1012" 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))) ```" #: :1018 #, 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 " "pointers and references, but only if the insert causes the load to be " "greater than the maximum load. + + 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`。+ +若执行了插入，则" "迭代器指向新插入的元素；否则指向等价的元素。抛出：若调用 `hasher` 以外的操作" "抛出异常，则函数无效果。注意：可能会导致迭代器、指针和引用失效，但仅当插入操" "作导致负载因子超过最大负载因子时才会发生。+ +`template` 仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是" "有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 调用，" "且 `Pred` 是透明的。这提供了异构查找能力，从而避免构造 `Key` 类型实例的开销" "。" #: :1026 #, safe-html, strict-same msgctxt ":1026" msgid "---" msgstr "---" #: :1028 #, safe-html, strict-same msgid "insert_or_assign with Hint" msgstr "带提示的 insert++_++or++_++assign" #: :1029 #, 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); ```" #: :1038 #, safe-html, strict-same msgctxt ":1038" msgid "" "Inserts a new element into the container or updates an existing one by " "assigning to the contained value." msgstr "向容器中插入一个新元素，或通过赋值给已存在的值来更新现有元素。" #: :1040 #, safe-html, strict-same msgctxt ":1040" msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "如果存在键为 `k` 的元素，则通过赋值 `std::forward(obj)` 来更新该元素。" #: :1042 #, safe-html, strict-same msgctxt ":1042" msgid "If there is no such element, it is added to the container as: ```c++" msgstr "如果不存在这样的元素，则将其添加到容器中，形式如下：```c++" #: :1045 #, safe-html, strict-same msgctxt ":1045" 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)))" #: :1050 #, safe-html, strict-same msgctxt ":1050" 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))) ```" #: :1055 #, safe-html, strict-same msgctxt ":1055" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是一个关于元素应插入位置的建议。此实现会忽略该建议。" #: :1058 #, 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:;; Can invalidate iterators, " "pointers and references, but only if the insert causes the load to be " "greater than the maximum load. + + 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 "" "返回：若执行了插入，则迭代器指向新插入的元素；否则指向等价的元素。抛出：若调" "用 `hasher` 以外的操作抛出异常，则函数无效果。注意：可能会导致迭代器、指针和" "引用失效，但仅当插入操作导致负载因子超过最大负载因子时才会发生。+ " "+`template` 仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。这提供了异构查找能力，从而避免" "构造 `Key` 类型实例的开销。" #: :1064 #, safe-html, strict-same msgctxt ":1064" msgid "---" msgstr "---" #: :1067 #, safe-html, strict-same msgid "Erase by Position" msgstr "通过位置擦除" #: :1075 #, safe-html, strict-same msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :1078 #, safe-html, strict-same msgid "" "Returns:;; An opaque object implicitly convertible to the `iterator` or " "`const_iterator` immediately following `position` prior to the erasure. " "Throws:;; Nothing. Notes:;; The opaque object returned must only be " "discarded or immediately converted to `iterator` or `const_iterator`." msgstr "" "返回;; 返回一个不透明对象，该对象可隐式转换为擦除前紧接在 `position` 之后的 " "`iterator` 或 `const++_++iterator` 。 抛出;; 无。 注意;; 返回的不透明对象必须" "被立即丢弃或转换为 `iterator` 或 `const++_++iterator` 。" #: :1083 #, safe-html, strict-same msgctxt ":1083" msgid "---" msgstr "---" #: :1085 #, safe-html, strict-same msgid "Erase by Key" msgstr "通过键擦除" #: :1086 #, 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); ```" #: :1091 #, safe-html, strict-same msgid "Erase all elements with key equivalent to `k`." msgstr "擦除所有键与 `k` 等价的元素。" #: :1094 #, safe-html, strict-same msgid "" "Returns:;; The number of elements erased. Throws:;; Only throws an exception " "if it is thrown by `hasher` or `key_equal`. Notes:;; The `template` " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. The library " "assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：被擦除的元素数量。抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出" "异常。注意：`template` 重载仅在以下条件下参与重载决议" "：`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 " "`iterator` 和 `const_iterator` 均不能从 `K` 隐式转换。库假定 `Hash` 可同时以 " "`K` 和 `Key` 调用，且 `Pred` 是透明的。这提供了异构查找能力，从而避免构造 " "`Key` 类型实例的开销。" #: :1098 #, safe-html, strict-same msgctxt ":1098" msgid "---" msgstr "---" #: :1100 #, safe-html, strict-same msgid "Erase Range" msgstr "范围擦除" #: :1102 #, safe-html, strict-same msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```" msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```" #: :1106 #, safe-html, strict-same msgid "Erases the elements in the range from `first` to `last`." msgstr "擦除从 `first` 到 `last` 范围内的元素。" #: :1109 #, safe-html, strict-same msgid "" "Returns:;; The iterator following the erased elements - i.e. `last`. " "Throws:;; Nothing in this implementation (neither the `hasher` nor the " "`key_equal` objects are called)." msgstr "" "返回：指向被擦除元素之后位置的迭代器，即 `last`。抛出：在此实现中不会抛出异常" "（既不调用 `hasher` 也不调用 `key_equal` 对象）。" #: :1112 #, safe-html, strict-same msgctxt ":1112" msgid "---" msgstr "---" #: :1114 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :1115 #, safe-html, strict-same msgid "" "```c++ void swap(unordered_flat_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); ```" msgstr "" "```c++ void swap(unordered_flat_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); " "```" #: :1121 #, safe-html, strict-same msgid "Swaps the contents of the container with the parameter." msgstr "将容器的内容与参数进行交换。" #: :1123 #, safe-html, strict-same msgctxt ":1123" 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1126 #, safe-html, strict-same msgid "Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping." msgstr "抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不会抛出异常。" #: :1128 #, safe-html, strict-same msgctxt ":1128" msgid "---" msgstr "---" #: :1130 #, safe-html, strict-same msgid "pull" msgstr "pull" #: :1131 #, safe-html, strict-same msgid "```c++ init_type pull(const_iterator position); ```" msgstr "```c++ init_type pull(const_iterator position); ```" #: :1135 #, safe-html, strict-same msgid "" "Move-constructs an `init_value` `x` from the element pointed to by " "`position`, erases the element and returns `x`." msgstr "" "从 `position` 指向的元素移动构造一个 `init_value` 对象 `x`，擦除该元素并返回 " "`x`。" #: :1138 #, safe-html, strict-same msgctxt ":1138" msgid "---" msgstr "---" #: :1140 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1141 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :1145 #, safe-html, strict-same msgid "Erases all elements in the container." msgstr "擦除容器中的所有元素。" #: :1148 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * " "bucket_count()`" msgstr "" "后置条件：`size() == 0`，`max_load() >= max_load_factor() * bucket_count()" "`" #: :1150 #, safe-html, strict-same msgctxt ":1150" msgid "---" msgstr "---" #: :1152 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1153 #, safe-html, strict-same msgid "" "```c++ template void merge(unordered_flat_map& source); template void merge" "(unordered_flat_map&& source); ```" msgstr "" "```c++ template void merge" "(unordered_flat_map& " "source); template void merge" "(unordered_flat_map&& " "source); ```" #: :1160 #, safe-html, strict-same msgid "" "Move-inserts all the elements from `source` whose key is not already present " "in `*this`, and erases them from `source`." msgstr "" "尝试将 `source` 中所有键尚未出现在 `*this` 内的元素移动插入到 `*this` 中，同" "时将这些元素从 `source` 移除。" #: :1162 #, safe-html, strict-same msgctxt ":1162" msgid "---" msgstr "---" #: :1164 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1166 #, safe-html, strict-same msgid "get_allocator" msgstr "get++_++allocator" #: :1167 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const noexcept; ```" msgstr "``` allocator_type get_allocator() const noexcept; ```" #: :1172 #, safe-html, strict-same msgid "Returns:;; The container's allocator." msgstr "返回：容器的分配器。" #: :1174 #, safe-html, strict-same msgctxt ":1174" msgid "---" msgstr "---" #: :1176 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1177 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :1182 #, safe-html, strict-same msgid "Returns:;; The container's hash function." msgstr "返回：容器的哈希函数。" #: :1184 #, safe-html, strict-same msgctxt ":1184" msgid "---" msgstr "---" #: :1186 #, safe-html, strict-same msgid "key_eq" msgstr "key++_++eq" #: :1187 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1192 #, safe-html, strict-same msgid "Returns:;; The container's key equality predicate" msgstr "返回：容器的键相等谓词。" #: :1194 #, safe-html, strict-same msgctxt ":1194" msgid "---" msgstr "---" #: :1196 #, safe-html, strict-same msgid "Lookup" msgstr "查找" #: :1198 #, safe-html, strict-same msgid "find" msgstr "find" #: :1199 #, safe-html, strict-same msgid "" "```c++ iterator find(const key_type& k); const_iterator find(const " "key_type& k) const; template iterator find(const K& k);" msgstr "" "```c++ iterator find(const key_type& k); const_iterator find" "(const key_type& k) const; template iterator find" "(const K& k);" #: :1205 #, safe-html, strict-same msgid "```" msgstr "```" #: :1208 #, safe-html, strict-same msgid "" "Returns:;; An iterator pointing to an element with key equivalent to `k`, or " "`end()` if no such element exists. Notes:;; The `template` " "overloads only participate in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs. The library assumes " "that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：指向键与 `k` 等价的元素的迭代器，若不存在这样的元素则返回 `end()`。注意" "：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实" "例化 `Key` 类型的开销。" #: :1211 #, safe-html, strict-same msgctxt ":1211" msgid "---" msgstr "---" #: :1213 #, safe-html, strict-same msgid "count" msgstr "count" #: :1214 #, 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; ```" #: :1221 #, safe-html, strict-same msgid "" "Returns:;; The number of elements with key equivalent to `k`. Notes:;; The " "`template` overload only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：键与 `k` 等价的元素数量。注意：`template` 重载仅在 " "`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与" "重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机" "制支持异构查找，从而避免实例化 `Key` 类型的开销。" #: :1224 #, safe-html, strict-same msgctxt ":1224" msgid "---" msgstr "---" #: :1226 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1227 #, 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; ```" #: :1234 #, safe-html, strict-same msgid "" "Returns:;; A boolean indicating whether or not there is an element with key " "equal to `key` in the container Notes:;; The `template` overload " "only participates in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。注意" "：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实" "例化 `Key` 类型的开销。" #: :1237 #, safe-html, strict-same msgctxt ":1237" msgid "---" msgstr "---" #: :1239 #, safe-html, strict-same msgid "equal_range" msgstr "equal++_++range" #: :1240 #, 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; ```" "" #: :1250 #, 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 "" "返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。注意" "：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实" "例化 `Key` 类型的开销。" #: :1253 #, safe-html, strict-same msgctxt ":1253" msgid "---" msgstr "---" #: :1255 #, safe-html, strict-same msgid "operator++[++++]++" msgstr "operator++[]++" #: :1256 #, 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); ```" #: :1263 #, safe-html, strict-same msgid "" "Effects:;; If the container does not already contain an element 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, pointers and references, but only if the insert causes the load " "to be greater than the maximum load. + + 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())`。返回：对 `x.second` 的引用" "，其中 `x` 是容器中已存在的元素，或键与 `k` 等价的新插入元素。抛出：如果调用 " "`hasher` 以外的操作抛出异常，则该函数无效果。注意：可能会导致迭代器、指针和引" "用失效，但仅当插入操作导致负载因子超过最大负载因子时才会发生。+ " "+`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实" "例化 `Key` 类型的开销。" #: :1270 #, safe-html, strict-same msgctxt ":1270" msgid "---" msgstr "---" #: :1272 #, safe-html, strict-same msgid "at" msgstr "at" #: :1273 #, 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; ```" #: :1281 #, 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` 等价的（唯一）元素。抛出：如" "果不存在这样的元素，则抛出 `std::out_of_range` 类型的异常对象。注意" "：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时以 `K` 和 `Key` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实" "例化 `Key` 类型的开销。" #: :1285 #, safe-html, strict-same msgctxt ":1285" msgid "---" msgstr "---" #: :1287 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1289 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1290 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1295 #, safe-html, strict-same msgid "Returns:;; The size of the bucket array." msgstr "返回：桶数组的大小。" #: :1297 #, safe-html, strict-same msgctxt ":1297" msgid "---" msgstr "---" #: :1299 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1301 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1302 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1307 #, safe-html, strict-same msgid "" "Returns:;; `static_cast(size())/static_cast(bucket_count())`, " "or `0` if `bucket_count() == 0`." msgstr "" "返回：`static_cast(size())/static_cast(bucket_count())`，若 " "`bucket_count() == 0` 则返回 `0`。" #: :1309 #, safe-html, strict-same msgctxt ":1309" msgid "---" msgstr "---" #: :1311 #, safe-html, strict-same msgid "max_load_factor" msgstr "max++_++load++_++factor（最大负载因子）" #: :1313 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1318 #, safe-html, strict-same msgid "Returns:;; Returns the container's maximum load factor." msgstr "返回：容器的最大负载因子。" #: :1320 #, safe-html, strict-same msgctxt ":1320" msgid "---" msgstr "---" #: :1322 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1323 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1328 #, safe-html, strict-same msgid "" "Effects:;; Does nothing, as the user is not allowed to change this " "parameter. Kept for compatibility with `boost::unordered_map`." msgstr "" "效果：不执行任何操作，因为用户不允许更改此参数。为与 `boost::unordered_map` " "保持兼容而保留。" #: :1330 #, safe-html, strict-same msgctxt ":1330" msgid "---" msgstr "---" #: :1333 #, safe-html, strict-same msgid "max_load" msgstr "max++_++load（最大负载）" #: :1335 #, safe-html, strict-same msgid "```c++ size_type max_load() const noexcept; ```" msgstr "```c++ size_type max_load() const noexcept; ```" #: :1340 #, safe-html, strict-same msgid "" "Returns:;; The maximum number of elements the container can hold without " "rehashing, assuming that no further elements will be erased. Note:;; After " "construction, rehash or clearance, the container's maximum load is at least " "`max_load_factor() * bucket_count()`. This number may decrease on erasure " "under high-load conditions." msgstr "" "返回：在不进行 rehash 的前提下，容器所能容纳的最大元素数量（假设不会有更多元" "素被擦除）。注意：在构造、rehash 或清空之后，容器的最大负载至少为 " "`max_load_factor() * bucket_count()`。在高负载条件下，该值可能因擦除操作而减" "小。" #: :1344 #, safe-html, strict-same msgctxt ":1344" msgid "---" msgstr "---" #: :1346 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1347 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1351 #, safe-html, strict-same msgid "" "Changes if necessary the size of the bucket array so that there are at least " "`n` buckets, and so that the load factor is less than or equal to the " "maximum load factor. When applicable, this will either grow or shrink the " "`bucket_count()` associated with the container." msgstr "" "如有必要，将改变桶数组的大小，使其至少包含 `n` 个桶，并确保负载因子小于或等于" "最大负载因子。此操作将根据情况增加或减少容器的 `bucket++_++count()` 。" #: :1353 #, safe-html, strict-same msgid "" "When `size() == 0`, `rehash(0)` will deallocate the underlying buckets " "array. If the provided Allocator uses fancy pointers, a default allocation " "is subsequently performed." msgstr "" "当 `size() == 0` 时，`rehash(0)` 将释放底层桶数组。如果提供的分配器使用花式指" "针，则随后会执行一次默认分配。" #: :1355 #, safe-html, strict-same msgctxt ":1355" msgid "" "Invalidates iterators, pointers and references, and changes the order of " "elements." msgstr "使迭代器、指针和引用失效，并改变元素的顺序。" #: :1358 #, safe-html, strict-same msgctxt ":1358" 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 "抛出：若抛出异常（除非由容器的哈希函数或比较函数抛出），则该函数无效果。" #: :1360 #, safe-html, strict-same msgctxt ":1360" msgid "---" msgstr "---" #: :1362 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1363 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1367 #, safe-html, strict-same msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`." msgstr "等价于 `a.rehash(ceil(n / a.max_load_factor()))`。" #: :1369 #, 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` 类似，该函数可用于增加或减少容器中的桶数量。" #: :1371 #, safe-html, strict-same msgctxt ":1371" msgid "" "Invalidates iterators, pointers and references, and changes the order of " "elements." msgstr "使迭代器、指针和引用失效，并改变元素的顺序。" #: :1374 #, safe-html, strict-same msgctxt ":1374" 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 "抛出：若抛出异常（除非由容器的哈希函数或比较函数抛出），则该函数无效果。" #: :1376 #, safe-html, strict-same msgctxt ":1376" msgid "---" msgstr "---" #: :1378 #, safe-html, strict-same msgid "Statistics" msgstr "统计信息" #: :1380 #, safe-html, strict-same msgid "get_stats" msgstr "get++_++stats" #: :1381 #, safe-html, strict-same msgid "```c++ stats get_stats() const; ```" msgstr "```c++ stats get_stats() const; ```" #: :1386 #, safe-html, strict-same msgid "" "Returns:;; A statistical description of the insertion and lookup operations " "performed by the container so far. Notes:;; Only available if xref:reference/" "stats.adoc#stats[statistics calculation] is " "xref:unordered_flat_map_boost_unordered_enable_stats[enabled]." msgstr "" "返回：对容器迄今为止执行的插入和查找操作的统计描述。注意：仅当 " "xref:reference/stats.adoc#stats[统计计算] 被 " "xref:unordered_flat_map_boost_unordered_enable_stats[启用] 时可用。" #: :1389 #, safe-html, strict-same msgctxt ":1389" msgid "---" msgstr "---" #: :1391 #, safe-html, strict-same msgid "reset_stats" msgstr "reset++_++stats" #: :1392 #, safe-html, strict-same msgid "```c++ void reset_stats() noexcept; ```" msgstr "```c++ void reset_stats() noexcept; ```" #: :1397 #, safe-html, strict-same msgid "" "Effects:;; Sets to zero the internal statistics kept by the container. " "Notes:;; Only available if xref:reference/stats.adoc#stats[statistics " "calculation] is " "xref:unordered_flat_map_boost_unordered_enable_stats[enabled]." msgstr "" "效果：将容器内部保持的统计信息重置为零。注意：仅当 xref:reference/" "stats.adoc#stats[统计计算] 被 " "xref:unordered_flat_map_boost_unordered_enable_stats[启用] 时可用。" #: :1400 #, safe-html, strict-same msgctxt ":1400" msgid "---" msgstr "---" #: :1402 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1403 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "如果以下任何一条件为真，则推导指引将不参与重载决议：" #: :1405 #, safe-html, strict-same msgid "" "- It has an `InputIterator` template parameter and a type that does not " "qualify as an input iterator is deduced for that parameter. - It has an " "`Allocator` template parameter and a type that does not qualify as an " "allocator is deduced for that parameter. - It has a `Hash` template " "parameter and an integral type or a type that qualifies as an allocator is " "deduced for that parameter. - It has a `Pred` template parameter and a type " "that qualifies as an allocator is deduced for that parameter." msgstr "" "- 该推导指引包含 `InputIterator` 模板参数，且为此参数推导出的类型不符合输入迭" "代器的要求。 - 该推导指引包含 `Allocator` 模板参数，且为该参数推导出的类型不" "符合分配器要求。 - 该推导指引包含 `Hash` 模板参数，且为该参数推导出的类型为整" "型或符合分配器要求。 - 该推导指引包含 `Pred` 模板参数，且为该参数推导出的类型" "符合分配器要求。" #: :1410 #, 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` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1414 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "__iter-value-type__" #: :1422 #, safe-html, strict-same msgid "__iter-key-type__" msgstr "__iter-key-type__" #: :1430 #, safe-html, strict-same msgid "__iter-mapped-type__" msgstr "__iter-mapped-type__" #: :1438 #, safe-html, strict-same msgid "__iter-to-alloc-type__" msgstr "__iter-to-alloc-type__" #: :1447 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1449 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1450 #, safe-html, strict-same msgid "" "```c++ template " "bool operator==(const unordered_flat_map& x, " "const unordered_flat_map& y); ```" msgstr "" "```c++ template bool operator==(const unordered_flat_map& x, const unordered_flat_map& y); ```" #: :1456 #, 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`。" #: :1459 #, safe-html, strict-same msgctxt ":1459" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器的相等谓词不等价，则行为未定义。" #: :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++ template " "bool operator!=(const unordered_flat_map& x, " "const unordered_flat_map& y); ```" msgstr "" "```c++ template bool operator!=(const unordered_flat_map& x, const unordered_flat_map& y); ```" #: :1470 #, 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`。" #: :1473 #, safe-html, strict-same msgctxt ":1473" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器的相等谓词不等价，则行为未定义。" #: :1475 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1476 #, safe-html, strict-same msgid "" "```c++ template " "void swap(unordered_flat_map& x, " "unordered_flat_map& y) noexcept(noexcept(x.swap" "(y))); ```" msgstr "" "```c++ template void swap(unordered_flat_map& x, unordered_flat_map& y) noexcept(noexcept(x.swap(y))); ```" #: :1483 #, safe-html, strict-same msgid "Swaps the contents of `x` and `y`." msgstr "交换 `x` 和 `y` 的内容。" #: :1485 #, safe-html, strict-same msgctxt ":1485" 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1488 #, safe-html, strict-same msgid "" "Effects:;; `x.swap(y)` Throws:;; Nothing unless `key_equal` or `hasher` " "throw on swapping." msgstr "" "效果：`x.swap(y)` 抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不" "会抛出异常。" #: :1491 #, safe-html, strict-same msgctxt ":1491" msgid "---" msgstr "---" #: :1493 #, safe-html, strict-same msgid "erase_if" msgstr "erase++_++if" #: :1494 #, safe-html, strict-same msgid "" "```c++ template typename unordered_flat_map::size_type erase_if" "(unordered_flat_map& c, Predicate pred); ```" msgstr "" "```c++ template typename unordered_flat_map::size_type erase_if(unordered_flat_map& c, Predicate pred); ```" #: :1500 #, safe-html, strict-same msgid "" "Traverses the container `c` and removes all elements for which the supplied " "predicate returns `true`." msgstr "遍历容器 `c`，并移除所有使得给定谓词返回 `true` 的元素。" #: :1503 #, 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 "" "返回：被擦除的元素数量。注意：等价于：`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` 的引用是非常量的。" #: :1520 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1522 #, safe-html, strict-same msgid "" "``unordered_flat_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++_++flat++_++map` 可通过本组件库提供的 API，借助 link:../../../../" "../serialization/index.html[Boost.Serialization] 进行归档/检索。支持常规归档" "与 XML 归档两种格式。" #: :1526 #, safe-html, strict-same msgid "Saving an unordered_flat_map to an archive" msgstr "将 unordered++_++flat++_++map 保存到归档" #: :1528 #, safe-html, strict-same msgid "" "Saves all the elements of an `unordered_flat_map` `x` to an archive (XML " "archive) `ar`." msgstr "将 `unordered++_++flat++_++map` `x` 的所有元素保存到归档（XML 归档） `ar` 。" #: :1531 #, 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[可默认构造] 要求）" "。" #: :1537 #, safe-html, strict-same msgctxt ":1537" msgid "---" msgstr "---" #: :1539 #, safe-html, strict-same msgid "Loading an unordered_flat_map from an archive" msgstr "从归档加载 unordered++_++flat++_++map" #: :1541 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of an `unordered_flat_map` `x` and inserts " "from an archive (XML archive) `ar` restored copies of the elements of the " "original `unordered_flat_map` `other` saved to the storage read by `ar`." msgstr "" "删除 `unordered++_++flat++_++map` 容器 `x` 中所有已存在的元素，并从归档（XML " "归档） `ar` 中插入原始 `unordered++_++flat++_++map` 容器 `other` 的元素副本，" "这些副本是从 `ar` 所读取的存储中恢复的。" #: :1546 #, safe-html, strict-same msgid "" "Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()" "`." msgstr "要求;; `x.key++_++equal()` 需要在功能上等价于 `other.key++_++equal()` 。" #: :1548 #, safe-html, strict-same msgctxt ":1548" msgid "---" msgstr "---" #: :1550 #, safe-html, strict-same msgid "Saving an iterator/const_iterator to an archive" msgstr "将迭代器/常量迭代器保存到归档" #: :1552 #, 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()` 迭代器。" #: :1556 #, safe-html, strict-same msgid "" "Requires:;; The `unordered_flat_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++_++flat++_++map` 容器 `x` 必须先前已保存至 " "`ar` ，且在保存 `x` 与保存 `it` 期间不得对 `x` 执行任何修改操作。" #: :1560 #, safe-html, strict-same msgctxt ":1560" msgid "---" msgstr "---" #: :1562 #, safe-html, strict-same msgid "Loading an iterator/const_iterator from an archive" msgstr "从归档加载迭代器/常量迭代器" #: :1564 #, safe-html, strict-same msgid "" "Makes an `iterator` (`const_iterator`) `it` point to the restored position " "of the original `iterator` (`const_iterator`) saved to the storage read by " "an archive (XML archive) `ar`." msgstr "" "使 `iterator` （ `const++_++iterator` ） `it` 指向原始 `iterator` （ " "`const++_++iterator` ）所恢复的位置。该原始迭代器已被保存到由归档（XML 归档" "） `ar` 读取的存储中。" #: :1569 #, safe-html, strict-same msgid "" "Requires:;; If `x` is the `unordered_flat_map` `it` points to, no modifying " "operations have been issued on `x` between loading of `x` and loading of " "`it`." msgstr "" "要求;; 若 `x` 是 `it` 所指向的 `unordered++_++flat++_++map` 容器，则在加载 " "`x` 与加载 `it` 期间不得对 `x` 执行任何修改操作。"