User avatar admin

Translation uploaded
Erases the element with key equivalent to `k` if it exists.
Erases the element with key equivalent to `k` if it exists.若存在键与 `k` 等价的元素，则删除该元素。
06/05/2026
User avatar admin

Translation uploaded
```c++ size_type erase(const key_type& k); template<class K> size_type erase(const K& k); ```
```c++ size_type erase(const key_type&amp; k); template<class Kk=""> size_type erase(const K&amp; k); ```</class>
06/05/2026
User avatar admin

Translation uploaded
erase
erase擦除
06/05/2026
User avatar admin

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

Translation uploaded
Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; 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:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; The `template<class K, class M>` only participates in overload resolution if返回值：;; 若执行插入操作则返回 `true`。
并发特性：;; 阻塞对 `*this` 的重哈希操作。
注意：;; 仅当 `Hash::is_transparent` and和 `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both是有效的成员类型别名时，`template<class k,="" class="" m="">` 才参与重载决议。库假定 `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>
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>
06/05/2026
User avatar admin

Translation uploaded
If there is no such element, it is added to the table as: ```c++
If there is no such element, it is added to the table as: ```c++若不存在该元素，则以如下形式添加到表中：
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>
06/05/2026
User avatar admin

Translation uploaded
Inserts a new element into the table or updates an existing one by assigning to the contained value.
Inserts a new element into the table or updates an existing one by assigning to the contained value.向表中插入新元素，或通过为已包含的值赋值来更新现有元素。
06/05/2026
User avatar admin

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

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

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

Translation uploaded
The `template<class K, class\... Args, class F1, class F2>` 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.
The `template<class K, class\... Args, class F1, class F2>` 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为有效成员类型别名时，`template<class k,="" args,="" class="" f1,="" f2="">` 这些重载版本才会参与重载决议。
库假定 `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
The interface is exposition only, as C++ does not allow to declare parameter `f1` and `f2` after a variadic parameter pack.
The interface is exposition only, as C++ does not allow to declare parameter该接口仅为说明性用法，因为 C++ 不允许在可变参数包之后声明 `f1` and和 `f2` after a variadic parameter pack.参数。
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>
:1452
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>
:1447
06/05/2026
User avatar admin

Translation uploaded
Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++
Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++返回值：;; 若执行插入操作则返回 true。
并发特性：;; 阻塞对 *this 的重哈希操作。
注意：;; 若已存在等价键的元素，则不会构造 value_type；否则，构造方式如下：
:1439
06/05/2026
User avatar admin

Translation uploaded
Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.
Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used.若表中不存在键为`k`的元素，则将由`k`和`args`构造的元素插入表中，随后以非常量引用指向新创建的元素并调用`f1`。
否则，以指向等价元素的引用调用`f2`；当且仅当使用`*_cvisit`重载版本时，该引用为常量引用。
06/05/2026

Search