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

382 :1355
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — reserve 7/10000 · 7
382 :1456
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``` hasher hash_function() const; ``` 37/10000 · 37
382 :1455
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Changes if necessary the size of the bucket array so that there are at least `n` buckets, and so that the load factor is less than or equal to the maximum load factor. When applicable, this will either grow or shrink the `bucket_count()` associated with the container. 268/10000 · 268
382 :1351
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class Key, class Hash, class Pred, class Alloc> bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& x, const unordered_multiset<Key, Hash, Pred, Alloc>& y); ``` 190/10000 · 190
382 :1450
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator==(const unordered_flat_map<Key, T, Hash, Pred, Alloc>& x, const unordered_flat_map<Key, T, Hash, Pred, Alloc>& y); ``` 205/10000 · 205
383 :1483
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```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; ``` 200/10000 · 200
383 :1392
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ void reserve(size_type n); ``` 37/10000 · 37
383 :1350
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — erase_if 8/10000 · 8
383 :1584
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Extracts the element with key equivalent to `k`, if it exists. 62/10000 · 62
383 :1584
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — bucket_count 12/10000 · 12
383 :1459
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — reserve 7/10000 · 7
383 :1356
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ void reserve(size_type n); ``` 37/10000 · 37
383 :1461
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The table's hash function. 37/10000 · 37
383 :1457
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array. If the provided Allocator uses fancy pointers, a default allocation is subsequently performed. 172/10000 · 172
383 :1357
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Return `true` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types). 184/10000 · 184
383 :1456
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Return `true` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types). 184/10000 · 184
384 :1491
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 558/10000 · 558
384 :1396
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`, or `a.rehash(1)` if `n > 0` and `a.max_load_factor() == std::numeric_limits<float>::infinity()`. 153/10000 · 153
384 :1351
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class K, class T, class H, class P, class A, class Predicate> typename unordered_node_set<K, T, H, P, A>::size_type erase_if(unordered_node_set<K, T, H, P, A>& c, Predicate pred); ``` 199/10000 · 199
384 :1587
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; A `node_type` object holding the extracted element, or empty if no element was extracted. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. 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. 546/10000 · 546