msgid "" msgstr "" "Project-Id-Version: Chinese (Simplified Han script) (Boost Unordered " "Translation (zh_Hans))\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-06-07 03:31+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: Chinese (Simplified Han script) \n" "Language: zh_Hans\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" "X-Generator: Weblate 2026.5\n" #: :2 #, safe-html, strict-same msgid "Class Template unordered_flat_set" msgstr "类模板 unordered_flat_set" #: :4 #, safe-html, strict-same msgid ":idprefix: unordered_flat_set_" msgstr ":idprefix: unordered_flat_set_" #: :6 #, safe-html, strict-same msgid "" "`boost::unordered_flat_set` — An open-addressing unordered associative " "container that stores unique values." msgstr "`boost::unordered_flat_set` — 一种开放定址无序关联容器，用于存储唯一值。" #: :8 #, safe-html, strict-same msgid "" "The performance of `boost::unordered_flat_set` is much better than that of " "`boost::unordered_set` or other implementations of `std::unordered_set`. " "Unlike standard unordered associative containers, which are node-based, the " "elements of a `boost::unordered_flat_set` are held directly in the bucket " "array, and insertions into an already occupied bucket are diverted to " "available buckets in the vicinity of the original position. This type of " "data layout is known as _open addressing_." msgstr "" "`boost::unordered_flat_set` 的性能远优于 `boost::unordered_set` 或 " "`std::unordered_set` 的其他实现。与基于节点的标准无序关联容器不同" "，`boost::unordered_flat_set` 的元素直接保存在桶数组中，当插入位置已被占用时" "，会转移到原始位置附近可用的桶中。这种数据布局称为**开放定址**。" #: :14 #, safe-html, strict-same msgid "" "As a result of its using open addressing, the interface of " "`boost::unordered_flat_set` deviates in a number of aspects from that of " "`boost::unordered_flat_set`/`std::unordered_flat_set`:" msgstr "" "由于采用开放定址，`boost::unordered_flat_set` 的接口在多个方面与 " "`boost::unordered_set`/`std::unordered_set` 存在差异：" #: :17 #, safe-html, strict-same msgid "" "- `value_type` must be move-constructible. - Pointer stability is not kept " "under rehashing. - `begin()` is not constant-time. - There is no API for " "bucket handling (except `bucket_count`) or node extraction/insertion. - The " "maximum load factor of the container is managed internally and can't be set " "by the user." msgstr "" "- `value_type` 必须可移动构造。\n" "- 在重哈希过程中不保持指针稳定性。\n" "- `begin()` 不是常数时间操作。\n" "- 没有用于桶操作的 API（除了 `bucket_count`），也没有节点提取/插入的 API。\n" "- 容器的最大负载因子由内部管理，用户无法设置。" #: :23 #, safe-html, strict-same msgid "" "Other than this, `boost::unordered_flat_set` is mostly a drop-in replacement " "of node-based standard unordered associative containers." msgstr "" "除此之外，`boost::unordered_flat_set` 基本上是基于节点的标准无序关联容器的直" "接替代品。" #: :26 #, safe-html, strict-same msgid "Synopsis" msgstr "概要" #: :235 #, safe-html, strict-same msgctxt ":235" msgid "---" msgstr "---" #: :237 #, safe-html, strict-same msgid "Description" msgstr "描述" #: :239 #, safe-html, strict-same msgid "*Template Parameters*" msgstr "*模板参数*" #: :242 #, safe-html, strict-same msgid "_Key_" msgstr "_键_" #: :242 #, safe-html, strict-same msgid "" "`Key` must be https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^] into the container" msgstr "" "`Key` 必须可以 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^] 到容器中" #: :246 #, safe-html, strict-same msgid "" "and https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the " "container." msgstr "" "并且可以从容器中 https://en.cppreference.com/w/cpp/named_req/" "Erasable[Erasable^]。" #: :248 #, safe-html, strict-same msgid "_Hash_" msgstr "_Hash_" #: :248 #, 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` 类型的值。" #: :248 #, safe-html, strict-same msgid "_Pred_" msgstr "_Pred_" #: :248 #, 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` 类型的值。" #: :248 #, safe-html, strict-same msgid "_Allocator_" msgstr "_Allocator_" #: :248 #, safe-html, strict-same msgid "" "An allocator whose value type is the same as the container's value type." msgstr "一种分配器，其值类型与容器的值类型相同。" #: :256 #, 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[fancy pointers] 的分配器。" #: :260 #, safe-html, strict-same msgid "" "The elements of the container are held into an internal _bucket array_. An " "element is inserted into a bucket determined by its hash code, but if the " "bucket is already occupied (a _collision_), an available one in the vicinity " "of the original position is used." msgstr "" "容器的元素保存在内部的**桶数组**中。元素根据其哈希码被插入到对应的桶中，但如" "果该桶已被占用（发生**冲突**），则会使用原始位置附近的一个可用桶。" #: :264 #, 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()`，但在容量较小的情况下，实现可能会允许更高的负载。" #: :269 #, 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`，则哈希函数将按原样使用；否则，将添加一个比特混合后处理阶段，以增加哈" "希质量，但会增加额外的计算成本。" #: :273 #, safe-html, strict-same msgctxt ":273" msgid "---" msgstr "---" #: :275 #, safe-html, strict-same msgid "Configuration Macros" msgstr "配置宏" #: :277 #, safe-html, strict-same msgid "`BOOST_UNORDERED_ENABLE_STATS`" msgstr "`BOOST_UNORDERED_ENABLE_STATS`" #: :279 #, 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[统计信息计算]。请注" "意，此选项会降低许多操作的整体性能。" #: :282 #, safe-html, strict-same msgctxt ":282" msgid "---" msgstr "---" #: :284 #, safe-html, strict-same msgid "Typedefs" msgstr "类型定义" #: :291 #, safe-html, strict-same msgctxt ":291" msgid "A constant iterator whose value type is `value_type`." msgstr "一种常量迭代器，其值类型为 `value_type`。" #: :293 #, safe-html, strict-same msgctxt ":293" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :295 #, safe-html, strict-same msgid "Convertible to `const_iterator`." msgstr "可转换为 `const_iterator`。" #: :297 #, safe-html, strict-same msgctxt ":297" msgid "---" msgstr "---" #: :304 #, safe-html, strict-same msgctxt ":304" msgid "A constant iterator whose value type is `value_type`." msgstr "一种常量迭代器，其值类型为 `value_type`。" #: :306 #, safe-html, strict-same msgctxt ":306" msgid "The iterator category is at least a forward iterator." msgstr "迭代器类别至少为前向迭代器。" #: :308 #, safe-html, strict-same msgid "Constructors" msgstr "构造函数" #: :310 #, safe-html, strict-same msgid "Default Constructor" msgstr "默认构造函数" #: :311 #, safe-html, strict-same msgid "```c++ unordered_flat_set(); ```" msgstr "```c++ unordered_flat_set(); ```" #: :315 #, 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()` 作为分配器，构造一个空容器。" #: :319 #, safe-html, strict-same msgctxt ":319" 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[DefaultConstructible^]。" #: :322 #, safe-html, strict-same msgctxt ":322" msgid "---" msgstr "---" #: :324 #, safe-html, strict-same msgid "Bucket Count Constructor" msgstr "桶数构造函数" #: :325 #, safe-html, strict-same msgid "" "```c++ explicit unordered_flat_set(size_type n, const hasher& hf = hasher(), " "const key_equal& eql = key_equal(), const allocator_type& a = allocator_type" "()); ```" msgstr "" "```c++ explicit unordered_flat_set(size_type n, const hasher& hf = hasher" "(), const key_equal& eql = key_equal(), const allocator_type& a = " "allocator_type()); ```" #: :332 #, 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` 作为分配器。" #: :336 #, safe-html, strict-same msgctxt ":336" 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[DefaultConstructible^]。" #: :339 #, safe-html, strict-same msgctxt ":339" msgid "---" msgstr "---" #: :341 #, safe-html, strict-same msgid "Iterator Range Constructor" msgstr "迭代器范围构造函数" #: :352 #, 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)` 范围内的元素插入其中。" #: :355 #, safe-html, strict-same msgctxt ":355" 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[DefaultConstructible^]。" #: :357 #, safe-html, strict-same msgctxt ":357" msgid "---" msgstr "---" #: :359 #, safe-html, strict-same msgid "Copy Constructor" msgstr "复制构造函数" #: :360 #, safe-html, strict-same msgid "```c++ unordered_flat_set(unordered_flat_set const& other); ```" msgstr "```c++ unordered_flat_set(unordered_flat_set const& other); ```" #: :364 #, safe-html, strict-same msgid "" "The copy constructor. Copies the contained elements, hash function, " "predicate and allocator." msgstr "复制构造函数。复制所包含的元素、哈希函数、谓词和分配器。" #: :366 #, 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` 存在且具有正确的签名" "，则分配器将根据其结果进行构造。" #: :369 #, safe-html, strict-same msgid "Requires:;; `value_type` is copy constructible" msgstr "要求：;; `value_type` 可复制构造。" #: :371 #, safe-html, strict-same msgctxt ":371" msgid "---" msgstr "---" #: :373 #, safe-html, strict-same msgid "Move Constructor" msgstr "移动构造函数" #: :374 #, safe-html, strict-same msgid "```c++ unordered_flat_set(unordered_flat_set&& other); ```" msgstr "```c++ unordered_flat_set(unordered_flat_set&& other); ```" #: :378 #, safe-html, strict-same msgid "" "The move constructor. The internal bucket array of `other` is transferred " "directly to the new container. The hash function, predicate and allocator " "are moved-constructed from `other`. If statistics are " "xref:unordered_flat_set_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "移动构造函数。`other` 的内部桶数组将直接转移给新容器。哈希函数、谓词和分配器" "从 `other` 进行移动构造。如果启用了统计信息（" "xref:unordered_flat_set_boost_unordered_enable_stats[enabled]），则从 " "`other` 转移内部统计信息，并调用 `other.reset_stats()`。" #: :383 #, safe-html, strict-same msgctxt ":383" msgid "---" msgstr "---" #: :385 #, safe-html, strict-same msgid "Iterator Range Constructor with Allocator" msgstr "带分配器的迭代器区间构造函数" #: :386 #, safe-html, strict-same msgid "" "```c++ template unordered_flat_set(InputIterator f, " "InputIterator l, const allocator_type& a); ```" msgstr "" "```c++ template unordered_flat_set(InputIterator " "f, InputIterator l, const allocator_type& a); ```" #: :391 #, 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)" "` 范围内的元素插入其中。" #: :394 #, safe-html, strict-same msgctxt ":394" 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[DefaultConstructible^]。" #: :396 #, safe-html, strict-same msgctxt ":396" msgid "---" msgstr "---" #: :398 #, safe-html, strict-same msgid "Allocator Constructor" msgstr "分配器构造函数" #: :399 #, safe-html, strict-same msgid "```c++ explicit unordered_flat_set(Allocator const& a); ```" msgstr "```c++ explicit unordered_flat_set(Allocator const& a); ```" #: :403 #, safe-html, strict-same msgid "Constructs an empty container, using allocator `a`." msgstr "构造一个空容器，使用分配器 `a`。" #: :405 #, safe-html, strict-same msgctxt ":405" msgid "---" msgstr "---" #: :407 #, safe-html, strict-same msgid "Copy Constructor with Allocator" msgstr "带分配器的复制构造函数" #: :408 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(unordered_flat_set const& other, Allocator const& " "a); ```" msgstr "" "```c++ unordered_flat_set(unordered_flat_set const& other, Allocator " "const& a); ```" #: :412 #, safe-html, strict-same msgid "" "Constructs a container, copying ``other``'s contained elements, hash " "function, and predicate, but using allocator `a`." msgstr "构造一个容器，复制 `other` 所包含的元素、哈希函数和谓词，但使用分配器 `a`。" #: :414 #, safe-html, strict-same msgctxt ":414" msgid "---" msgstr "---" #: :416 #, safe-html, strict-same msgid "Move Constructor with Allocator" msgstr "带分配器的移动构造函数" #: :417 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(unordered_flat_set&& other, Allocator const& a); " "```" msgstr "" "```c++ unordered_flat_set(unordered_flat_set&& other, Allocator " "const& a); ```" #: :421 #, safe-html, strict-same msgid "" "If `a == other.get_allocator()`, the elements of `other` are transferred " "directly to the new container; otherwise, elements are moved-constructed " "from those of `other`. The hash function and predicate are moved-constructed " "from `other`, and the allocator is copy-constructed from `a`. If statistics " "are xref:unordered_flat_set_boost_unordered_enable_stats[enabled], transfers " "the internal statistical information from `other` iff `a == " "other.get_allocator()`, and always calls `other.reset_stats()`." msgstr "" "如果 `a == other.get_allocator()`，则 `other` 的元素会直接转移给新容器；否则" "，将根据 `other` 中的元素进行移动构造。哈希函数和谓词从 `other` 进行移动构造" "，而分配器则从 `a` 进行复制构造。如果启用了统计信息（" "xref:unordered_flat_set_boost_unordered_enable_stats[enabled]），则仅当 `a " "== other.get_allocator()` 时才从 `other` 转移内部统计信息，并且总是调用 " "`other.reset_stats()`。" #: :428 #, safe-html, strict-same msgctxt ":428" msgid "---" msgstr "---" #: :430 #, safe-html, strict-same msgid "Move Constructor from concurrent_flat_set" msgstr "从 concurrent_flat_set 移动构造" #: :432 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(concurrent_flat_set&& " "other); ```" msgstr "" "```c++ unordered_flat_set(concurrent_flat_set&& other); ```" #: :436 #, safe-html, strict-same msgid "" "Move construction from a xref:#concurrent_flat_set[`concurrent_flat_set`]. " "The internal bucket array of `other` is transferred directly to the new " "container. The hash function, predicate and allocator are moved-constructed " "from `other`. If statistics are " "xref:unordered_flat_set_boost_unordered_enable_stats[enabled], transfers the " "internal statistical information from `other` and calls `other.reset_stats()" "`." msgstr "" "从 xref:#concurrent_flat_set[`concurrent_flat_set`] 进行移动构造。`other` 的" "内部桶数组将直接转移给新容器。哈希函数、谓词和分配器从 `other` 进行移动构造。" "如果启用了统计信息（" "xref:unordered_flat_set_boost_unordered_enable_stats[enabled]），则从 " "`other` 转移内部统计信息，并调用 `other.reset_stats()`。" #: :443 #, safe-html, strict-same msgid "Complexity:;; Constant time. Concurrency:;; Blocking on `other`." msgstr "" "复杂度：;; 常数时间。\n" "并发性：;; 在 `other` 上阻塞。" #: :446 #, safe-html, strict-same msgctxt ":446" msgid "---" msgstr "---" #: :448 #, safe-html, strict-same msgid "Initializer List Constructor" msgstr "初始化列表构造函数" #: :458 #, 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` 中的元素插入其中。" #: :461 #, safe-html, strict-same msgctxt ":461" 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[DefaultConstructible^]。" #: :463 #, safe-html, strict-same msgctxt ":463" msgid "---" msgstr "---" #: :465 #, safe-html, strict-same msgid "Bucket Count Constructor with Allocator" msgstr "带分配器的桶数构造函数" #: :466 #, safe-html, strict-same msgid "```c++ unordered_flat_set(size_type n, allocator_type const& a); ```" msgstr "" "```c++ unordered_flat_set(size_type n, allocator_type const& a); ```" #: :470 #, 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` 作为分配器。" #: :473 #, 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[DefaultConstructible^]。" #: :476 #, safe-html, strict-same msgctxt ":476" msgid "---" msgstr "---" #: :478 #, safe-html, strict-same msgid "Bucket Count Constructor with Hasher and Allocator" msgstr "带哈希函数和分配器的桶数构造函数" #: :479 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(size_type n, hasher const& hf, allocator_type " "const& a); ```" msgstr "" "```c++ unordered_flat_set(size_type n, hasher const& hf, allocator_type " "const& a); ```" #: :483 #, 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` 作为分配器。" #: :486 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://" "en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]." msgstr "" "后置条件：;; `size() == 0`\n" "要求：;; `key_equal` 需要是 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^]。" #: :489 #, safe-html, strict-same msgctxt ":489" msgid "---" msgstr "---" #: :491 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的迭代器范围构造函数" #: :498 #, 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)` 范围内的元素插入其中。" #: :501 #, safe-html, strict-same msgctxt ":501" 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[DefaultConstructible^]。" #: :503 #, safe-html, strict-same msgctxt ":503" msgid "---" msgstr "---" #: :505 #, safe-html, strict-same msgid "Iterator Range Constructor with Bucket Count and Hasher" msgstr "带桶数和哈希函数的迭代器范围构造函数" #: :513 #, 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)` 范围内的元素插入其中。" #: :516 #, safe-html, strict-same msgctxt ":516" 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[DefaultConstructible^]。" #: :518 #, safe-html, strict-same msgctxt ":518" msgid "---" msgstr "---" #: :520 #, safe-html, strict-same msgid "initializer_list Constructor with Allocator" msgstr "带分配器的初始化列表构造函数" #: :522 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(std::initializer_list il, const " "allocator_type& a); ```" msgstr "" "```c++ unordered_flat_set(std::initializer_list il, const " "allocator_type& a); ```" #: :526 #, 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` 中的元素插入" "其中。" #: :529 #, safe-html, strict-same msgctxt ":529" 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[DefaultConstructible^]。" #: :531 #, safe-html, strict-same msgctxt ":531" msgid "---" msgstr "---" #: :533 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Allocator" msgstr "带桶数和分配器的初始化列表构造函数" #: :535 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(std::initializer_list il, size_type n, " "const allocator_type& a); ```" msgstr "" "```c++ unordered_flat_set(std::initializer_list il, size_type n, " "const allocator_type& a); ```" #: :539 #, safe-html, strict-same msgid "" "Constructs an empty container with at least `n` buckets, using `a` and " "default hash function and key equality predicate, and inserts the elements " "from `il` into it." msgstr "" "构造一个至少包含 `n` 个桶的空容器，使用 `a` 以及默认的哈希函数和键相等谓词，" "并将 `il` 中的元素插入其中。" #: :542 #, safe-html, strict-same msgctxt ":542" 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[DefaultConstructible^]。" #: :544 #, safe-html, strict-same msgctxt ":544" msgid "---" msgstr "---" #: :546 #, safe-html, strict-same msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator" msgstr "带桶数、哈希函数和分配器的初始化列表构造函数" #: :548 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" msgstr "" "```c++ unordered_flat_set(std::initializer_list il, size_type n, " "const hasher& hf, const allocator_type& a); ```" #: :553 #, 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` 中的元素插入其中。" #: :556 #, safe-html, strict-same msgctxt ":556" 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[DefaultConstructible^]。" #: :558 #, safe-html, strict-same msgctxt ":558" msgid "---" msgstr "---" #: :560 #, safe-html, strict-same msgid "Destructor" msgstr "析构函数" #: :562 #, safe-html, strict-same msgid "```c++ ~unordered_flat_set(); ```" msgstr "```c++ ~unordered_flat_set(); ```" #: :567 #, safe-html, strict-same msgid "" "Note:;; The destructor is applied to every element, and all memory is " "deallocated" msgstr "注意：;; 析构函数会应用于每个元素，并且所有内存都会被释放。" #: :569 #, safe-html, strict-same msgctxt ":569" msgid "---" msgstr "---" #: :571 #, safe-html, strict-same msgid "Assignment" msgstr "赋值操作" #: :573 #, safe-html, strict-same msgid "Copy Assignment" msgstr "复制赋值" #: :575 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set& operator=(unordered_flat_set const& other); ```" msgstr "" "```c++ unordered_flat_set& operator=(unordered_flat_set const& other)" "; ```" #: :579 #, 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` 元素的副本。" #: :584 #, safe-html, strict-same msgctxt ":584" 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[CopyInsertable^]。" #: :586 #, safe-html, strict-same msgctxt ":586" msgid "---" msgstr "---" #: :588 #, safe-html, strict-same msgid "Move Assignment" msgstr "移动赋值" #: :589 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set& operator=(unordered_flat_set&& other) noexcept(" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits" "::propagate_on_container_move_assignment::value) && std::is_same::value); ``` The move assignment operator. Destroys previously " "existing elements, swaps the hash function and predicate from `other`, and " "move-assigns the allocator from `other` if " "`Alloc::propagate_on_container_move_assignment` exists and " "`Alloc::propagate_on_container_move_assignment::value` is `true`. If at this " "point the allocator is equal to `other.get_allocator()`, the internal bucket " "array of `other` is transferred directly to the new container; otherwise, " "inserts move-constructed copies of the elements of `other`. If statistics " "are xref:unordered_flat_set_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_flat_set& operator=(unordered_flat_set&& 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_flat_set_boost_unordered_enable_stats[enabled]），则仅当最终的" "分配器等于 `other.get_allocator()` 时才从 `other` 转移内部统计信息，并且总是" "调用 `other.reset_stats()`。" #: :603 #, safe-html, strict-same msgctxt ":603" msgid "---" msgstr "---" #: :605 #, safe-html, strict-same msgid "Initializer List Assignment" msgstr "初始化列表赋值" #: :606 #, safe-html, strict-same msgid "" "```c++ unordered_flat_set& operator=(std::initializer_list il); " "```" msgstr "" "```c++ unordered_flat_set& operator=(std::initializer_list " "il); ```" #: :610 #, safe-html, strict-same msgid "" "Assign from values in initializer list. All previously existing elements are " "destroyed." msgstr "从初始化列表中的值进行赋值。所有先前存在的元素均被销毁。" #: :613 #, safe-html, strict-same msgctxt ":613" 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[CopyInsertable^]。" #: :615 #, safe-html, strict-same msgid "Iterators" msgstr "迭代器" #: :617 #, safe-html, strict-same msgid "begin" msgstr "begin" #: :618 #, safe-html, strict-same msgid "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" msgstr "" "```c++ iterator begin() noexcept; const_iterator begin() const noexcept; ```" #: :624 #, 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()`)" #: :627 #, safe-html, strict-same msgctxt ":627" msgid "---" msgstr "---" #: :629 #, safe-html, strict-same msgid "end" msgstr "end" #: :630 #, safe-html, strict-same msgid "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" msgstr "" "```c++ iterator end() noexcept; const_iterator end() const noexcept; ```" #: :636 #, safe-html, strict-same msgid "" "Returns:;; An iterator which refers to the past-the-end value for the " "container." msgstr "返回：;; 指向容器尾后值的迭代器。" #: :638 #, safe-html, strict-same msgctxt ":638" msgid "---" msgstr "---" #: :640 #, safe-html, strict-same msgid "cbegin" msgstr "cbegin" #: :641 #, safe-html, strict-same msgid "```c++ const_iterator cbegin() const noexcept; ```" msgstr "```c++ const_iterator cbegin() const noexcept; ```" #: :646 #, 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 "" "返回：;; 指向容器第一个元素的常量迭代器，若容器为空，则返回容器的尾后常量迭代" "器。\n" "复杂度：;; O(`bucket_count()`)" #: :649 #, safe-html, strict-same msgctxt ":649" msgid "---" msgstr "---" #: :651 #, safe-html, strict-same msgid "cend" msgstr "cend" #: :652 #, safe-html, strict-same msgid "```c++ const_iterator cend() const noexcept; ```" msgstr "```c++ const_iterator cend() const noexcept; ```" #: :657 #, safe-html, strict-same msgid "" "Returns:;; A `const_iterator` which refers to the past-the-end value for the " "container." msgstr "返回：;; 指向容器尾后值的常量迭代器。" #: :659 #, safe-html, strict-same msgctxt ":659" msgid "---" msgstr "---" #: :661 #, safe-html, strict-same msgid "Size and Capacity" msgstr "大小与容量" #: :663 #, safe-html, strict-same msgid "empty" msgstr "空" #: :665 #, safe-html, strict-same msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```" msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```" #: :670 #, safe-html, strict-same msgid "Returns:;; `size() == 0`" msgstr "返回：;; `size() == 0`" #: :672 #, safe-html, strict-same msgctxt ":672" msgid "---" msgstr "---" #: :674 #, safe-html, strict-same msgid "size" msgstr "大小" #: :676 #, safe-html, strict-same msgid "```c++ size_type size() const noexcept; ```" msgstr "```c++ size_type size() const noexcept; ```" #: :681 #, safe-html, strict-same msgid "Returns:;; `std::distance(begin(), end())`" msgstr "返回：;; `std::distance(begin(), end())`" #: :683 #, safe-html, strict-same msgctxt ":683" msgid "---" msgstr "---" #: :685 #, safe-html, strict-same msgid "max_size" msgstr "max_size" #: :687 #, safe-html, strict-same msgid "```c++ size_type max_size() const noexcept; ```" msgstr "```c++ size_type max_size() const noexcept; ```" #: :692 #, safe-html, strict-same msgid "Returns:;; `size()` of the largest possible container." msgstr "返回：;; 可能的最大容器的 `size()`。" #: :694 #, safe-html, strict-same msgctxt ":694" msgid "---" msgstr "---" #: :696 #, safe-html, strict-same msgid "Modifiers" msgstr "修改器" #: :698 #, safe-html, strict-same msgid "emplace" msgstr "原地构造" #: :699 #, safe-html, strict-same msgid "" "```c++ template std::pair emplace(Args&&... " "args); ```" msgstr "" "```c++ template std::pair emplace" "(Args&&... args); ```" #: :703 #, safe-html, strict-same msgctxt ":703" 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` 构造的对象" "。" #: :706 #, safe-html, strict-same msgctxt ":706" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, pointers and " "references, but only if the insert causes the load to be greater than the " "maximum load. +" msgstr "" "要求：;; `value_type` 可以从 `args` 构造。\n" "返回：;; 如果进行了插入，则返回类型的 `bool` 分量为 `true`。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载因子大于最大负载因" "子时才会发生。" #: :713 #, safe-html, strict-same msgctxt ":713" msgid "---" msgstr "---" #: :715 #, safe-html, strict-same msgid "emplace_hint" msgstr "emplace_hint" #: :716 #, 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); ```" #: :720 #, safe-html, strict-same msgctxt ":720" 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` 构造的对象" "。" #: :722 #, safe-html, strict-same msgid "" "`position` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`position` 是关于元素应该插入位置的一个提示。此实现会忽略它。" #: :725 #, safe-html, strict-same msgctxt ":725" msgid "" "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` " "component of the return type is `true` if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, pointers and " "references, but only if the insert causes the load to be greater than the " "maximum load. +" msgstr "" "要求：;; `value_type` 可以从 `args` 构造。\n" "返回：;; 如果进行了插入，则返回类型的 `bool` 分量为 `true`。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。" #: :732 #, safe-html, strict-same msgctxt ":732" msgid "---" msgstr "---" #: :734 #, safe-html, strict-same msgid "Copy Insert" msgstr "复制插入" #: :735 #, safe-html, strict-same msgid "```c++ std::pair insert(const value_type& obj); ```" msgstr "" "```c++ std::pair insert(const value_type& obj); " "```" #: :739 #, safe-html, strict-same msgctxt ":739" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中不存在具有等价键的元素时，才将 `obj` 插入容器中。" #: :742 #, safe-html, strict-same msgctxt ":742" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, pointers and references, but only if the " "insert causes the load to be greater than the maximum load." msgstr "" "要求：;; `value_type` 必须是 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]。\n" "返回：;; 如果进行了插入，则返回类型的 `bool` 分量为 `true`。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。" #: :749 #, safe-html, strict-same msgctxt ":749" msgid "---" msgstr "---" #: :751 #, safe-html, strict-same msgid "Move Insert" msgstr "移动插入" #: :752 #, safe-html, strict-same msgid "```c++ std::pair insert(value_type&& obj); ```" msgstr "" "```c++ std::pair insert(value_type&& obj); ```" #: :756 #, safe-html, strict-same msgctxt ":756" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中不存在具有等价键的元素时，才将 `obj` 插入容器中。" #: :759 #, safe-html, strict-same msgctxt ":759" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, pointers and references, but only if the " "insert causes the load to be greater than the maximum load." msgstr "" "要求：;; `value_type` 必须是 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]。\n" "返回：;; 如果进行了插入，则返回类型的 `bool` 分量为 `true`。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。" #: :766 #, safe-html, strict-same msgctxt ":766" msgid "---" msgstr "---" #: :768 #, safe-html, strict-same msgid "Transparent Insert" msgstr "透明插入" #: :769 #, safe-html, strict-same msgid "```c++ template std::pair insert(K&& k); ```" msgstr "" "```c++ template std::pair insert" "(K&& k); ```" #: :773 #, safe-html, strict-same msgctxt ":773" msgid "" "Inserts an element constructed from `std::forward(k)` in the container if " "and only if there is no element in the container with an equivalent key." msgstr "" "当且仅当容器中不存在具有等价键的元素时，才插入一个从 `std::forward(k)` 构" "造的元素。" #: :776 #, safe-html, strict-same msgctxt ":776" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; The bool " "component of the return type is true if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, pointers and " "references, but only if the insert causes the load to be greater than the " "maximum load. + + This overload only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs " "and neither `iterator` nor `const_iterator` are implicitly convertible from " "`K`. The library assumes that `Hash` is callable with both `K` and `Key` and " "that `Pred` is transparent. This enables heterogeneous lookup which avoids " "the cost of instantiating an instance of the `Key` type." msgstr "" "要求：;; `value_type` 可以从 `k` 进行 https://en.cppreference.com/w/cpp/" "named_req/EmplaceConstructible[EmplaceConstructible^]。\n" "返回：;; 如果进行了插入，则返回类型的 bool 分量为 true。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。\n" "此外，仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef，并且 `K` 不能隐式转换为 `iterator` 或 `const_iterator` 时，此重载才" "会参与重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 类型调用，且 `Pred` 是透" "明的。这支持了异构查找，从而避免了实例化 `Key` 类型的开销。" #: :785 #, safe-html, strict-same msgctxt ":785" msgid "---" msgstr "---" #: :787 #, safe-html, strict-same msgid "Copy Insert with Hint" msgstr "带提示的复制插入" #: :788 #, safe-html, strict-same msgid "" "```c++ iterator insert(const_iterator hint, const value_type& obj); ``` " "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "" "```c++iterator insert(const_iterator hint, const value_type& obj);\n" "```当且仅当容器中不存在具有等价键的元素时，才将 `obj` 插入容器中。" #: :793 #, safe-html, strict-same msgctxt ":793" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素应该插入位置的一个提示。此实现会忽略它。" #: :796 #, safe-html, strict-same msgctxt ":796" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, pointers and references, but only if the " "insert causes the load to be greater than the maximum load." msgstr "" "要求：;; `value_type` 必须是 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^]。\n" "返回：;; 如果进行了插入，则返回类型的 `bool` 分量为 `true`。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。" #: :803 #, safe-html, strict-same msgctxt ":803" msgid "---" msgstr "---" #: :805 #, safe-html, strict-same msgid "Move Insert with Hint" msgstr "带提示的移动插入" #: :806 #, safe-html, strict-same msgid "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" msgstr "" "```c++ iterator insert(const_iterator hint, value_type&& obj); ```" #: :810 #, safe-html, strict-same msgctxt ":810" msgid "" "Inserts `obj` in the container if and only if there is no element in the " "container with an equivalent key." msgstr "当且仅当容器中不存在具有等价键的元素时，才将 `obj` 插入容器中。" #: :812 #, safe-html, strict-same msgctxt ":812" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素应该插入位置的一个提示。此实现会忽略它。" #: :815 #, safe-html, strict-same msgctxt ":815" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the " "return type is `true` if an insert took place. + + If an insert took place, " "then the iterator points to the newly inserted element. Otherwise, it points " "to the element with equivalent key. Throws:;; If an exception is thrown by " "an operation other than a call to `hasher` the function has no effect. " "Notes:;; Can invalidate iterators, pointers and references, but only if the " "insert causes the load to be greater than the maximum load." msgstr "" "要求：;; `value_type` 必须是 https://en.cppreference.com/w/cpp/named_req/" "MoveInsertable[MoveInsertable^]。\n" "返回：;; 如果进行了插入，则返回类型的 `bool` 分量为 `true`。\n" "如果进行了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。\n" "抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。" #: :822 #, safe-html, strict-same msgctxt ":822" msgid "---" msgstr "---" #: :824 #, safe-html, strict-same msgid "Transparent Insert with Hint" msgstr "带提示的透明插入" #: :825 #, safe-html, strict-same msgid "" "```c++ template std::pair insert(const_iterator " "hint, K&& k); ```" msgstr "" "```c++ template std::pair insert" "(const_iterator hint, K&& k); ```" #: :829 #, safe-html, strict-same msgctxt ":829" msgid "" "Inserts an element constructed from `std::forward(k)` in the container if " "and only if there is no element in the container with an equivalent key." msgstr "" "当且仅当容器中不存在具有等价键的元素时，才插入一个从 `std::forward(k)` 构" "造的元素。" #: :831 #, safe-html, strict-same msgctxt ":831" msgid "" "`hint` is a suggestion to where the element should be inserted. This " "implementation ignores it." msgstr "`hint` 是关于元素应该插入位置的一个提示。此实现会忽略它。" #: :834 #, safe-html, strict-same msgctxt ":834" msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; The bool " "component of the return type is true if an insert took place. + + If an " "insert took place, then the iterator points to the newly inserted element. " "Otherwise, it points to the element with equivalent key. Throws:;; If an " "exception is thrown by an operation other than a call to `hasher` the " "function has no effect. Notes:;; Can invalidate iterators, pointers and " "references, but only if the insert causes the load to be greater than the " "maximum load. + + This overload only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs " "and neither `iterator` nor `const_iterator` are implicitly convertible from " "`K`. The library assumes that `Hash` is callable with both `K` and `Key` and " "that `Pred` is transparent. This enables heterogeneous lookup which avoids " "the cost of instantiating an instance of the `Key` type." msgstr "" "要求：;; `value_type` 可以从 `k` 进行 https://en.cppreference.com/w/cpp/" "named_req/EmplaceConstructible[EmplaceConstructible^]。返回：;; 如果进行了插" "入，则返回类型的 bool 分量为 true。如果进行了插入，则迭代器指向新插入的元素；" "否则，指向具有等价键的元素。抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，" "则该函数无效。备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于" "最大负载时才会发生。此重载仅当 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef，并且 `K` 不能隐式转换为 " "`iterator` 或 `const_iterator` 时，才会参与重载决议。库假定 `Hash` 可同时以 " "`K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例" "化 `Key` 类型的开销。" #: :843 #, safe-html, strict-same msgctxt ":843" msgid "---" msgstr "---" #: :845 #, safe-html, strict-same msgid "Insert Iterator Range" msgstr "迭代器范围插入" #: :846 #, safe-html, strict-same msgid "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" msgstr "" "```c++ template void insert(InputIterator first, " "InputIterator last); ```" #: :850 #, safe-html, strict-same msgctxt ":850" 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 "" "将一系列元素插入容器中。当且仅当容器中不存在具有等价键的元素时，才插入该元素" "。" #: :853 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "EmplaceConstructible[EmplaceConstructible^] into the container from " "`*first`. Throws:;; When inserting a single element, if an exception is " "thrown by an operation other than a call to `hasher` the function has no " "effect. Notes:;; Can invalidate iterators, pointers and references, but only " "if the insert causes the load to be greater than the maximum load." msgstr "" "要求：;; `value_type` 可以从 `*first` 进行 https://en.cppreference.com/w/cpp/" "named_req/EmplaceConstructible[EmplaceConstructible^] 到容器中。\n" "抛出：;; 当插入单个元素时，如果除调用 `hasher` 之外的操作抛出异常，则该函数无" "效。\n" "备注：;; 可能会使迭代器、指针和引用失效，但仅当插入导致负载大于最大负载时才会" "发生。" #: :857 #, safe-html, strict-same msgctxt ":857" msgid "---" msgstr "---" #: :859 #, safe-html, strict-same msgid "Insert Initializer List" msgstr "初始化列表插入" #: :860 #, safe-html, strict-same msgid "```c++ void insert(std::initializer_list); ```" msgstr "```c++ void insert(std::initializer_list); ```" #: :864 #, safe-html, strict-same msgctxt ":864" 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 "" "将一系列元素插入容器中。当且仅当容器中不存在具有等价键的元素时，才插入该元素" "。" #: :867 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] into the container. Throws:;; When inserting " "a single element, if an exception is thrown by an operation other than a " "call to `hasher` the function has no effect. Notes:;; Can invalidate " "iterators, pointers and references, but only if the insert causes the load " "to be greater than the maximum load." msgstr "" "要求：;; `value_type` 必须可以 https://en.cppreference.com/w/cpp/named_req/" "CopyInsertable[CopyInsertable^] 到容器中。抛出：;; 当插入单个元素时，如果除调" "用 `hasher` 之外的操作抛出异常，则该函数无效。备注：;; 可能会使迭代器、指针和" "引用失效，但仅当插入导致负载大于最大负载时才会发生。" #: :871 #, safe-html, strict-same msgctxt ":871" msgid "---" msgstr "---" #: :873 #, safe-html, strict-same msgid "Erase by Position" msgstr "通过位置擦除" #: :881 #, safe-html, strict-same msgid "Erase the element pointed to by `position`." msgstr "擦除由 `position` 指向的元素。" #: :884 #, safe-html, strict-same msgid "" "Returns:;; An opaque object implicitly convertible to the `iterator` or " "`const_iterator` immediately following `position` prior to the erasure. " "Throws:;; Nothing. Notes:;; The opaque object returned must only be " "discarded or immediately converted to `iterator` or `const_iterator`." msgstr "" "返回：;; 一个不透明对象，可隐式转换为擦除前紧接 `position` 之后的 `iterator` " "或 `const_iterator`。抛出：;; 无。备注：;; 返回的不透明对象只能被丢弃或立即转" "换为 `iterator` 或 `const_iterator`。" #: :889 #, safe-html, strict-same msgctxt ":889" msgid "---" msgstr "---" #: :891 #, safe-html, strict-same msgid "Erase by Key" msgstr "通过键擦除" #: :892 #, 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); ```" #: :897 #, safe-html, strict-same msgid "Erase all elements with key equivalent to `k`." msgstr "删除所有键与 `k` 等价的元素。" #: :900 #, safe-html, strict-same msgid "" "Returns:;; The number of elements erased. Throws:;; Only throws an exception " "if it is thrown by `hasher` or `key_equal`. Notes:;; The `template` " "overload only participates in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs and neither `iterator` " "nor `const_iterator` are implicitly convertible from `K`. The library " "assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：;; 被删除的元素数量。抛出：;; 仅当由 `hasher` 或 `key_equal` 抛出异常时" "才会抛出异常。备注：;; `template` 重载仅当 " "`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，并且 " "`K` 不能隐式转换为 `iterator` 或 `const_iterator` 时，才会参与重载决议。库假" "定 `Hash` 可同时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查" "找，从而避免了实例化 `Key` 类型的开销。" #: :904 #, safe-html, strict-same msgctxt ":904" msgid "---" msgstr "---" #: :906 #, safe-html, strict-same msgid "Erase Range" msgstr "范围擦除" #: :908 #, safe-html, strict-same msgid "```c++ iterator erase(const_iterator first, const_iterator last); ```" msgstr "```c++ iterator erase(const_iterator first, const_iterator last); ```" #: :912 #, safe-html, strict-same msgid "Erases the elements in the range from `first` to `last`." msgstr "删除从 `first` 到 `last` 范围内的元素。" #: :915 #, safe-html, strict-same msgid "" "Returns:;; The iterator following the erased elements - i.e. `last`. " "Throws:;; Nothing in this implementation (neither the `hasher` nor the " "`key_equal` objects are called)." msgstr "" "返回：;; 被删除元素之后的迭代器，即 `last`。抛出：;; 在此实现中不抛出任何异常" "（既不会调用 `hasher` 也不会调用 `key_equal` 对象）。" #: :918 #, safe-html, strict-same msgctxt ":918" msgid "---" msgstr "---" #: :920 #, safe-html, strict-same msgid "swap" msgstr "交换" #: :921 #, safe-html, strict-same msgid "" "```c++ void swap(unordered_flat_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); ```" msgstr "" "```c++ void swap(unordered_flat_set& other) noexcept" "(boost::allocator_traits::is_always_equal::value || " "boost::allocator_traits::propagate_on_container_swap::value); " "```" #: :927 #, safe-html, strict-same msgid "Swaps the contents of the container with the parameter." msgstr "交换容器与参数的内容。" #: :929 #, safe-html, strict-same msgctxt ":929" 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`，则交换两个容器的分" "配器。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :932 #, safe-html, strict-same msgid "Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping." msgstr "抛出：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，否则不抛出任何异常。" #: :934 #, safe-html, strict-same msgctxt ":934" msgid "---" msgstr "---" #: :936 #, safe-html, strict-same msgid "pull" msgstr "pull" #: :937 #, safe-html, strict-same msgid "```c++ init_type pull(const_iterator position); ```" msgstr "```c++ init_type pull(const_iterator position); ```" #: :941 #, 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`。" #: :944 #, safe-html, strict-same msgctxt ":944" msgid "---" msgstr "---" #: :946 #, safe-html, strict-same msgid "clear" msgstr "清空" #: :947 #, safe-html, strict-same msgid "```c++ void clear() noexcept; ```" msgstr "```c++ void clear() noexcept; ```" #: :951 #, safe-html, strict-same msgid "Erases all elements in the container." msgstr "清除容器中的所有元素。" #: :954 #, safe-html, strict-same msgid "" "Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * " "bucket_count()`" msgstr "" "Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * " "bucket_count()`" #: :956 #, safe-html, strict-same msgctxt ":956" msgid "---" msgstr "---" #: :958 #, safe-html, strict-same msgid "merge" msgstr "合并" #: :959 #, safe-html, strict-same msgid "" "```c++ template void merge(unordered_flat_set& source); template void merge" "(unordered_flat_set&& source); ```" msgstr "" "```c++ template void merge" "(unordered_flat_set& " "source); template void merge" "(unordered_flat_set&& " "source); ```" #: :966 #, safe-html, strict-same msgid "" "Move-inserts all the elements from `source` whose key is not already present " "in `*this`, and erases them from `source`." msgstr "" "移动插入 `source` 中所有键尚未存在于 `*this` 中的元素，并从 `source` 中删除它" "们。" #: :968 #, safe-html, strict-same msgctxt ":968" msgid "---" msgstr "---" #: :970 #, safe-html, strict-same msgid "Observers" msgstr "观察器" #: :972 #, safe-html, strict-same msgid "get_allocator" msgstr "get_allocator" #: :973 #, safe-html, strict-same msgid "``` allocator_type get_allocator() const noexcept; ```" msgstr "``` allocator_type get_allocator() const noexcept; ```" #: :978 #, safe-html, strict-same msgid "Returns:;; The container's allocator." msgstr "返回：;; 容器的分配器。" #: :980 #, safe-html, strict-same msgctxt ":980" msgid "---" msgstr "---" #: :982 #, safe-html, strict-same msgid "hash_function" msgstr "哈希函数" #: :983 #, safe-html, strict-same msgid "``` hasher hash_function() const; ```" msgstr "``` hasher hash_function() const; ```" #: :988 #, safe-html, strict-same msgid "Returns:;; The container's hash function." msgstr "返回：;; 容器的哈希函数。" #: :990 #, safe-html, strict-same msgctxt ":990" msgid "---" msgstr "---" #: :992 #, safe-html, strict-same msgid "key_eq" msgstr "key_eq" #: :993 #, safe-html, strict-same msgid "``` key_equal key_eq() const; ```" msgstr "``` key_equal key_eq() const; ```" #: :998 #, safe-html, strict-same msgid "Returns:;; The container's key equality predicate" msgstr "返回：;; 容器的键相等谓词。" #: :1000 #, safe-html, strict-same msgctxt ":1000" msgid "---" msgstr "---" #: :1002 #, safe-html, strict-same msgid "Lookup" msgstr "查找" #: :1004 #, safe-html, strict-same msgid "find" msgstr "find" #: :1005 #, 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);" #: :1011 #, safe-html, strict-same msgid "```" msgstr "```" #: :1014 #, safe-html, strict-same msgid "" "Returns:;; An iterator pointing to an element with key equivalent to `k`, or " "`end()` if no such element exists. Notes:;; The `template` " "overloads only participate in overload resolution if `Hash::is_transparent` " "and `Pred::is_transparent` are valid member typedefs. The library assumes " "that `Hash` is callable with both `K` and `Key` and that `Pred` is " "transparent. This enables heterogeneous lookup which avoids the cost of " "instantiating an instance of the `Key` type." msgstr "" "返回：;; 指向键与 `k` 等价之元素的迭代器，若无此元素则返回 `end()`。备注：;; " "`template` 重载仅当 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时才会参与重载决议。库假定 " "`Hash` 可同时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，" "从而避免了实例化 `Key` 类型的开销。" #: :1017 #, safe-html, strict-same msgctxt ":1017" msgid "---" msgstr "---" #: :1019 #, safe-html, strict-same msgid "count" msgstr "count" #: :1020 #, 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; ```" #: :1027 #, safe-html, strict-same msgid "" "Returns:;; The number of elements with key equivalent to `k`. Notes:;; The " "`template` overload only participates in overload resolution if " "`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. " "The library assumes that `Hash` is callable with both `K` and `Key` and that " "`Pred` is transparent. This enables heterogeneous lookup which avoids the " "cost of instantiating an instance of the `Key` type." msgstr "" "返回：;; 键与 `k` 等价的元素个数。备注：;; `template` 重载仅当 " "`Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时才会" "参与重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明" "的。这支持了异构查找，从而避免了实例化 `Key` 类型的开销。" #: :1030 #, safe-html, strict-same msgctxt ":1030" msgid "---" msgstr "---" #: :1032 #, safe-html, strict-same msgid "contains" msgstr "包含" #: :1033 #, 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; ```" #: :1040 #, safe-html, strict-same msgid "" "Returns:;; A boolean indicating whether or not there is an element with key " "equal to `key` in the container Notes:;; The `template` overload " "only participates in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：;; 一个布尔值，指示容器中是否存在键等于 `key` 的元素。备注：;; " "`template` 重载仅当 `Hash::is_transparent` 和 " "`Pred::is_transparent` 是有效的成员 typedef 时才会参与重载决议。库假定 " "`Hash` 可同时以 `K` 和 `Key` 类型调用，且 `Pred` 是透明的。这支持了异构查找，" "从而避免了实例化 `Key` 类型的开销。" #: :1043 #, safe-html, strict-same msgctxt ":1043" msgid "---" msgstr "---" #: :1045 #, safe-html, strict-same msgid "equal_range" msgstr "equal_range" #: :1046 #, 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; ```" "" #: :1056 #, safe-html, strict-same msgid "" "Returns:;; A range containing all elements with key equivalent to `k`. If " "the container doesn't contain any such elements, returns `std::make_pair" "(b.end(), b.end())`. Notes:;; The `template` overloads only " "participate in overload resolution if `Hash::is_transparent` and " "`Pred::is_transparent` are valid member typedefs. The library assumes that " "`Hash` is callable with both `K` and `Key` and that `Pred` is transparent. " "This enables heterogeneous lookup which avoids the cost of instantiating an " "instance of the `Key` type." msgstr "" "返回：;; 一个范围，包含所有键与 `k` 等价的元素。若容器中不包含任何此类元素，" "则返回 `std::make_pair(b.end(), b.end())`。备注：;; `template` " "重载仅当 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 " "typedef 时才会参与重载决议。库假定 `Hash` 可同时以 `K` 和 `Key` 类型调用，且 " "`Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型的开销。" #: :1059 #, safe-html, strict-same msgctxt ":1059" msgid "---" msgstr "---" #: :1061 #, safe-html, strict-same msgid "Bucket Interface" msgstr "桶接口" #: :1063 #, safe-html, strict-same msgid "bucket_count" msgstr "bucket_count" #: :1064 #, safe-html, strict-same msgid "```c++ size_type bucket_count() const noexcept; ```" msgstr "```c++ size_type bucket_count() const noexcept; ```" #: :1069 #, safe-html, strict-same msgid "Returns:;; The size of the bucket array." msgstr "返回：;; 桶数组的大小。" #: :1071 #, safe-html, strict-same msgctxt ":1071" msgid "---" msgstr "---" #: :1073 #, safe-html, strict-same msgid "Hash Policy" msgstr "哈希策略" #: :1075 #, safe-html, strict-same msgid "load_factor" msgstr "负载因子" #: :1076 #, safe-html, strict-same msgid "```c++ float load_factor() const noexcept; ```" msgstr "```c++ float load_factor() const noexcept; ```" #: :1081 #, 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`。" #: :1083 #, safe-html, strict-same msgctxt ":1083" msgid "---" msgstr "---" #: :1085 #, safe-html, strict-same msgid "max_load_factor" msgstr "最大负载因子" #: :1087 #, safe-html, strict-same msgid "```c++ float max_load_factor() const noexcept; ```" msgstr "```c++ float max_load_factor() const noexcept; ```" #: :1092 #, safe-html, strict-same msgid "Returns:;; Returns the container's maximum load factor." msgstr "返回：;; 返回容器的最大负载因子。" #: :1094 #, safe-html, strict-same msgctxt ":1094" msgid "---" msgstr "---" #: :1096 #, safe-html, strict-same msgid "Set max_load_factor" msgstr "设置最大负载因子" #: :1097 #, safe-html, strict-same msgid "```c++ void max_load_factor(float z); ```" msgstr "```c++ void max_load_factor(float z); ```" #: :1102 #, safe-html, strict-same msgid "" "Effects:;; Does nothing, as the user is not allowed to change this " "parameter. Kept for compatibility with `boost::unordered_set`." msgstr "" "效果：;; 不执行任何操作，因为用户不允许更改此参数。为与 " "`boost::unordered_set` 保持兼容而保留。" #: :1104 #, safe-html, strict-same msgctxt ":1104" msgid "---" msgstr "---" #: :1107 #, safe-html, strict-same msgid "max_load" msgstr "最大负载" #: :1109 #, safe-html, strict-same msgid "```c++ size_type max_load() const noexcept; ```" msgstr "```c++ size_type max_load() const noexcept; ```" #: :1114 #, 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 "" "返回：;; 假设不再删除更多元素，容器在不进行重哈希的情况下所能容纳的最大元素数" "量。注意：;; 在构造、重哈希或清空之后，容器的最大负载至少为 `max_load_factor" "() * bucket_count()`。在高负载条件下，该值可能因删除操作而减小。" #: :1118 #, safe-html, strict-same msgctxt ":1118" msgid "---" msgstr "---" #: :1120 #, safe-html, strict-same msgid "rehash" msgstr "重哈希" #: :1121 #, safe-html, strict-same msgid "```c++ void rehash(size_type n); ```" msgstr "```c++ void rehash(size_type n); ```" #: :1125 #, 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()`。" #: :1127 #, 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)` 将释放底层桶数组的内存。如果所提供的分配器使" "用 fancy pointers，随后将执行一次默认分配。" #: :1129 #, safe-html, strict-same msgctxt ":1129" msgid "" "Invalidates iterators, pointers and references, and changes the order of " "elements." msgstr "使迭代器、指针和引用失效，并改变元素的顺序。" #: :1132 #, safe-html, strict-same msgctxt ":1132" 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 "抛出：;; 如果抛出异常（除非是由容器的哈希函数或比较函数抛出），则该函数无效。" #: :1134 #, safe-html, strict-same msgctxt ":1134" msgid "---" msgstr "---" #: :1136 #, safe-html, strict-same msgid "reserve" msgstr "保留" #: :1137 #, safe-html, strict-same msgid "```c++ void reserve(size_type n); ```" msgstr "```c++ void reserve(size_type n); ```" #: :1141 #, safe-html, strict-same msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`." msgstr "等价于 `a.rehash(ceil(n / a.max_load_factor()))`。" #: :1143 #, 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` 类似，此函数可用于增加或减少容器中桶的数量。" #: :1145 #, safe-html, strict-same msgctxt ":1145" msgid "" "Invalidates iterators, pointers and references, and changes the order of " "elements." msgstr "使迭代器、指针和引用失效，并改变元素的顺序。" #: :1148 #, safe-html, strict-same msgctxt ":1148" 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 "抛出：;; 如果抛出异常（除非是由容器的哈希函数或比较函数抛出），则该函数无效。" #: :1150 #, safe-html, strict-same msgctxt ":1150" msgid "---" msgstr "---" #: :1152 #, safe-html, strict-same msgid "Statistics" msgstr "统计信息" #: :1154 #, safe-html, strict-same msgid "get_stats" msgstr "get_stats" #: :1155 #, safe-html, strict-same msgid "```c++ stats get_stats() const; ```" msgstr "```c++ stats get_stats() const; ```" #: :1160 #, safe-html, strict-same msgid "" "Returns:;; A statistical description of the insertion and lookup operations " "performed by the container so far. Notes:;; Only available if xref:reference/" "stats.adoc#stats[statistics calculation] is " "xref:unordered_flat_set_boost_unordered_enable_stats[enabled]." msgstr "" "返回：;; 对容器迄今为止所执行的插入和查找操作的统计描述。备注：;; 仅在 " "xref:reference/stats.adoc#stats[统计信息计算] 已 " "xref:unordered_flat_set_boost_unordered_enable_stats[启用] 时可用。" #: :1163 #, safe-html, strict-same msgctxt ":1163" msgid "---" msgstr "---" #: :1165 #, safe-html, strict-same msgid "reset_stats" msgstr "reset_stats" #: :1166 #, safe-html, strict-same msgid "```c++ void reset_stats() noexcept; ```" msgstr "```c++ void reset_stats() noexcept; ```" #: :1171 #, safe-html, strict-same msgid "" "Effects:;; Sets to zero the internal statistics kept by the container. " "Notes:;; Only available if xref:reference/stats.adoc#stats[statistics " "calculation] is " "xref:unordered_flat_set_boost_unordered_enable_stats[enabled]." msgstr "" "效果：;; 将容器内部保持的统计信息归零。备注：;; 仅在 xref:reference/" "stats.adoc#stats[统计信息计算] 已 " "xref:unordered_flat_set_boost_unordered_enable_stats[启用] 时可用。" #: :1174 #, safe-html, strict-same msgctxt ":1174" msgid "---" msgstr "---" #: :1176 #, safe-html, strict-same msgid "Deduction Guides" msgstr "推导指引" #: :1177 #, safe-html, strict-same msgid "" "A deduction guide will not participate in overload resolution if any of the " "following are true:" msgstr "在以下任一条件成立时，推导指引将不参与重载决议：" #: :1179 #, safe-html, strict-same msgid "" "- It has an `InputIterator` template parameter and a type that does not " "qualify as an input iterator is deduced for that parameter. - It has an " "`Allocator` template parameter and a type that does not qualify as an " "allocator is deduced for that parameter. - It has a `Hash` template " "parameter and an integral type or a type that qualifies as an allocator is " "deduced for that parameter. - It has a `Pred` template parameter and a type " "that qualifies as an allocator is deduced for that parameter." msgstr "" "- 它具有 `InputIterator` 模板参数，并且为该参数推导出的类型不符合输入迭代器的" "要求。- 它具有 `Allocator` 模板参数，并且为该参数推导出的类型不符合分配器的要" "求。- 它具有 `Hash` 模板参数，并且为该参数推导出的是整数类型或符合分配器要求" "的类型。- 它具有 `Pred` 模板参数，并且为该参数推导出的是符合分配器要求的类型" "。" #: :1184 #, 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` 成员类型。其默认值与所选构造函数的默认值一致。" #: :1188 #, safe-html, strict-same msgid "__iter-value-type__" msgstr "_iter-value-type_" #: :1196 #, safe-html, strict-same msgid "Equality Comparisons" msgstr "相等性比较" #: :1198 #, safe-html, strict-same msgid "operator" msgstr "operator" #: :1199 #, safe-html, strict-same msgid "" "```c++ template " "bool operator==(const unordered_flat_set& x, " "const unordered_flat_set& y); ```" msgstr "" "```c++ template bool operator==(const unordered_flat_set& x, const unordered_flat_set& y); ```" #: :1205 #, 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`。" #: :1208 #, safe-html, strict-same msgctxt ":1208" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "备注：;; 如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1210 #, safe-html, strict-same msgctxt ":1210" msgid "---" msgstr "---" #: :1212 #, safe-html, strict-same msgid "operator!" msgstr "operator!" #: :1213 #, safe-html, strict-same msgid "" "```c++ template " "bool operator!=(const unordered_flat_set& x, " "const unordered_flat_set& y); ```" msgstr "" "```c++ template bool operator!=(const unordered_flat_set& x, const unordered_flat_set& y); ```" #: :1219 #, 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`。" #: :1222 #, safe-html, strict-same msgctxt ":1222" msgid "" "Notes:;; Behavior is undefined if the two containers don't have equivalent " "equality predicates." msgstr "备注：;; 如果两个容器不具有等价的相等谓词，则行为未定义。" #: :1224 #, safe-html, strict-same msgid "Swap" msgstr "交换" #: :1225 #, safe-html, strict-same msgid "" "```c++ template " "void swap(unordered_flat_set& x, " "unordered_flat_set& y) noexcept(noexcept(x.swap" "(y))); ```" msgstr "" "```c++ template void swap(unordered_flat_set& x, unordered_flat_set& y) noexcept(noexcept(x.swap(y))); ```" #: :1232 #, safe-html, strict-same msgid "Swaps the contents of `x` and `y`." msgstr "交换 `x` 和 `y` 的内容。" #: :1234 #, safe-html, strict-same msgctxt ":1234" 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`，则交换两个容器的分" "配器。否则，使用不相等的分配器进行交换将导致未定义行为。" #: :1237 #, safe-html, strict-same msgid "" "Effects:;; `x.swap(y)` Throws:;; Nothing unless `key_equal` or `hasher` " "throw on swapping." msgstr "" "效果：;; `x.swap(y)` 抛出：;; 除非 `key_equal` 或 `hasher` 在交换时抛出异常，" "否则不抛出任何异常。" #: :1240 #, safe-html, strict-same msgctxt ":1240" msgid "---" msgstr "---" #: :1242 #, safe-html, strict-same msgid "erase_if" msgstr "erase_if" #: :1243 #, safe-html, strict-same msgid "" "```c++ template typename unordered_flat_set::size_type erase_if" "(unordered_flat_set& c, Predicate pred); ```" msgstr "" "```c++ template typename unordered_flat_set::size_type erase_if(unordered_flat_set& c, Predicate pred); ```" #: :1249 #, safe-html, strict-same msgid "" "Traverses the container `c` and removes all elements for which the supplied " "predicate returns `true`." msgstr "遍历容器 `c` 并移除所有使给定谓词返回 `true` 的元素。" #: :1252 #, safe-html, strict-same msgid "" "Returns:;; The number of erased elements. Notes:;; Equivalent to: + + ```c++ " "auto original_size = c.size(); for (auto i = c.begin(), last = c.end(); i != " "last; ) { if (pred(*i)) { i = c.erase(i); } else { ++i; } } return " "original_size - c.size(); ```" msgstr "" "返回：;; 被移除的元素数量。备注：;; 等价于：```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(); " "```" #: :1267 #, safe-html, strict-same msgid "Serialization" msgstr "序列化" #: :1269 #, safe-html, strict-same msgid "" "``unordered_flat_set``s can be archived/retrieved by means of link:../../../" "../../serialization/index.html[Boost.Serialization^] using the API provided " "by this library. Both regular and XML archives are supported." msgstr "" "`unordered_flat_set` 可以通过本库提供的 API，使用 link:../../../../../" "serialization/index.html[Boost.Serialization^] 进行归档/恢复。支持常规归档和 " "XML 归档。" #: :1273 #, safe-html, strict-same msgid "Saving an unordered_flat_set to an archive" msgstr "将 unordered_flat_set 保存到归档中" #: :1275 #, safe-html, strict-same msgid "" "Saves all the elements of an `unordered_flat_set` `x` to an archive (XML " "archive) `ar`." msgstr "将 `unordered_flat_set` `x` 的所有元素保存到归档（XML 归档）`ar` 中。" #: :1278 #, safe-html, strict-same msgid "" "Requires:;; `value_type` is serializable (XML serializable), and it supports " "Boost.Serialization `save_construct_data`/`load_construct_data` protocol " "(automatically suported by https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^] types)." msgstr "" "要求：;; `value_type` 必须是可序列化的（支持 XML 序列化），并且支持 " "Boost.Serialization 的 `save_construct_data`/`load_construct_data` 协议（该协" "议由 https://en.cppreference.com/w/cpp/named_req/" "DefaultConstructible[DefaultConstructible^] 类型的自动支持）。" #: :1284 #, safe-html, strict-same msgctxt ":1284" msgid "---" msgstr "---" #: :1286 #, safe-html, strict-same msgid "Loading an unordered_flat_set from an archive" msgstr "从归档中加载 unordered_flat_set" #: :1288 #, safe-html, strict-same msgid "" "Deletes all preexisting elements of an `unordered_flat_set` `x` and inserts " "from an archive (XML archive) `ar` restored copies of the elements of the " "original `unordered_flat_set` `other` saved to the storage read by `ar`." msgstr "" "删除 `unordered_flat_set` `x` 中所有已存在的元素，并从归档（XML 归档）`ar` 中" "插入由 `ar` 所读取存储中保存的原始 `unordered_flat_set` `other` 元素的恢复副" "本。" #: :1293 #, safe-html, strict-same msgid "" "Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()" "`." msgstr "要求：;; `x.key_equal()` 在功能上等价于 `other.key_equal()`。" #: :1295 #, safe-html, strict-same msgctxt ":1295" msgid "---" msgstr "---" #: :1297 #, safe-html, strict-same msgid "Saving an iterator/const_iterator to an archive" msgstr "将迭代器/常量迭代器保存到归档" #: :1299 #, safe-html, strict-same msgid "" "Saves the positional information of an `iterator` (`const_iterator`) `it` to " "an archive (XML archive) `ar`. `it` can be and `end()` iterator." msgstr "" "将 `iterator`（`const_iterator`）`it` 的位置信息保存到归档（XML 归档）`ar` 中" "。`it` 可以是 `end()` 迭代器。" #: :1303 #, safe-html, strict-same msgid "" "Requires:;; The `unordered_flat_set` `x` pointed to by `it` has been " "previously saved to `ar`, and no modifying operations have been issued on " "`x` between saving of `x` and saving of `it`." msgstr "" "要求：;; `it` 所指向的 `unordered_flat_set` `x` 此前已保存至 `ar`，并且在保" "存 `x` 和保存 `it` 之间未对 `x` 执行任何修改操作。" #: :1307 #, safe-html, strict-same msgctxt ":1307" msgid "---" msgstr "---" #: :1309 #, safe-html, strict-same msgid "Loading an iterator/const_iterator from an archive" msgstr "从归档加载迭代器/常量迭代器" #: :1311 #, safe-html, strict-same msgid "" "Makes an `iterator` (`const_iterator`) `it` point to the restored position " "of the original `iterator` (`const_iterator`) saved to the storage read by " "an archive (XML archive) `ar`." msgstr "" "使 `iterator`（`const_iterator`）`it` 指向保存到由归档（XML 归档）`ar` 读取的" "存储中的原始 `iterator`（`const_iterator`）的被恢复位置。" #: :1316 #, safe-html, strict-same msgid "" "Requires:;; If `x` is the `unordered_flat_set` `it` points to, no modifying " "operations have been issued on `x` between loading of `x` and loading of " "`it`." msgstr "" "要求：;; 如果 `x` 是 `it` 所指向的 `unordered_flat_set`，则在加载 `x` 和加载 " "`it` 之间未对 `x` 执行任何修改操作。"