Zen

Translation

:1068
English
If there is no such element, it is added to the container as: ```c++
34/680 · 68

Sign in to save translations.

Key English Chinese (Simplified Han script) Actions
:1019
If there is an existing element with key `k` this function does nothing.
如果已存在键为 `k` 的元素，则该函数不执行任何操作。
:1021
`hint` is a suggestion to where the element should be inserted.
`hint` 是关于元素插入位置的建议。
Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; This function is similiar to xref:#unordered_map_emplace_hint[emplace_hint] except the `value_type` is constructed using: + + -- ```c++
返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：此函数类似于 xref:#unordered_map_emplace_hint[emplace_hint]，区别在于 `value_type` 的构造方式如下：
```c++
:1031
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>
:1036
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>
instead of xref:#unordered_map_emplace_hint[emplace_hint] which simply forwards all arguments to ``value_type``'s constructor.
而不是像 xref:#unordered_map_emplace_hint[emplace_hint] 那样简单地将所有参数转发给 `value_type` 的构造函数。
The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same key.
标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。
:1045
Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.
可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。
:1047
Pointers and references to elements are never invalidated.
指向元素的指针和引用永远不会失效。
:1049
The `template<class K, class\... Args>` 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. --
`template<class k,="" args="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
:1052
---
---
insert_or_assign
insert_or_assign
```c++ template<class M> std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); template<class M> std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); template<class K, class M> std::pair<iterator, bool> insert_or_assign(K&& k, M&& obj); ```
```c++ template<class m=""> std::pair<iterator, bool=""> insert_or_assign(const key_type&amp; k, M&amp;&amp; obj); template<class m=""> std::pair<iterator, bool=""> insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj); template<class k,="" class="" m=""> std::pair<iterator, bool=""> insert_or_assign(K&amp;&amp; k, M&amp;&amp; obj); ```</iterator,></class></iterator,></class></iterator,></class>
:1064
Inserts a new element into the container or updates an existing one by assigning to the contained value.
向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1066
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>
:1068
If there is no such element, it is added to the container as: ```c++
如果不存在这样的元素，则将其添加到容器中，形式为：
```c++
:1071
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>
:1076
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></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, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. + + Pointers and references to elements are never invalidated. + + The `template<class K, class M>` 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.
返回：返回类型的 bool 分量为 true 表示发生了插入。
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。
指向元素的指针和引用永远不会失效。

`template<class k,="" class="" m="">` 仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
:1092
---
---
insert_or_assign with Hint
带提示位置的 `insert_or_assign`
```c++ template<class M> iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); template<class M> iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); template<class K, class M> iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); ```
```c++ template<class m=""> iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&amp;&amp; obj); template<class m=""> iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj); template<class k,="" class="" m=""> iterator insert_or_assign(const_iterator hint, K&amp;&amp; k, M&amp;&amp; obj); ```</class></class></class>
:1104
Inserts a new element into the container or updates an existing one by assigning to the contained value.
向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1106
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>
:1108
If there is no such element, it is added to the container as: ```c++
向容器中插入新元素，或通过赋值给已存在的元素值来更新该元素。
:1111
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>
:1116
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>
:1121
`hint` is a suggestion to where the element should be inserted.
`hint` 是关于元素插入位置的建议。
Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same key. + + Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. + + Pointers and references to elements are never invalidated. + + The `template<class K, class M>` 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.
返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：标准关于 `hint` 的含义表述相当模糊。但唯一实际的使用方式，也是 Boost.Unordered 支持的唯一方式，是将其指向一个具有相同键的已存在元素。
可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。 指向元素的指针和引用永远不会失效。
`template<class k,="" class="" m="">` 仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
:1134
---
---
Extract by Iterator
通过迭代器提取
Key English Chinese (Simplified Han script) Actions
Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`, or `a.rehash(1)` if `n > 0` and `a.max_load_factor() == std::numeric_limits<float>::infinity()`.
等价于 `a.rehash(ceil(n / a.max_load_factor()))`；如果 `n &gt; 0` 且 `a.max_load_factor() == std::numeric_limits<float>::infinity()`，则等价于 `a.rehash(1)`。</float>
:1000
Pointers and references to elements are never invalidated.
指向元素的指针和引用永远不会失效。
:1002
The `template<class K, class\... Args>` 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. --
`template<class k,="" args="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
:1005
---
---
:1017
Inserts a new element into the container if there is no existing element with key `k` contained within it.
如果容器中不存在键为 `k` 的元素，则插入一个新元素。
:1019
If there is an existing element with key `k` this function does nothing.
如果已存在键为 `k` 的元素，则该函数不执行任何操作。
:1021
`hint` is a suggestion to where the element should be inserted.
`hint` 是关于元素插入位置的建议。
:1031
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<args>(args)...))</args></key>
:1036
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<args>(args)...)) ```</args></k>
:1045
Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.
可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。
:1047
Pointers and references to elements are never invalidated.
指向元素的指针和引用永远不会失效。
:1049
The `template<class K, class\... Args>` 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. --
`template<class k,="" args="">` 重载仅在 `Hash::is_transparent` 和 `Pred::is_transparent` 是有效的成员 typedef，且 `iterator` 和 `const_iterator` 都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` 和 `Key` 调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
:1052
---
---
:1064
Inserts a new element into the container or updates an existing one by assigning to the contained value.
向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1066
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>
:1068
If there is no such element, it is added to the container as: ```c++
如果不存在这样的元素，则将其添加到容器中，形式为：
```c++
:1071
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>
:1076
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>
:1092
---
---
:1104
Inserts a new element into the container or updates an existing one by assigning to the contained value.
向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1106
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
如果存在键为 `k` 的元素，则通过赋值 `std::forward<m>(obj)` 来更新它。</m>
:1108
If there is no such element, it is added to the container as: ```c++
向容器中插入新元素，或通过赋值给已存在的元素值来更新该元素。
:1111
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<key>(k)), std::forward_as_tuple(std::forward<m>(obj)))</m></key>
:1116
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```
value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<k>(k)), std::forward_as_tuple(std::forward<m>(obj))) ```</m></k>
:1121
`hint` is a suggestion to where the element should be inserted.
`hint` 是关于元素插入位置的建议。
:1134
---
---
:1147
---
---
:1164
---
---
:1171
If `nh` is empty, has no effect.
如果 `nh` 为空，则无效果。
:1173
Otherwise inserts the element owned by `nh` if and only if there is no element in the container with an equivalent key.
否则，当且仅当容器中没有具有等价键的元素时，才插入 `nh` 所拥有的元素。

Loading…

User avatar admin

Translation uploaded
If there is no such element, it is added to the container as: ```c++
If there is no such element, it is added to the container as: 如果不存在这样的元素，则将其添加到容器中，形式为：
```c++
:1068
06/05/2026
User avatar admin

String added in the repository
If there is no such element, it is added to the container as: ```c++
If there is no such element, it is added to the container as: ```c++
:1068
06/05/2026
Browse all string changes

Things to check

Double space

Translation contains double space.

Fix string

Reset

Mismatching line breaks

Number of new lines in translation does not match source.

Reset

Glossary

English Chinese (Simplified Han script)
No related strings found in the glossary.

String information

Key
:1068
Flags
safe-html, strict-same
Unit identifier
55642
Source string location
:1068
String age
06/05/2026
Last updated
06/06/2026
Source string age
06/05/2026
Translation file AsciiDoc file
doc/modules/ROOT/pages/reference/unordered_map_zh_Hans.adoc, string 260