User avatar admin

Translation uploaded
Inserts a new element into the container or updates an existing one by assigning to the contained value.
Inserts a new element into the container or updates an existing one by assigning to the contained value.向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1108
06/05/2026
User avatar admin

Translation uploaded
```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 Mm=""> iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&&amp;&amp; obj); template<class Mm=""> iterator insert_or_assign(const_iterator hint, key_type&& k, M&&amp;&amp; k, M&amp;&amp; obj); template<class K,k,="" class M="" m=""> iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); ```amp;&amp; k, M&amp;&amp; obj); ```</class></class></class>
06/05/2026
User avatar admin

Translation uploaded
insert_or_assign with Hint
带提示位置的 insert_or_assign with Hint
06/05/2026
User avatar admin

Translation uploaded
---
---
:1096
06/05/2026
User avatar admin

Translation uploaded
Returns:;; The `bool` component of the return type is `true` if an insert took place. + + If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + The `template<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.
Returns:;; The `bool` component of the return type is `true` if an insert took place. + + If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + The 返回：返回类型的 `bool` 分量为 `true` 表示发生了插入。
如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。

`template<class K,k,="" class M>` only participates in overload resolution if="" m="">` 仅在 `Hash::is_transparent` and和 `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both是有效的成员 typedef 时参与重载决议。库假定 `Hash` 可同时使用 `K` and和 `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
06/05/2026
User avatar admin

Translation uploaded
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<Kk>(k)), std::forward_as_tuple(std::forward<Mm>(obj))) ```</m></k>
:1082
06/05/2026
User avatar admin

Translation uploaded
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<Kkey>(k)), std::forward_as_tuple(std::forward<Mm>(obj)))</m></key>
:1077
06/05/2026
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++
:1074
06/05/2026
User avatar admin

Translation uploaded
If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.
If there is an element with key `k`, then it is updated by assigning如果存在键为 `k` 的元素，则通过赋值 `std::forward<Mm>(obj)`. 来更新它。</m>
:1072
06/05/2026
User avatar admin

Translation uploaded
Inserts a new element into the container or updates an existing one by assigning to the contained value.
Inserts a new element into the container or updates an existing one by assigning to the contained value.向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1070
06/05/2026
User avatar admin

Translation uploaded
```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> m="">
std::pair<iterator, bool=""> insert_or_assign(const key_type&amp; k, M&&amp;&amp; obj);
template<class M> m="">
std::pair<iterator, bool=""> insert_or_assign(key_type&& k, M&&amp;&amp; k, M&amp;&amp; obj);
template<class K,k,="" class M> ="" m="">
std::pair<iterator, bool=""> insert_or_assign(K&& k, M&&amp;&amp; k, M&amp;&amp; obj);
```</iterator,></class></iterator,></class></iterator,></class>
06/05/2026
User avatar admin

Translation uploaded
insert_or_assign
insert_or_assign
06/05/2026
User avatar admin

Translation uploaded
---
---
:1058
06/05/2026
User avatar admin

Translation uploaded
--
--
:1056
06/05/2026
User avatar admin

Translation uploaded
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.
The `template<class K, class\... Args>` overload only participates in overload resolution ifk,="" args="">` 重载仅在 `Hash::is_transparent` and和 `Pred::is_transparent` are valid member typedefs and neither是有效的成员 typedef，且 `iterator` nor和 `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both都不能从 `K` 隐式转换时参与重载决议。库假定 `Hash` 可同时使用 `K` and和 `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.调用，且 `Pred` 是透明的。这支持了异构查找，从而避免了实例化 `Key` 类型对象的开销。</class>
:1054
06/05/2026
User avatar admin

Translation uploaded
Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load.
Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load.可能使迭代器失效，但仅当插入导致负载大于最大负载时才会发生。
:1052
06/05/2026
User avatar admin

Translation uploaded
unlike xref:#unordered_node_map_emplace_hint[emplace_hint], which simply forwards all arguments to ``value_type``'s constructor.
unlike与 xref:#unordered_node_map_emplace_hint[emplace_hint], which simply forwards all arguments to ``value_type``'s constructor. 不同，后者只是将所有参数直接转发给 `value_type` 的构造函数。
06/05/2026
User avatar admin

Translation uploaded
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<Kk>(k)), std::forward_as_tuple(std::forward<Aargs>(args)...)) ```</args></k>
:1045
06/05/2026
User avatar admin

Translation uploaded
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<Kkey>(k)), std::forward_as_tuple(std::forward<Aargs>(args)...))</args></key>
:1040
06/05/2026
User avatar admin

Translation uploaded
Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; This function is similiar to xref:#unordered_node_map_emplace_hint[emplace_hint], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; This function is similiar to xref:#unordered_node_map_emplace_hint[emplace_hint], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- 返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。
抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：此函数类似于 xref:#unordered_node_map_emplace_hint[emplace_hint]，区别在于如果存在具有等价键的元素，则不构造 `value_type`；否则，构造形式为：

```c++
06/05/2026

Search