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>
:1111
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++向容器中插入新元素，或通过赋值给已存在的元素值来更新该元素。
:1108
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>
:1106
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.向容器中插入一个新元素，或通过赋值更新现有元素的值。
:1104
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
---
---
:1092
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 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.
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 返回：返回类型的 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>
:1076
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>
:1071
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++
:1068
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>
: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

Search