2. Boost Unordered Translation (zh_Hans)
3. English
4. Zen

321 :1183
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — contains 8/10000 · 8
321 :1280
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Insert Node and Visit 21/10000 · 21
321 :1271
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``` allocator_type get_allocator() const noexcept; ``` 54/10000 · 54
:1150 :1150
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
321 :1182
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ size_type max_bucket_count() const noexcept; ``` 55/10000 · 55
321 :1263
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 927/10000 · 927
:1292 :1292
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. + + In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations. Notes:;; This method was implemented because returning an iterator to the next element from erase was expensive, but the container has been redesigned so that is no longer the case. So this method is now deprecated. 454/10000 · 454
322 :1221
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ bool contains(const key_type& k) const; template<class K> bool contains(const K& k) const; ``` 123/10000 · 123
322 :1181
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Hash Policy 11/10000 · 11
322 :1364
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — unlike xref:#concurrent_node_map_emplace[emplace], which simply forwards all arguments to ``value_type``'s constructor. 119/10000 · 119
322 :1398
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + 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. 536/10000 · 536
:1285 :1285
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
322 :1184
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ bool contains(const key_type& k) const; template<class K> bool contains(const K& k) const; ``` 123/10000 · 123
322 :1281
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class F1, class F2> insert_return_type insert_and_visit(node_type&& nh, F1 f1, F2 f2); template<class F1, class F2> insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ``` 203/10000 · 203
322 :1276
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The container's allocator. 37/10000 · 37
322 :1152
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Statistics 10/10000 · 10
322 :1187
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; An upper bound on the number of buckets. 51/10000 · 51
:1270 :1270
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
:1297 :1297
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
323 :1228
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 474/10000 · 474