User avatar admin

Translation uploaded
Requires:;; `n < bucket_count()` Returns:;; The number of elements in bucket `n`.
Requires:要求：;; `n <&lt; bucket_count()` Returns:;; The number of elements in bucket `n`.返回：;; 桶 `n` 中的元素个数。
06/05/2026
User avatar admin

Translation uploaded
```c++ size_type bucket_size(size_type n) const; ```
```c++ size_type bucket_size(size_type n) const; ```
06/05/2026
User avatar admin

Translation uploaded
bucket_size
bucket_size桶大小
06/05/2026
User avatar admin

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

Translation uploaded
Returns:;; An upper bound on the number of buckets.
Returns:;; An upper bound on the number of buckets.返回：;; 桶数量的上限。
06/05/2026
User avatar admin

Translation uploaded
```c++ size_type max_bucket_count() const noexcept; ```
```c++ size_type max_bucket_count() const noexcept; ```
06/05/2026
User avatar admin

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

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

Translation uploaded
Returns:;; The number of buckets.
Returns:;; The number of buckets.返回：;; 桶的数量。
06/05/2026
User avatar admin

Translation uploaded
```c++ size_type bucket_count() const noexcept; ```
```c++ size_type bucket_count() const noexcept; ```
06/05/2026
User avatar admin

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

Translation uploaded
Bucket Interface
Bucket Interface桶接口
06/05/2026
User avatar admin

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

Translation uploaded
Returns:;; A reference to `x.second` where `x` is the (unique) element whose key is equivalent to `k`. Throws:;; An exception object of type `std::out_of_range` if no such element is present. 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 reference to `x.second` where `x` is the (unique) element whose key is equivalent to `k`. Throws:;; An exception object of type `std::out_of_range` if no such element is present. Notes:;; The `template<class K>` overloads only participate in overload resolution if返回：;; 指向 `x.second` 的引用，其中 `x` 是键与 `k` 等价的（唯一）元素。
抛出：;; 如果不存在这样的元素，则抛出 `std::out_of_range` 类型的异常对象。
备注：;; 仅当 `Hash::is_transparent` and和 `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both是有效的成员 typedef 时，`template<class 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>
06/05/2026
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
---
---
:1480
06/05/2026
User avatar admin

Translation uploaded
Effects:;; If the container does not already contain an elements 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, 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>` 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 elements 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, 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>` overload only participates in overload resolution if。
返回：;; 指向 `x.second` 的引用，其中 `x` 是容器中已存在的元素，或者是键与 `k` 等价的新插入元素。
抛出：;; 如果除调用 `hasher` 之外的操作抛出异常，则该函数无效。
备注：;; 可能使迭代器失效，但仅当插入导致负载因子大于或等于最大负载因子时才会发生。
此外，指向元素的指针和引用永远不会失效。
另外，仅当 `Hash::is_transparent` and和 `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both是有效的成员 typedef 时，`template<class 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` 类型调用，且 `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

Search