User avatar admin

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

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

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

Translation uploaded
Effects:;; If the container does not already contain an element with a key equivalent to `k`, inserts the value `std::pair<key_type const, mapped_type>(k, mapped_type())`. Returns:;; A reference to `x.second` where `x` is the element already in the container, or the newly inserted element with a key equivalent to `k`. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. + + The `template<class K>` overload 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.
Effects:;; If the container does not already contain an element with a key equivalent to `k`, inserts the value效果：如果容器尚未包含键与 `k` 等价的元素，则插入值 `std::pair<key_type const,="" mapped_type="">(k, mapped_type())`. Returns:;; A reference to `x.second` where `x` is the element already in the container, or the newly inserted element with a key equivalent to `k`. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. + + The `template<class K>` overload only participates in overload resolution if。返回：对 `x.second` 的引用，其中 `x` 是容器中已存在的元素，或键与 `k` 等价的新插入元素。抛出：如果调用 `hasher` 以外的操作抛出异常，则该函数无效果。注意：可能会导致迭代器、指针和引用失效，但仅当插入操作导致负载因子超过最大负载因子时才会发生。+ +`template<class k="">` 重载仅在 `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` 调用，且 `Pred` 是透明的。该机制支持异构查找，从而避免实例化 `Key` 类型的开销。</class></key_type.>
06/05/2026
User avatar admin

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

Translation uploaded
operator++[++++]++
operator++[++++]++
06/05/2026
User avatar admin

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

Translation uploaded
Returns:;; A range containing all elements with key equivalent to `k`. If the container doesn't contain any such elements, returns `std::make_pair(b.end(), b.end())`. Notes:;; The `template<class K>` 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.
Returns:;; A range containing all elements with key equivalent to `k`. If the container doesn't contain any such elements, returns `std::make_pair(b.end(), b.end())`. Notes:;; The `template<class K>` overloads only participate in overload resolution if返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。注意：`template<class k="">` 重载仅在 `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
```c++ std::pair<iterator, iterator> equal_range(const key_type& k); std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const; template<class K> std::pair<iterator, iterator> equal_range(const K& k); template<class K> std::pair<const_iterator, const_iterator> equal_range(const K& k) const; ```
```c++ std::pair<iterator, iterator=""> equal_range(const key_type&amp; k); std::pair<const_iterator, const_iterator=""> equal_range(const key_type&amp; k) const; template<class Kk=""> std::pair<iterator, iterator=""> equal_range(const K&amp; k); template<class Kk=""> std::pair<const_iterator, const_iterator=""> equal_range(const K&amp; k) const; ```</const_iterator,></class></iterator,></class></const_iterator,></iterator,>
06/05/2026
User avatar admin

Translation uploaded
equal_range
equal_++_++range
06/05/2026
User avatar admin

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

Translation uploaded
Returns:;; A boolean indicating whether or not there is an element with key equal to `key` in the container Notes:;; The `template<class K>` overload 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:;; A boolean indicating whether or not there is an element with key equal to `key` in the container Notes:;; The `template<class K>` overload only participates in overload resolution if返回：一个布尔值，指示容器中是否存在键等于 `key` 的元素。注意：`template<class k="">` 重载仅在 `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
```c++ bool contains(const key_type& k) const; template<class K> bool contains(const K& k) const; ```
```c++ bool contains(const key_type&amp; k) const; template<class Kk=""> bool contains(const K&amp; k) const; ```</class>
06/05/2026
User avatar admin

Translation uploaded
contains
contains包含
06/05/2026
User avatar admin

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

Translation uploaded
Returns:;; The number of elements with key equivalent to `k`. Notes:;; The `template<class K>` overload 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 number of elements with key equivalent to `k`. Notes:;; The `template<class K>` overload only participates in overload resolution if返回：键与 `k` 等价的元素数量。注意：`template<class k="">` 重载仅在 `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
```c++ size_type count(const key_type& k) const; template<class K> size_type count(const K& k) const; ```
```c++ size_type count(const key_type&amp; k) const; template<class Kk=""> size_type count(const K&amp; k) const; ```</class>
06/05/2026
User avatar admin

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

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

Translation uploaded
Returns:;; An iterator pointing to an element with key equivalent to `k`, or `end()` if no such element exists. Notes:;; The `template<class K>` 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.
Returns:;; An iterator pointing to an element with key equivalent to `k`, or `end()` if no such element exists. Notes:;; The `template<class K>` overloads only participate in overload resolution if返回：指向键与 `k` 等价的元素的迭代器，若不存在这样的元素则返回 `end()`。注意：`template<class k="">` 重载仅在 `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

Search