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-06 17:07+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: Chinese (Simplified Han script) \n" "Language: zh_Hans\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" "X-Generator: Weblate 2026.5\n" #: :2 #, safe-html, strict-same msgid "Class Template unordered_node_map" msgstr "类模板 unordered_node_map" #: :4 #, safe-html, strict-same msgid ":idprefix: unordered_node_map_" msgstr ":idprefix: unordered_node_map_" #: :6 #, safe-html, strict-same msgid "" "`boost::unordered_node_map` — A node-based, open-addressing unordered " "associative container that associates unique keys with another value." msgstr "" "`boost::unordered_node_map` — 一个基于节点的、开放寻址的无序关联容器，将唯一" "键与对应值相关联。" #: :8 #, safe-html, strict-same msgid "" "`boost::unordered_node_map` uses an open-addressing layout like " "`boost::unordered_flat_map`, but, being node-based, it provides pointer " "stability and node handling functionalities. Its performance lies between " "those of `boost::unordered_map` and `boost::unordered_flat_map`." msgstr "" "`boost::unordered_node_map` 使用与 `boost::unordered_flat_map` 类似的开放寻址" "布局，但由于其基于节点的特性，它提供了指针稳定性和节点处理功能。其性能介于 " "`boost::unordered_map` 和 `boost::unordered_flat_map` 之间。" #: :12 #, safe-html, strict-same msgid "" "As a result of its using open addressing, the interface of " "`boost::unordered_node_map` deviates in a number of aspects from that of " "`boost::unordered_map`/`std::unordered_map`:" msgstr "" "由于使用开放寻址，`boost::unordered_node_map` 的接口在多个方面与 " "`boost::unordered_map`/`std::unordered_map` 有所不同：" #: :15 #, safe-html, strict-same msgid "" "- `begin()` is not constant-time. - There is no API for bucket handling " "(except `bucket_count`). - The maximum load factor of the container is " "managed internally and can't be set by the user." msgstr "" "- `begin()` 不是常数时间复杂度操作。 - 未提供用于桶管理的 API（除 " "`bucket_count` 外）。 - 容器的最大负载因子由内部管理，用户无法进行设置。" #: :19 #, safe-html, strict-same msgid "" "Other than this, `boost::unordered_node_map` is mostly a drop-in replacement " "of standard unordered associative containers." msgstr "" "除此之外，`boost::unordered_node_map` 基本上可以作为标准无序关联容器的即时代" "替品。" #: :22 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :286 #, safe-html, strict-same msgctxt ":286" msgid "---" msgstr "---" #: :288 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :290 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :293 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :297 #, safe-html, strict-same msgid "" "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` 的对象构造并插入容器，并且还必须可以从容器中 " "https://en.cppreference.com/w/cpp/named_req/Erasable[可擦除^]。" #: :300 #, safe-html, strict-same msgid "_T_" msgstr "_T_" #: :300 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :300 #, 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` 类型的值。" #: :300 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :300 #, 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` 类型的值。" #: :300 #, safe-html, strict-same msgid "_Allocator_" msgstr "分配器" #: :300 #, safe-html, strict-same msgid "" "An allocator whose value type is the same as the container's value type." msgstr "一个分配器，其值类型与容器的值类型相同。" #: :310 #, 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[异形指针] 的分配器。" #: :314 #, safe-html, strict-same msgid "" "The element nodes of the container are held into an internal _bucket array_. " "A node is inserted into a bucket determined by the hash code of its element, " "but if the bucket is already occupied (a _collision_), an available one in " "the vicinity of the original position is used." msgstr "" "容器的元素节点被保存在内部的 _桶数组_ 中。节点根据其元素的哈希码被插入到对应" "的桶中，但如果该桶已被占用（发生 _冲突_），则会使用原始位置附近的一个可用桶。" #: :318 #, 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()`，但在容器规模较小时，实现可能会允许更高的负载。" #: :323 #, safe-html, strict-same msgid "" "If `link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]::value` is " "`true`, the hash function is used as-is; otherwise, a bit-mixing post-" "processing stage is added to increase the quality of hashing at the expense " "of extra computational cost." msgstr "" "如果 `link:../../../../../container_hash/doc/html/" "hash.html#ref_hash_is_avalanching[hash_is_avalanching]::value` 为 " "`true`，则哈希函数将按原样使用；否则，会增加一个位混合后处理阶段，以牺牲额外" "的计算成本为代价来提高哈希质量。" #: :327 #, safe-html, strict-same msgctxt ":327" msgid "---" msgstr "---" #: :329 #, safe-html, strict-same msgid "Configuration Macros" msgstr "配置宏" #: :331 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_STATS`" msgstr "`BOOST_UNORDERED_ENABLE_STATS`" #: :333 #, 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[统计计算]。请注意，" "此选项会降低许多操作的整体性能。" #: :336 #, safe-html, strict-same msgctxt ":336" msgid "---" msgstr "---" #: :338 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :345 #, safe-html, strict-same msgid "An iterator whose value type is `value_type`." msgstr "一种迭代器，其值类型为 `value_type` 。" #: :347 #, safe-html, strict-same msgctxt ":347" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :349 #, safe-html, strict-same msgid "Convertible to `const_iterator`." msgstr "可转换为 `const_iterator`。" #: :351 #, safe-html, strict-same msgctxt ":351" msgid "---" msgstr "---" #: :358 #, safe-html, strict-same msgid "A constant iterator whose value type is `value_type`." msgstr "一个常量迭代器，其值类型为 `value_type` 。" #: :360 #, safe-html, strict-same msgctxt ":360" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :362 #, safe-html, strict-same msgctxt ":362" msgid "---" msgstr "---" #: :369 #, safe-html, strict-same msgid "" "A class for holding extracted container elements, modelling https://" "en.cppreference.com/w/cpp/container/node_handle[NodeHandle]." msgstr "" "一个用于存放被提取容器元素的类，符合 https://en.cppreference.com/w/cpp/" "container/node_handle[NodeHandle] 模型。" #: :372 #, safe-html, strict-same msgctxt ":372" msgid "---" msgstr "---" #: :379 #, safe-html, strict-same msgid "A specialization of an internal class template:" msgstr "内部类模板的特化：" #: :392 #, safe-html, strict-same msgid "with `Iterator` = `iterator` and `NodeType` = `node_type`." msgstr "其中 `Iterator` = `iterator`，`NodeType` = `node_type`。" #: :394 #, safe-html, strict-same msgctxt ":394" msgid "---" msgstr "---" #: :396 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :398 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :399 #, safe-html, strict-same msgid "```c++ unordered_node_map(); ```" msgstr "```c++ unordered_node_map(); ```" #: :403 #, 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()" "` 作为分配器，构造一个空容器。" #: :407 #, safe-html, strict-same msgctxt ":407" msgid "" "Postconditions:;; `size() == 0` Requires:;; If the defaults are used, " "`hasher`, `key_equal` and `allocator_type` need to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` \n" "要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 " "https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构" "造^]。" #: :410 #, safe-html, strict-same msgctxt ":410" msgid "---" msgstr "---" #: :412 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :413 #, safe-html, strict-same msgid "" "```c++ explicit unordered_node_map(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = allocator_type" "()); ```" msgstr "" "```c++ explicit unordered_node_map(size_type n, const hasher& hf = hasher" "(), const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" #: :420 #, 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` 作为分配器。" #: :424 #, safe-html, strict-same msgctxt ":424" msgid "" "Postconditions:;; `size() == 0` Requires:;; If the defaults are used, " "`hasher`, `key_equal` and `allocator_type` need to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` \n" "要求：如果使用默认值，则 `hasher`、`key_equal` 和 `allocator_type` 需要满足 " "https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可默认构" "造^]。" #: :427 #, safe-html, strict-same msgctxt ":427" msgid "---" msgstr "---" #: :429 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :440 #, 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)` 范围内的元素插入其中。" #: :443 #, safe-html, strict-same msgctxt ":443" 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[可默认构" "造^]。" #: :445 #, safe-html, strict-same msgctxt ":445" msgid "---" msgstr "---" #: :447 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :448 #, safe-html, strict-same msgid "```c++ unordered_node_map(unordered_node_map const& other); ```" msgstr "```c++ unordered_node_map(unordered_node_map const& other); ```" #: :452 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate and allocator." msgstr "拷贝构造函数。拷贝所包含的元素、哈希函数、谓词和分配器。" #: :454 #, 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` 存在且具有正确的签名" "，则分配器将根据其结果进行构造。" #: :456 #, safe-html, strict-same msgctxt ":456" msgid "---" msgstr "---" #: :458 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :459 #, safe-html, strict-same msgid "```c++ unordered_node_map(unordered_node_map&& other); ```" msgstr "```c++ unordered_node_map(unordered_node_map&& other); ```" #: :463 #, safe-html, strict-same msgid "" "The move constructor. The internal bucket array of `other` is transferred " "directly to the new container. The hash function, predicate and allocator " "are moved-constructed from `other`. If statistics are " "xref:unordered_node_map_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "移动构造函数。`other` 的内部桶数组会被直接转移给新容器。哈希函数、谓词和分配" "器通过移动构造从 `other` 获得。如果启用了统计信息（详见 " "xref:unordered_node_map_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则会从 `other` 转移内部的统计信息，并调用 `other.reset_stats()`。" #: :468 #, safe-html, strict-same msgctxt ":468" msgid "---" msgstr "---" #: :470 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器范围构造函数" #: :471 #, safe-html, strict-same msgid "" "```c++ template unordered_node_map(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template unordered_node_map(InputIterator " "f, InputIterator l, const allocator_type& a); ```" #: :476 #, 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)` " "范围内的元素插入其中。" #: :479 #, safe-html, strict-same msgctxt ":479" 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[可默认构造^]。" #: :481 #, safe-html, strict-same msgctxt ":481" msgid "---" msgstr "---" #: :483 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :484 #, safe-html, strict-same msgid "```c++ explicit unordered_node_map(Allocator const& a); ```" msgstr "```c++ explicit unordered_node_map(Allocator const& a); ```" #: :488 #, safe-html, strict-same msgid "Constructs an empty container, using allocator `a`." msgstr "使用分配器 `a` 构造一个空容器。" #: :490 #, safe-html, strict-same msgctxt ":490" msgid "---" msgstr "---" #: :492 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的拷贝构造函数" #: :493 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(unordered_node_map const& other, Allocator const& " "a); ```" msgstr "" "```c++ unordered_node_map(unordered_node_map const& other, Allocator " "const& a); ```" #: :497 #, safe-html, strict-same msgid "" "Constructs a container, copying ``other``'s contained elements, hash " "function, and predicate, but using allocator `a`." msgstr "构造一个容器，拷贝 `other` 所包含的元素、哈希函数和谓词，但使用分配器 `a`。" #: :499 #, safe-html, strict-same msgctxt ":499" msgid "---" msgstr "---" #: :501 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :502 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(unordered_node_map&& other, Allocator const& a); " "```" msgstr "" "```c++ unordered_node_map(unordered_node_map&& other, Allocator " "const& a); ```" #: :506 #, safe-html, strict-same msgid "" "If `a == other.get_allocator()`, the element nodes of `other` are " "transferred directly to the new container; otherwise, elements are moved-" "constructed from those of `other`. The hash function and predicate are moved-" "constructed from `other`, and the allocator is copy-constructed from `a`. If " "statistics are " "xref:unordered_node_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_node_map_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则当 `a == other.get_allocator()` 时，会从 `other` 转移内部的统计信息，并且" "始终会调用 `other.reset_stats()`。" #: :513 #, safe-html, strict-same msgctxt ":513" msgid "---" msgstr "---" #: :515 #, safe-html, strict-same msgid "Move Constructor from concurrent_node_map" msgstr "从 `concurrent_node_map` 的移动构造函数" #: :517 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(concurrent_node_map" "&& other); ```" msgstr "" "```c++ unordered_node_map(concurrent_node_map&& other); ```" #: :521 #, safe-html, strict-same msgid "" "Move construction from a xref:#concurrent_node_map[`concurrent_node_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_node_map_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "从 xref:#concurrent_node_map[`concurrent_node_map`] 进行移动构造。`other` 的" "内部桶数组直接转移给新容器。哈希函数、谓词和分配器通过移动构造从 `other` 获得" "。如果启用了统计信息（详见 " "xref:unordered_node_map_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则从 `other` 转移内部的统计信息，并调用 `other.reset_stats()`。" #: :528 #, safe-html, strict-same msgid "Complexity:;; Constant time. Concurrency:;; Blocking on `other`." msgstr "" "复杂度：常数时间。 \n" "并发性：在 `other` 上阻塞。" #: :531 #, safe-html, strict-same msgctxt ":531" msgid "---" msgstr "---" #: :533 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :543 #, 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` 中的元素插入其中。" #: :546 #, safe-html, strict-same msgctxt ":546" 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[可默认构" "造^]。" #: :548 #, safe-html, strict-same msgctxt ":548" msgid "---" msgstr "---" #: :550 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :551 #, safe-html, strict-same msgid "```c++ unordered_node_map(size_type n, allocator_type const& a); ```" msgstr "" "```c++ unordered_node_map(size_type n, allocator_type const& a); ```" #: :555 #, 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` 作为分配器。" #: :558 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to " "be https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：`size() == 0` \n" "要求：`hasher` 和 `key_equal` 需要满足 https://en.cppreference.com/w/cpp/" "named_req/DefaultConstructible[可默认构造^]。" #: :561 #, safe-html, strict-same msgctxt ":561" msgid "---" msgstr "---" #: :563 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :564 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" msgstr "" "```c++ unordered_node_map(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :568 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `hf` as the " "hash function, the default key equality predicate and `a` as the allocator." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `hf` 作为哈希函数，使用默认的键相等谓" "词，并以 `a` 作为分配器。" #: :571 #, 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[可默认构造^] 要求。" #: :574 #, safe-html, strict-same msgctxt ":574" msgid "---" msgstr "---" #: :576 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :583 #, 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)` 范围内的元素插入其中。" #: :586 #, safe-html, strict-same msgctxt ":586" 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[可默认构造^]。" #: :588 #, safe-html, strict-same msgctxt ":588" msgid "---" msgstr "---" #: :590 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :598 #, 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)` 范围内的元素插入其中。" #: :601 #, safe-html, strict-same msgctxt ":601" 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[可默认构造] 要求。" #: :603 #, safe-html, strict-same msgctxt ":603" msgid "---" msgstr "---" #: :605 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :607 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ unordered_node_map(std::initializer_list il, const " "allocator_type& a); ```" #: :611 #, 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` 中的元素插入" "其中。" #: :614 #, safe-html, strict-same msgctxt ":614" 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[可默认构造^]。" #: :616 #, safe-html, strict-same msgctxt ":616" msgid "---" msgstr "---" #: :618 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :620 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(std::initializer_list il, size_type n, " "const allocator_type& a); ```" msgstr "" "```c++ unordered_node_map(std::initializer_list il, size_type n, " "const allocator_type& a); ```" #: :624 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` and " "default hash function and key equality predicate, and inserts the elements " "from `il` into it." msgstr "" "使用 `a` 以及默认的哈希函数和键相等谓词，构造一个至少包含 `n` 个桶的空容器，" "并将 `il` 中的元素插入其中。" #: :627 #, safe-html, strict-same msgctxt ":627" 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[可默认构造^]。" #: :629 #, safe-html, strict-same msgctxt ":629" msgid "---" msgstr "---" #: :631 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :633 #, safe-html, strict-same msgid "" "```c++ unordered_node_map(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ unordered_node_map(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" #: :638 #, 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` 中的元素插入其中。" #: :641 #, safe-html, strict-same msgctxt ":641" 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[可默认构造^]。" #: :643 #, safe-html, strict-same msgctxt ":643" msgid "---" msgstr "---" #: :645 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :647 #, safe-html, strict-same msgid "```c++ ~unordered_node_map(); ```" msgstr "```c++ ~unordered_node_map(); ```" #: :652 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：析构函数会应用于每个元素，并且所有内存都会被释放。" #: :654 #, safe-html, strict-same msgctxt ":654" msgid "---" msgstr "---" #: :656 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :658 #, safe-html, strict-same msgid "Copy Assignment" msgstr "拷贝赋值" #: :660 #, safe-html, strict-same msgid "" "```c++ unordered_node_map& operator=(unordered_node_map const& other); ```" msgstr "" "```c++ unordered_node_map& operator=(unordered_node_map const& other)" "; ```" #: :664 #, 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` 中元素的副本。" #: :669 #, safe-html, strict-same msgctxt ":669" 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[可拷贝插入^]。" #: :671 #, safe-html, strict-same msgctxt ":671" msgid "---" msgstr "---" #: :673 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :674 #, safe-html, strict-same msgid "" "```c++ unordered_node_map& operator=(unordered_node_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_node_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++\n" "unordered_node_map& operator=(unordered_node_map&& other) " "noexcept((boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && " "std::is_same::value);\n" "```\n" "移动赋值运算符。销毁之前存在的元素，交换来自 `other` 的哈希函数和谓词，并且如" "果 `Alloc::propagate_on_container_move_assignment` 存在且 " "`Alloc::propagate_on_container_move_assignment::value` 为 `true`，则从 " "`other` 移动赋值分配器。如果此时分配器与 `other.get_allocator()` 相等，则 " "`other` 的内部桶数组直接转移给当前容器；否则，插入从 `other` 元素移动构造而来" "的副本。如果启用了统计信息（详见 " "xref:unordered_node_map_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`]）" "，则当最终分配器与 `other.get_allocator()` 相等时，从 `other` 转移内部的统计" "信息，并且始终会调用 `other.reset_stats()`。" #: :688 #, safe-html, strict-same msgctxt ":688" msgid "---" msgstr "---" #: :690 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :691 #, safe-html, strict-same msgid "" "```c++ unordered_node_map& operator=(std::initializer_list il); " "```" msgstr "" "```c++ unordered_node_map& operator=(std::initializer_list " "il); ```" #: :695 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All previously existing elements are " "destroyed." msgstr "从初始化列表中的值进行赋值。所有之前存在的元素都会被销毁。" #: :698 #, safe-html, strict-same msgctxt ":698" 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[可拷贝插入^]。" #: :700 #, safe-html, strict-same msgid "Iterators" msgstr "迭代器" #: :702 #, safe-html, strict-same msgid "begin" msgstr "begin" #: :703 #, safe-html, strict-same msgid "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" msgstr "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" #: :709 #, safe-html, strict-same msgid "" "Returns:;; An iterator referring to the first element of the container, or " "if the container is empty the past-the-end value for the container. " "Complexity:;; O(`bucket_count()`)" msgstr "" "返回：指向容器第一个元素的迭代器，如果容器为空则返回容器的尾后迭代器。 \n" "复杂度：O(`bucket_count()`)" #: :712 #, safe-html, strict-same msgctxt ":712" msgid "---" msgstr "---" #: :714 #, safe-html, strict-same msgid "end" msgstr "end" #: :715 #, safe-html, strict-same msgid "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" msgstr "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" #: :721 #, safe-html, strict-same msgid "" "Returns:;; An iterator which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后值的迭代器。" #: :723 #, safe-html, strict-same msgctxt ":723" msgid "---" msgstr "---" #: :725 #, safe-html, strict-same msgid "cbegin" msgstr "cbegin" #: :726 #, safe-html, strict-same msgid "```c++ const_iterator cbegin() const noexcept; ```" msgstr "```c++ const_iterator cbegin() const noexcept; ```" #: :731 #, 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`，如果容器为空则返回容器的尾后值。" " \n" "复杂度：O(`bucket_count()`)" #: :734 #, safe-html, strict-same msgctxt ":734" msgid "---" msgstr "---" #: :736 #, safe-html, strict-same msgid "cend" msgstr "cend" #: :737 #, safe-html, strict-same msgid "```c++ const_iterator cend() const noexcept; ```" msgstr "```c++ const_iterator cend() const noexcept; ```" #: :742 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` which refers to the past-the-end value for the " "container." msgstr "返回：指向容器尾后值的 `const_iterator`。" #: :744 #, safe-html, strict-same msgctxt ":744" msgid "---" msgstr "---" #: :746 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :748 #, safe-html, strict-same msgid "empty" msgstr "空" #: :750 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :755 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "Returns:;; `size() == 0`" #: :757 #, safe-html, strict-same msgctxt ":757" msgid "---" msgstr "---" #: :759 #, safe-html, strict-same msgid "size" msgstr "大小" #: :761 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :766 #, safe-html, strict-same msgid "Returns:;; `std::distance(begin(), end())`" msgstr "Returns:;; `std::distance(begin(), end())`" #: :768 #, safe-html, strict-same msgctxt ":768" msgid "---" msgstr "---" #: :770 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :772 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :777 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible container." msgstr "返回：可能的最大容器的 `size()`。" #: :779 #, safe-html, strict-same msgctxt ":779" msgid "---" msgstr "---" #: :781 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :783 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :784 #, safe-html, strict-same msgid "" "```c++ template std::pair emplace(Args&&... " "args); ```" msgstr "" "```c++ template std::pair emplace" "(Args&&... args); ```" #: :788 #, safe-html, strict-same msgctxt ":788" 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` 构造的对象。" #: :791 #, safe-html, strict-same msgctxt ":791" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load to be greater than the maximum load. + + If `args...` " "is of the form `k,v`, it delays constructing the whole object until it is " "certain that an element should be inserted, using only the `k` argument to " "check. This optimization happens when `key_type` is move constructible or " "when the `k` argument is a `key_type`." msgstr "" "要求：`value_type` 可从 `args` 构造。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "如果 `args...` 的形式为 `k,v`，则该函数会延迟构造整个对象，直到确定应该插入元" "素为止，仅使用 `k` 参数进行检查。当 `key_type` 可移动构造或 `k` 参数本身就是 " "`key_type` 类型时，此优化生效。" #: :800 #, safe-html, strict-same msgctxt ":800" msgid "---" msgstr "---" #: :802 #, safe-html, strict-same msgid "emplace_hint" msgstr "emplace_hint" #: :803 #, 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); ```" #: :807 #, safe-html, strict-same msgctxt ":807" 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` 构造的对象。" #: :809 #, safe-html, strict-same msgid "" "`position` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`position` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :812 #, safe-html, strict-same msgctxt ":812" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, but only if the " "insert causes the load to be greater than the maximum load. + + If `args...` " "is of the form `k,v`, it delays constructing the whole object until it is " "certain that an element should be inserted, using only the `k` argument to " "check. This optimization happens when `key_type` is move constructible or " "when the `k` argument is a `key_type`." msgstr "" "要求：`value_type` 可从 `args` 构造。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "如果 `args...` 的形式为 `k,v`，则该函数会延迟构造整个对象，直到确定应该插入元" "素为止，仅使用 `k` 参数进行检查。当 `key_type` 可移动构造或 `k` 参数本身就是 " "`key_type` 类型时，此优化生效。" #: :821 #, safe-html, strict-same msgctxt ":821" msgid "---" msgstr "---" #: :823 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :824 #, 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); ```" #: :829 #, safe-html, strict-same msgctxt ":829" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :832 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load 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[可拷贝插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "形式为 `insert(x)` 的调用，如果 `x` 可以同等转换为 `const value_type&` " "和 `const init_type&`，则不会产生歧义，并且会选择 `init_type` 重载。" #: :841 #, safe-html, strict-same msgctxt ":841" msgid "---" msgstr "---" #: :843 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :844 #, 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); ```" #: :849 #, safe-html, strict-same msgctxt ":849" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :852 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load 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[可移动插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "形式为 `insert(x)` 的调用，如果 `x` 可以同等转换为 `value_type&&` 和 " "`init_type&&`，则不会产生歧义，并且会选择 `init_type` 重载。" #: :861 #, safe-html, strict-same msgctxt ":861" msgid "---" msgstr "---" #: :863 #, safe-html, strict-same msgid "Copy Insert with Hint" msgstr "带提示的复制插入" #: :864 #, 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 "" "```c++\n" "iterator insert(const_iterator hint, const value_type& obj);\n" "iterator insert(const_iterator hint, const init_type& obj);\n" "```\n" "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :870 #, safe-html, strict-same msgctxt ":870" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :873 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load 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[可拷贝插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "形式为 `insert(hint, x)` 的调用，如果 `x` 可以同等转换为 `const " "value_type&` 和 `const init_type&`，则不会产生歧义，并且会选择 " "`init_type` 重载。" #: :882 #, safe-html, strict-same msgctxt ":882" msgid "---" msgstr "---" #: :884 #, safe-html, strict-same msgid "Move Insert with Hint" msgstr "带提示的移动插入" #: :885 #, 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); ```" #: :890 #, safe-html, strict-same msgctxt ":890" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中没有具有等价键的元素时，才将 `obj` 插入容器。" #: :892 #, safe-html, strict-same msgctxt ":892" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :895 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, but only if the insert causes the load 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[可移动插入^]。 \n" "返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "形式为 `insert(hint, x)` 的调用，如果 `x` 可以同等转换为 " "`value_type&&` 和 `init_type&&`，则不会产生歧义，并且会选择 " "`init_type` 重载。" #: :904 #, safe-html, strict-same msgctxt ":904" msgid "---" msgstr "---" #: :906 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :907 #, safe-html, strict-same msgid "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" #: :911 #, safe-html, strict-same msgctxt ":911" msgid "" "Inserts a range of elements into the container. Elements are inserted if and " "only if there is no element in the container with an equivalent key." msgstr "" "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入" "这些元素。" #: :914 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into the container from " "`*first`. Throws:;; When inserting a single element, if an exception is " "thrown by an operation other than a call to `hasher` the function has no " "effect. Notes:;; Can invalidate iterators, but only if the insert causes the " "load to be greater than the maximum load." msgstr "" "要求：`value_type` 可以从 `*first` 出发在容器中进行 https://" "en.cppreference.com/w/cpp/named_req/EmplaceConstructible[可原位构造^]。 \n" "抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效" "果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :918 #, safe-html, strict-same msgctxt ":918" msgid "---" msgstr "---" #: :920 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :921 #, safe-html, strict-same msgid "```c++ void insert(std::initializer_list); ```" msgstr "```c++ void insert(std::initializer_list); ```" #: :925 #, safe-html, strict-same msgctxt ":925" 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 "" "将一个范围内的元素插入容器中。当且仅当容器中没有具有等价键的元素时，才会插入" "这些元素。" #: :928 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] into the container. Throws:;; When inserting " "a single element, if an exception is thrown by an operation other than a " "call to `hasher` the function has no effect. Notes:;; Can invalidate " "iterators, but only if the insert causes the load to be greater than the " "maximum load." msgstr "" "要求：`value_type` 可以在容器中进行 https://en.cppreference.com/w/cpp/" "named_req/CopyInsertable[可拷贝插入^]。 \n" "抛出：当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无效" "果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :932 #, safe-html, strict-same msgctxt ":932" msgid "---" msgstr "---" #: :934 #, safe-html, strict-same msgid "Insert Node" msgstr "节点插入" #: :935 #, safe-html, strict-same msgid "```c++ insert_return_type insert(node_type&& nh); ```" msgstr "```c++ insert_return_type insert(node_type&& nh); ```" #: :939 #, safe-html, strict-same msgid "" "If `nh` is not empty, inserts the associated element in the container if and " "only if there is no element in the container with a key equivalent to `nh.key" "()`. `nh` is empty when the function returns." msgstr "" "如果 `nh` 非空，则当且仅当容器中没有键与 `nh.key()` 等价的元素时，才将关联的" "元素插入容器。函数返回时 `nh` 变为空。" #: :943 #, safe-html, strict-same msgid "" "Returns:;; An `insert_return_type` object constructed from `position`, " "`inserted` and `node`: +" msgstr "" "返回：一个 `insert_return_type` 对象，由 `position`、`inserted` 和 `node` 构" "造而成。" #: :944 #, safe-html, strict-same msgid "" "If `nh` is empty, `inserted` is `false`, `position` is `end()`, and `node` " "is empty." msgstr "" "若 `nh` 为空，则 `inserted` 为 `false` ， `position` 为 `end()` ，且 `node` " "为空。" #: :945 #, safe-html, strict-same msgid "" "Otherwise if the insertion took place, `inserted` is true, `position` points " "to the inserted element, and `node` is empty." msgstr "" "否则，若插入操作发生，则 `inserted` 为 `true` ， `position` 指向被插入的元素" "，且 `node` 为空。" #: :946 #, safe-html, strict-same msgid "" "If the insertion failed, `inserted` is false, `node` has the previous value " "of `nh`, and `position` points to an element with a key equivalent to `nh.key" "()`." msgstr "" "若插入操作失败，则 `inserted` 为 `false` ， `node` 保留 `nh` 的原始值，且 " "`position` 指向与 `nh.key()` 等效的元素。" #: :947 #, safe-html, strict-same msgid "" "Throws:;; If an exception is thrown by an operation other than a call to " "`hasher` the function has no effect. Notes:;; Behavior is undefined if `nh` " "is not empty and the allocators of `nh` and the container are not equal." msgstr "" "若 `nh` 非空，则当且仅当容器中不存在键等价于 `nh.key()` 的元素时，插入其关联" "元素。函数返回时 `nh` 为空。" #: :950 #, safe-html, strict-same msgctxt ":950" msgid "---" msgstr "---" #: :952 #, safe-html, strict-same msgid "Insert Node with Hint" msgstr "带提示的节点插入" #: :953 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" msgstr "" "```c++ iterator insert(const_iterator hint, node_type&& nh); ```" #: :957 #, safe-html, strict-same msgid "" "If `nh` is not empty, inserts the associated element in the container if and " "only if there is no element in the container with a key equivalent to `nh.key" "()`. `nh` becomes empty if insertion took place, otherwise it is not changed." msgstr "" "如果 `nh` 非空，则当且仅当容器中没有键与 `nh.key()` 等价的元素时，才将关联的" "元素插入容器。如果插入发生，则 `nh` 变为空；否则 `nh` 不变。" #: :960 #, safe-html, strict-same msgctxt ":960" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :963 #, safe-html, strict-same msgid "" "Returns:;; The iterator returned is `end()` if `nh` is empty. If insertion " "took place, then the iterator points to the newly inserted element; " "otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Behavior is undefined if `nh` is not empty " "and the allocators of `nh` and the container are not equal." msgstr "" "返回：如果 `nh` 为空，则返回的迭代器为 `end()`。如果插入发生，则迭代器指向新" "插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：如果 `nh` 非空且 `nh` 与容器的分配器不相等，则行为未定义。" #: :968 #, safe-html, strict-same msgctxt ":968" msgid "---" msgstr "---" #: :970 #, safe-html, strict-same msgid "try_emplace" msgstr "try_emplace" #: :971 #, 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++\n" "template\n" "std::pair try_emplace(const key_type& k, " "Args&&... args);\n" "template\n" "std::pair try_emplace(key_type&& k, " "Args&&... args);\n" "template\n" "std::pair try_emplace(K&& k, Args&&... " "args);\n" "```" #: :980 #, safe-html, strict-same msgctxt ":980" msgid "" "Inserts a new element into the container if there is no existing element " "with key `k` contained within it." msgstr "如果容器中不存在键为 `k` 的元素，则插入一个新元素。" #: :982 #, safe-html, strict-same msgctxt ":982" msgid "" "If there is an existing element with key `k` this function does nothing." msgstr "如果已存在键为 `k` 的元素，则该函数不执行任何操作。" #: :985 #, 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_node_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` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：此函数类似于 xref:#unordered_node_map_emplace[emplace]，区别在于如果存" "在具有等价键的元素，则不构造 `value_type`；否则，构造形式为： \n" "\n" "```c++" #: :995 #, safe-html, strict-same msgctxt ":995" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...))" msgstr "" "```c++\n" "value_type(std::piecewise_construct,\n" " std::forward_as_tuple(std::forward(k)),\n" " std::forward_as_tuple(std::forward(args)...))\n" "```" #: :1000 #, safe-html, strict-same msgctxt ":1000" 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)...)) ```" #: :1005 #, safe-html, strict-same msgid "" "unlike xref:#unordered_node_map_emplace[emplace], which simply forwards all " "arguments to ``value_type``'s constructor." msgstr "" "与 xref:#unordered_node_map_emplace[emplace] 不同，后者只是将所有参数直接转发" "给 `value_type` 的构造函数。" #: :1007 #, safe-html, strict-same msgctxt ":1007" msgid "" "Can invalidate iterators, but only if the insert causes the load to be " "greater than the maximum load." msgstr "可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :1009 #, safe-html, strict-same msgctxt ":1009" 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` 类型对象的开销。" #: :1011 #, safe-html, strict-same msgctxt ":1011" msgid "--" msgstr "--" #: :1013 #, safe-html, strict-same msgctxt ":1013" msgid "---" msgstr "---" #: :1015 #, safe-html, strict-same msgid "try_emplace with Hint" msgstr "带提示的 try_emplace" #: :1016 #, 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); ```" #: :1025 #, safe-html, strict-same msgctxt ":1025" msgid "" "Inserts a new element into the container if there is no existing element " "with key `k` contained within it." msgstr "如果容器中不存在键为 `k` 的元素，则插入一个新元素。" #: :1027 #, safe-html, strict-same msgctxt ":1027" msgid "" "If there is an existing element with key `k` this function does nothing." msgstr "如果已存在键为 `k` 的元素，则该函数不执行任何操作。" #: :1029 #, safe-html, strict-same msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :1032 #, 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_node_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 "" "返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" " \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：此函数类似于 xref:#unordered_node_map_emplace_hint[emplace_hint]，区别" "在于如果存在具有等价键的元素，则不构造 `value_type`；否则，构造形式为： \n" "\n" "```c++" #: :1040 #, safe-html, strict-same msgctxt ":1040" 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)...))" #: :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(args)...)) ```" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(args)...)) ```" #: :1050 #, safe-html, strict-same msgid "" "unlike xref:#unordered_node_map_emplace_hint[emplace_hint], which simply " "forwards all arguments to ``value_type``'s constructor." msgstr "" "与 xref:#unordered_node_map_emplace_hint[emplace_hint] 不同，后者只是将所有参" "数直接转发给 `value_type` 的构造函数。" #: :1052 #, safe-html, strict-same msgctxt ":1052" msgid "" "Can invalidate iterators, but only if the insert causes the load to be " "greater than the maximum load." msgstr "可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。" #: :1054 #, safe-html, strict-same msgctxt ":1054" 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` 类型对象的开销。" #: :1056 #, safe-html, strict-same msgctxt ":1056" msgid "--" msgstr "--" #: :1058 #, safe-html, strict-same msgctxt ":1058" msgid "---" msgstr "---" #: :1060 #, safe-html, strict-same msgid "insert_or_assign" msgstr "insert_or_assign" #: :1061 #, 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++\n" "template\n" "std::pair insert_or_assign(const key_type& k, " "M&& obj);\n" "template\n" "std::pair insert_or_assign(key_type&& k, " "M&& obj);\n" "template\n" "std::pair insert_or_assign(K&& k, M&& " "obj);\n" "```" #: :1070 #, safe-html, strict-same msgctxt ":1070" msgid "" "Inserts a new element into the container or updates an existing one by " "assigning to the contained value." msgstr "向容器中插入一个新元素，或通过赋值更新现有元素的值。" #: :1072 #, safe-html, strict-same msgctxt ":1072" msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "如果存在键为 `k` 的元素，则通过赋值 `std::forward(obj)` 来更新它。" #: :1074 #, safe-html, strict-same msgctxt ":1074" msgid "If there is no such element, it is added to the container as: ```c++" msgstr "" "如果不存在这样的元素，则将其添加到容器中，形式为： \n" "```c++" #: :1077 #, safe-html, strict-same msgctxt ":1077" msgid "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" msgstr "" "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward" "(k)), std::forward_as_tuple(std::forward(obj)))" #: :1082 #, safe-html, strict-same msgctxt ":1082" 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))) ```" #: :1088 #, safe-html, strict-same msgid "" "Returns:;; The `bool` component of the return type is `true` if an insert " "took place. + + If an insert took place, then the iterator points to the " "newly inserted element. Otherwise, it points to the element with equivalent " "key. Throws:;; If an exception is thrown by an operation other than a call " "to `hasher` the function has no effect. Notes:;; Can invalidate iterators, " "but only if the insert causes the load 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` 表示发生了插入。 \n" "如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "`template` 仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1096 #, safe-html, strict-same msgctxt ":1096" msgid "---" msgstr "---" #: :1098 #, safe-html, strict-same msgid "insert_or_assign with Hint" msgstr "带提示位置的 insert_or_assign" #: :1099 #, 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); ```" #: :1108 #, safe-html, strict-same msgctxt ":1108" msgid "" "Inserts a new element into the container or updates an existing one by " "assigning to the contained value." msgstr "向容器中插入一个新元素，或通过赋值更新现有元素的值。" #: :1110 #, safe-html, strict-same msgctxt ":1110" msgid "" "If there is an element with key `k`, then it is updated by assigning " "`std::forward(obj)`." msgstr "如果存在键为 `k` 的元素，则通过赋值 `std::forward(obj)` 来更新它。" #: :1112 #, safe-html, strict-same msgctxt ":1112" msgid "If there is no such element, it is added to the container as: ```c++" msgstr "" "如果不存在这样的元素，则将其添加到容器中，形式为： \n" "```c++" #: :1115 #, safe-html, strict-same msgctxt ":1115" 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)))" #: :1120 #, safe-html, strict-same msgctxt ":1120" 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))) ```" #: :1125 #, safe-html, strict-same msgctxt ":1125" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素插入位置的建议。此实现会忽略该建议。" #: :1128 #, 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, 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 "" "返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。" " \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "`template` 仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1134 #, safe-html, strict-same msgctxt ":1134" msgid "---" msgstr "---" #: :1137 #, safe-html, strict-same msgid "Erase by Position" msgstr "按位置擦除" #: :1145 #, safe-html, strict-same msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :1148 #, 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`。 \n" "抛出：不抛出任何异常。 \n" "注意：返回的不透明对象只能被丢弃或立即转换为 `iterator` 或 `const_iterator`。" #: :1153 #, safe-html, strict-same msgctxt ":1153" msgid "---" msgstr "---" #: :1155 #, safe-html, strict-same msgid "Erase by Key" msgstr "通过键擦除" #: :1156 #, 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); ```" #: :1161 #, safe-html, strict-same msgid "Erase all elements with key equivalent to `k`." msgstr "擦除所有键与 `k` 等价的元素。" #: :1164 #, safe-html, strict-same msgid "" "Returns:;; The number of elements erased. Throws:;; Only throws an exception " "if it is thrown by `hasher` or `key_equal`. Notes:;; The `template` " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. The library " "assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：被擦除的元素数量。 \n" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 " "`const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使" "用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 " "`Key` 类型对象的开销。" #: :1168 #, safe-html, strict-same msgctxt ":1168" msgid "---" msgstr "---" #: :1170 #, safe-html, strict-same msgid "Erase Range" msgstr "范围擦除" #: :1172 #, safe-html, strict-same msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```" msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```" #: :1176 #, safe-html, strict-same msgid "Erases the elements in the range from `first` to `last`." msgstr "Erases the elements in the range from `first` to `last`." #: :1179 #, safe-html, strict-same msgid "" "Returns:;; The iterator following the erased elements - i.e. `last`. " "Throws:;; Nothing in this implementation (neither the `hasher` nor the " "`key_equal` objects are called)." msgstr "" "返回：被擦除元素之后的迭代器——即 `last`。 \n" "抛出：在此实现中不抛出任何异常（既不调用 `hasher` 也不调用 `key_equal` 对象）" "。" #: :1182 #, safe-html, strict-same msgctxt ":1182" msgid "---" msgstr "---" #: :1184 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :1185 #, safe-html, strict-same msgid "" "```c++ void swap(unordered_node_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); ```" msgstr "" "```c++ void swap(unordered_node_map& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); " "```" #: :1191 #, safe-html, strict-same msgid "Swaps the contents of the container with the parameter." msgstr "交换容器的内容与参数的内容。" #: :1193 #, safe-html, strict-same msgctxt ":1193" 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1196 #, safe-html, strict-same msgid "Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping." msgstr "抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。" #: :1198 #, safe-html, strict-same msgctxt ":1198" msgid "---" msgstr "---" #: :1200 #, safe-html, strict-same msgid "Extract by Position" msgstr "通过位置提取" #: :1201 #, safe-html, strict-same msgid "```c++ node_type extract(const_iterator position); ```" msgstr "```c++ node_type extract(const_iterator position); ```" #: :1205 #, safe-html, strict-same msgid "Extracts the element pointed to by `position`." msgstr "提取 `position` 所指向的元素。" #: :1208 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` object holding the extracted element. Throws:;; " "Nothing." msgstr "" "返回：一个持有被提取元素的 `node_type` 对象。 \n" "抛出：不抛出任何异常。" #: :1211 #, safe-html, strict-same msgctxt ":1211" msgid "---" msgstr "---" #: :1213 #, safe-html, strict-same msgid "Extract by Key" msgstr "通过键提取" #: :1214 #, safe-html, strict-same msgid "" "```c++ node_type extract(const key_type& k); template node_type " "extract(K&& k); ```" msgstr "" "```c++ node_type extract(const key_type& k); template " "node_type extract(K&& k); ```" #: :1219 #, safe-html, strict-same msgid "Extracts the element with key equivalent to `k`, if it exists." msgstr "提取键与 `k` 等价的元素（如果存在）。" #: :1222 #, safe-html, strict-same msgid "" "Returns:;; A `node_type` object holding the extracted element, or empty if " "no element was extracted. Throws:;; Only throws an exception if it is thrown " "by `hasher` or `key_equal`. Notes:;; The `template` overload only " "participates in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：一个持有被提取元素的 `node_type` 对象；如果未提取到任何元素，则返回空。" " \n" "抛出：仅当 `hasher` 或 `key_equal` 抛出异常时才会抛出。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1226 #, safe-html, strict-same msgctxt ":1226" msgid "---" msgstr "---" #: :1228 #, safe-html, strict-same msgid "pull" msgstr "pull" #: :1229 #, safe-html, strict-same msgid "```c++ init_type pull(const_iterator position); ```" msgstr "```c++ init_type pull(const_iterator position); ```" #: :1233 #, 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`。" #: :1236 #, safe-html, strict-same msgctxt ":1236" msgid "---" msgstr "---" #: :1238 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :1239 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :1243 #, safe-html, strict-same msgid "Erases all elements in the container." msgstr "擦除容器中的所有元素。" #: :1246 #, 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()" "`" #: :1248 #, safe-html, strict-same msgctxt ":1248" msgid "---" msgstr "---" #: :1250 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :1251 #, safe-html, strict-same msgid "" "```c++ template void merge(unordered_node_map& source); template void merge" "(unordered_node_map&& source); ```" msgstr "" "```c++ template void merge" "(unordered_node_map& " "source); template void merge" "(unordered_node_map&& " "source); ```" #: :1258 #, safe-html, strict-same msgid "" "Transfers all the element nodes from `source` whose key is not already " "present in `*this`." msgstr "从 `source` 转移所有键在 `*this` 中尚未存在的元素节点。" #: :1261 #, safe-html, strict-same msgid "" "Requires:;; `this\\->get_allocator() == source.get_allocator()`. Notes:;; " "Invalidates iterators to the elements transferred. If the resulting size of " "`*this` is greater than its original maximum load, invalidates all iterators " "associated to `*this`." msgstr "" "要求：`this->get_allocator() == source.get_allocator()`。 \n" "注意：会使被转移元素的迭代器失效。如果 `*this` 的结果大小大于其原始最大负载，" "则会使与 `*this` 关联的所有迭代器失效。" #: :1266 #, safe-html, strict-same msgctxt ":1266" msgid "---" msgstr "---" #: :1268 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :1270 #, safe-html, strict-same msgid "get_allocator" msgstr "get_allocator" #: :1271 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const noexcept; ```" msgstr "``` allocator_type get_allocator() const noexcept; ```" #: :1276 #, safe-html, strict-same msgid "Returns:;; The container's allocator." msgstr "返回：容器的分配器。" #: :1278 #, safe-html, strict-same msgctxt ":1278" msgid "---" msgstr "---" #: :1280 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :1281 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :1286 #, safe-html, strict-same msgid "Returns:;; The container's hash function." msgstr "返回：容器的哈希函数。" #: :1288 #, safe-html, strict-same msgctxt ":1288" msgid "---" msgstr "---" #: :1290 #, safe-html, strict-same msgid "key_eq" msgstr "key_eq" #: :1291 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :1296 #, safe-html, strict-same msgid "Returns:;; The container's key equality predicate" msgstr "返回：容器的键相等谓词。" #: :1298 #, safe-html, strict-same msgctxt ":1298" msgid "---" msgstr "---" #: :1300 #, safe-html, strict-same msgid "Lookup" msgstr "查找" #: :1302 #, safe-html, strict-same msgid "find" msgstr "find" #: :1303 #, 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);" #: :1309 #, safe-html, strict-same msgid "```" msgstr "```" #: :1312 #, safe-html, strict-same msgid "" "Returns:;; An iterator pointing to an element with key equivalent to `k`, or " "`end()` if no such element exists. Notes:;; The `template` " "overloads only participate in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs. The library assumes " "that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：指向键与 `k` 等价的元素的迭代器；如果不存在这样的元素，则返回 `end()`。" " \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1315 #, safe-html, strict-same msgctxt ":1315" msgid "---" msgstr "---" #: :1317 #, safe-html, strict-same msgid "count" msgstr "count" #: :1318 #, 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; ```" #: :1325 #, safe-html, strict-same msgid "" "Returns:;; The number of elements with key equivalent to `k`. Notes:;; The " "`template` overload only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：键与 `k` 等价的元素数量。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1328 #, safe-html, strict-same msgctxt ":1328" msgid "---" msgstr "---" #: :1330 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1331 #, 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; ```" #: :1338 #, safe-html, strict-same msgid "" "Returns:;; A boolean indicating whether or not there is an element with key " "equal to `key` in the container Notes:;; The `template` overload " "only participates in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1341 #, safe-html, strict-same msgctxt ":1341" msgid "---" msgstr "---" #: :1343 #, safe-html, strict-same msgid "equal_range" msgstr "equal_range" #: :1344 #, 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; ```" "" #: :1354 #, safe-html, strict-same msgid "" "Returns:;; A range containing all elements with key equivalent to `k`. If " "the container doesn't contain any such elements, returns `std::make_pair" "(b.end(), b.end())`. Notes:;; The `template` overloads only " "participate in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：包含所有键与 `k` 等价的元素的范围。如果容器不包含任何此类元素，则返回 " "`std::make_pair(b.end(), b.end())`。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1357 #, safe-html, strict-same msgctxt ":1357" msgid "---" msgstr "---" #: :1359 #, safe-html, strict-same msgid "operator++[++++]++" msgstr "operator++[++++]++" #: :1360 #, 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); ```" #: :1367 #, 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, 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())`。 \n" "返回：对 `x.second` 的引用，其中 `x` 是容器中已存在的元素，或是新插入的键与 " "`k` 等价的元素。 \n" "抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。 \n" "注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。 \n" "\n" "`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1374 #, safe-html, strict-same msgctxt ":1374" msgid "---" msgstr "---" #: :1376 #, safe-html, strict-same msgid "at" msgstr "at" #: :1377 #, 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; ```" #: :1385 #, safe-html, strict-same msgid "" "Returns:;; A reference to `x.second` where `x` is the (unique) element whose " "key is equivalent to `k`. Throws:;; An exception object of type " "`std::out_of_range` if no such element is present. Notes:;; The " "`template` overloads only participate in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：对 `x.second` 的引用，其中 `x` 是键与 `k` 等价的（唯一）元素。 \n" "抛出：如果不存在这样的元素，则抛出 `std::out_of_range` 类型的异常对象。 \n" "注意：`template` 重载仅在 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可" "同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了" "实例化 `Key` 类型对象的开销。" #: :1389 #, safe-html, strict-same msgctxt ":1389" msgid "---" msgstr "---" #: :1391 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1393 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1394 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1399 #, safe-html, strict-same msgid "Returns:;; The size of the bucket array." msgstr "返回：桶数组的大小。" #: :1401 #, safe-html, strict-same msgctxt ":1401" msgid "---" msgstr "---" #: :1403 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1405 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1406 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1411 #, 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`。" #: :1413 #, safe-html, strict-same msgctxt ":1413" msgid "---" msgstr "---" #: :1415 #, safe-html, strict-same msgid "max_load_factor" msgstr "max_load_factor" #: :1417 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1422 #, safe-html, strict-same msgid "Returns:;; Returns the container's maximum load factor." msgstr "返回：容器的最大负载因子。" #: :1424 #, safe-html, strict-same msgctxt ":1424" msgid "---" msgstr "---" #: :1426 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1427 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1432 #, 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` 保持兼容。" #: :1434 #, safe-html, strict-same msgctxt ":1434" msgid "---" msgstr "---" #: :1437 #, safe-html, strict-same msgid "max_load" msgstr "max_load" #: :1439 #, safe-html, strict-same msgid "```c++ size_type max_load() const noexcept; ```" msgstr "```c++ size_type max_load() const noexcept; ```" #: :1444 #, safe-html, strict-same msgid "" "Returns:;; The maximum number of elements the container can hold without " "rehashing, assuming that no further elements will be erased. Note:;; After " "construction, rehash or clearance, the container's maximum load is at least " "`max_load_factor() * bucket_count()`. This number may decrease on erasure " "under high-load conditions." msgstr "" "返回：容器在不触发重哈希的情况下能够容纳的最大元素数量（假设不再有元素被擦除" "）。 \n" "注意：在构造、重哈希或清空操作之后，容器的最大负载至少为 `max_load_factor() " "* bucket_count()`。在高负载条件下，该数值可能会因元素擦除而减小。" #: :1448 #, safe-html, strict-same msgctxt ":1448" msgid "---" msgstr "---" #: :1450 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1451 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1455 #, 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()`。" #: :1457 #, 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)` 将释放底层的桶数组。如果提供的分配器使用异形" "指针，则会随后执行一次默认分配。" #: :1459 #, safe-html, strict-same msgctxt ":1459" msgid "Invalidates iterators and changes the order of elements." msgstr "使迭代器失效并改变元素的顺序。" #: :1462 #, safe-html, strict-same msgctxt ":1462" 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 "" "抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果" "。" #: :1464 #, safe-html, strict-same msgctxt ":1464" msgid "---" msgstr "---" #: :1466 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1467 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1471 #, safe-html, strict-same msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`." msgstr "等价于 `a.rehash(ceil(n / a.max_load_factor()))`。" #: :1473 #, 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` 类似，此函数可用于增大或缩小容器中的桶数量。" #: :1475 #, safe-html, strict-same msgctxt ":1475" msgid "Invalidates iterators and changes the order of elements." msgstr "使迭代器失效并改变元素的顺序。" #: :1478 #, safe-html, strict-same msgctxt ":1478" 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 "" "抛出：如果抛出异常（除非是由容器的哈希函数或比较函数抛出的），则该函数无效果" "。" #: :1480 #, safe-html, strict-same msgctxt ":1480" msgid "---" msgstr "---" #: :1482 #, safe-html, strict-same msgid "Statistics" msgstr "统计信息" #: :1484 #, safe-html, strict-same msgid "get_stats" msgstr "get_stats" #: :1485 #, safe-html, strict-same msgid "```c++ stats get_stats() const; ```" msgstr "```c++ stats get_stats() const; ```" #: :1490 #, safe-html, strict-same msgid "" "Returns:;; A statistical description of the insertion and lookup operations " "performed by the container so far. Notes:;; Only available if xref:reference/" "stats.adoc#stats[statistics calculation] is " "xref:unordered_node_map_boost_unordered_enable_stats[enabled]." msgstr "" "返回：容器迄今为止所执行插入和查找操作的统计描述。 \n" "注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 " "xref:unordered_node_map_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] " "启用时才可用。" #: :1493 #, safe-html, strict-same msgctxt ":1493" msgid "---" msgstr "---" #: :1495 #, safe-html, strict-same msgid "reset_stats" msgstr "reset_stats" #: :1496 #, safe-html, strict-same msgid "```c++ void reset_stats() noexcept; ```" msgstr "```c++ void reset_stats() noexcept; ```" #: :1501 #, safe-html, strict-same msgid "" "Effects:;; Sets to zero the internal statistics kept by the container. " "Notes:;; Only available if xref:reference/stats.adoc#stats[statistics " "calculation] is " "xref:unordered_node_map_boost_unordered_enable_stats[enabled]." msgstr "" "效果：将容器内部维护的统计信息归零。 \n" "注意：仅在 xref:reference/stats.adoc#stats[统计计算] 通过 " "xref:unordered_node_map_boost_unordered_enable_stats[`BOOST_UNORDERED_ENABLE_STATS`] " "启用时才可用。" #: :1504 #, safe-html, strict-same msgctxt ":1504" msgid "---" msgstr "---" #: :1506 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1507 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "如果以下任何一条件为真，则推导指引将不参与重载决议：" #: :1509 #, safe-html, strict-same msgid "" "- It has an `InputIterator` template parameter and a type that does not " "qualify as an input iterator is deduced for that parameter. - It has an " "`Allocator` template parameter and a type that does not qualify as an " "allocator is deduced for that parameter. - It has a `Hash` template " "parameter and an integral type or a type that qualifies as an allocator is " "deduced for that parameter. - It has a `Pred` template parameter and a type " "that qualifies as an allocator is deduced for that parameter." msgstr "" "- 它具有一个 `InputIterator` 模板参数，并且为该参数推导出的类型不符合输入迭代" "器的要求。\n" "- 它具有一个 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要求" "。\n" "- 它具有一个 `Hash` 模板参数，并且为该参数推导出的类型是整数类型或符合分配器" "的要求。\n" "- 它具有一个 `Pred` 模板参数，并且为该参数推导出的类型符合分配器的要求。" #: :1514 #, 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` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1518 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "_iter-value-type_" #: :1526 #, safe-html, strict-same msgid "__iter-key-type__" msgstr "__iter-key-type__" #: :1534 #, safe-html, strict-same msgid "__iter-mapped-type__" msgstr "__iter-mapped-type__" #: :1542 #, safe-html, strict-same msgid "__iter-to-alloc-type__" msgstr "__iter-to-alloc-type__" #: :1551 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1553 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1554 #, safe-html, strict-same msgid "" "```c++ template " "bool operator==(const unordered_node_map& x, " "const unordered_node_map& y); ```" msgstr "" "```c++ template bool operator==(const unordered_node_map& x, const unordered_node_map& y); ```" #: :1560 #, 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`。" #: :1563 #, safe-html, strict-same msgctxt ":1563" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1565 #, safe-html, strict-same msgctxt ":1565" msgid "---" msgstr "---" #: :1567 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1568 #, safe-html, strict-same msgid "" "```c++ template " "bool operator!=(const unordered_node_map& x, " "const unordered_node_map& y); ```" msgstr "" "```c++ template bool operator!=(const unordered_node_map& x, const unordered_node_map& y); ```" #: :1574 #, 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`。" #: :1577 #, safe-html, strict-same msgctxt ":1577" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "注意：如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1579 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1580 #, safe-html, strict-same msgid "" "```c++ template " "void swap(unordered_node_map& x, " "unordered_node_map& y) noexcept(noexcept(x.swap" "(y))); ```" msgstr "" "```c++ template void swap(unordered_node_map& x, unordered_node_map& y) noexcept(noexcept(x.swap(y))); ```" #: :1587 #, safe-html, strict-same msgid "Swaps the contents of `x` and `y`." msgstr "交换 `x` 和 `y` 的内容。" #: :1589 #, safe-html, strict-same msgctxt ":1589" 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`，则交换容器的分配器" "。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1592 #, safe-html, strict-same msgid "" "Effects:;; `x.swap(y)` Throws:;; Nothing unless `key_equal` or `hasher` " "throw on swapping." msgstr "" "效果：`x.swap(y)` \n" "抛出：除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。" #: :1595 #, safe-html, strict-same msgctxt ":1595" msgid "---" msgstr "---" #: :1597 #, safe-html, strict-same msgid "erase_if" msgstr "erase_if" #: :1598 #, safe-html, strict-same msgid "" "```c++ template typename unordered_node_map::size_type erase_if" "(unordered_node_map& c, Predicate pred); ```" msgstr "" "```c++ template typename unordered_node_map::size_type erase_if(unordered_node_map& c, Predicate pred); ```" #: :1604 #, safe-html, strict-same msgid "" "Traverses the container `c` and removes all elements for which the supplied " "predicate returns `true`." msgstr "遍历容器 `c`，并移除所有使给定谓词返回 `true` 的元素。" #: :1607 #, safe-html, strict-same msgid "" "Returns:;; The number of erased elements. Notes:;; Equivalent to: + + ```c++ " "auto original_size = c.size(); for (auto i = c.begin(), last = c.end(); i != " "last; ) { if (pred(*i)) { i = c.erase(i); } else { ++i; } } return " "original_size - c.size(); ``` + Note that the references passed to `pred` " "are non-const." msgstr "" "返回：被擦除的元素数量。 \n" "注意：等价于： \n" "```c++\n" "auto original_size = c.size();\n" "for (auto i = c.begin(), last = c.end(); i != last; ) {\n" " if (pred(*i)) {\n" " i = c.erase(i);\n" " } else {\n" " ++i;\n" " }\n" "}\n" "return original_size - c.size();\n" "``` \n" "注意，传递给 `pred` 的引用是非常量的。" #: :1624 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1626 #, safe-html, strict-same msgid "" "``unordered_node_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_node_map` 可以通过本库提供的 API，借助 link:../../../../../" "serialization/index.html[Boost.Serialization^] 进行归档/恢复。支持常规归档和 " "XML 归档。" #: :1630 #, safe-html, strict-same msgid "Saving an unordered_node_map to an archive" msgstr "将 unordered_node_map 保存到归档中" #: :1632 #, safe-html, strict-same msgid "" "Saves all the elements of an `unordered_node_map` `x` to an archive (XML " "archive) `ar`." msgstr "将 `unordered_node_map` `x` 的所有元素保存到归档（XML 归档） `ar` 。" #: :1635 #, 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 归档需支持 XML 序列化），并且它们必须支持 " "Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（该协" "议由满足 https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[可" "默认构造^] 的类型自动支持）。" #: :1641 #, safe-html, strict-same msgctxt ":1641" msgid "---" msgstr "---" #: :1643 #, safe-html, strict-same msgid "Loading an unordered_node_map from an archive" msgstr "从归档中加载 unordered_node_map" #: :1645 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of an `unordered_node_map` `x` and inserts " "from an archive (XML archive) `ar` restored copies of the elements of the " "original `unordered_node_map` `other` saved to the storage read by `ar`." msgstr "" "删除 `unordered_node_map` 容器 `x` 中所有已存在的元素，并从归档（XML 归档" "）`ar` 中插入从原始 `unordered_node_map` 容器 `other` 保存到 `ar` 所读取存储" "中的元素恢复出的副本。" #: :1650 #, safe-html, strict-same msgid "" "Requires:;; `key_type` and `mapped_type` are constructible from " "`std::remove_const::type&&` and `std::remove_const" "::type&&`, respectively. `x.key_equal()` is functionally equivalent to " "`other.key_equal()`." msgstr "" "要求：`key_type` 和 `mapped_type` 必须分别能够从 `std::remove_const" "::type&&` 和 `std::remove_const::type&&` 构造" "。`x.key_equal()` 在功能上必须等价于 `other.key_equal()`。" #: :1655 #, safe-html, strict-same msgctxt ":1655" msgid "---" msgstr "---" #: :1657 #, safe-html, strict-same msgid "Saving an iterator/const_iterator to an archive" msgstr "将迭代器/常量迭代器保存到归档" #: :1659 #, safe-html, strict-same msgid "" "Saves the positional information of an `iterator` (`const_iterator`) `it` to " "an archive (XML archive) `ar`. `it` can be and `end()` iterator." msgstr "" "将迭代器（或常量迭代器）`it` 的位置信息保存到归档（XML 归档）`ar` 中。`it` 可" "以是一个 `end()` 迭代器。" #: :1663 #, safe-html, strict-same msgid "" "Requires:;; The `unordered_node_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_node_map` 容器 `x` 必须先被保存到 `ar` 中，并" "且在保存 `x` 和保存 `it` 之间，不能对 `x` 执行任何修改操作。" #: :1667 #, safe-html, strict-same msgctxt ":1667" msgid "---" msgstr "---" #: :1669 #, safe-html, strict-same msgid "Loading an iterator/const_iterator from an archive" msgstr "从归档加载迭代器/常量迭代器" #: :1671 #, safe-html, strict-same msgid "" "Makes an `iterator` (`const_iterator`) `it` point to the restored position " "of the original `iterator` (`const_iterator`) saved to the storage read by " "an archive (XML archive) `ar`." msgstr "" "使迭代器（或常量迭代器）`it` 指向原始迭代器（或常量迭代器）被保存到归档（XML " "归档）`ar` 所读取存储中的位置恢复后的位置。" #: :1676 #, safe-html, strict-same msgid "" "Requires:;; If `x` is the `unordered_node_map` `it` points to, no modifying " "operations have been issued on `x` between loading of `x` and loading of " "`it`." msgstr "" "要求：如果 `x` 是 `it` 所指向的 `unordered_node_map` 容器，则在加载 `x` 和加" "载 `it` 之间，不能对 `x` 执行任何修改操作。"