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>
:1066
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.向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1064
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 Mm=""> std::pair<iterator, bool=""> insert_or_assign(const key_type&amp; k, M&&amp;&amp; obj); template<class Mm=""> 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&& obj); ```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
---
---
:1052
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>
:1049
06/05/2026
User avatar admin

Translation uploaded
Pointers and references to elements are never invalidated.
Pointers and references to elements are never invalidated.指向元素的指针和引用永远不会失效。
:1047
06/05/2026
User avatar admin

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

Translation uploaded
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.
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 支持的唯一方式，是将其指向一个具有相同键的已存在元素。
06/05/2026
User avatar admin

Translation uploaded
instead of xref:#unordered_map_emplace_hint[emplace_hint] which simply forwards all arguments to ``value_type``'s constructor.
instead of而不是像 xref:#unordered_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>
:1036
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>
:1031
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_map_emplace_hint[emplace_hint] except the `value_type` is constructed using: + + -- ```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返回：如果发生了插入，则迭代器指向新插入的元素；否则，指向具有等价键的元素。 抛出：如果除调用 `hasher` 之外的操作抛出异常，则该函数无效果。
注意：此函数类似于 xref:#unordered_map_emplace_hint[emplace_hint] except the，区别在于 `value_type` is constructed using: + + -- 的构造方式如下：
```c++
06/05/2026
User avatar admin

Translation uploaded
`hint` is a suggestion to where the element should be inserted.
`hint` is a suggestion to where the element should be inserted.是关于元素插入位置的建议。
:1021
06/05/2026
User avatar admin

Translation uploaded
If there is an existing element with key `k` this function does nothing.
If there is an existing element with key `k` this function does nothing.如果已存在键为 `k` 的元素，则该函数不执行任何操作。
:1019
06/05/2026
User avatar admin

Translation uploaded
Inserts a new element into the container if there is no existing element with key `k` contained within it.
Inserts a new element into the container if there is no existing element with key `k` contained within it.如果容器中不存在键为 `k` 的元素，则插入一个新元素。
:1017
06/05/2026
User avatar admin

Translation uploaded
```c++ template<class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template<class... Args> iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template<class K, class... Args> iterator try_emplace(const_iterator hint, K&& k, Args&&... args); ```
```c++ template<class... Aargs=""> iterator try_emplace(const_iterator hint, const key_type&amp; k, Args&&amp;&amp;... args); template<class... Aargs=""> iterator try_emplace(const_iterator hint, key_type&& k, Args&&amp;&amp; k, Args&amp;&amp;... args); template<class K,k,="" class... Args="" args=""> iterator try_emplace(const_iterator hint, K&& k, Args&&... args); ```amp;&amp; k, Args&amp;&amp;... args); ```</class></class...></class...>
06/05/2026
User avatar admin

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

Translation uploaded
---
---
:1005
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>
:1002
06/05/2026

Search