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

273 :426
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Use 3/10000 · 3
273 :1124
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same key. + + 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, 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. 1018/10000 · 1018
:1075 :1075
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Erase the element pointed to by `position`. 43/10000 · 43
273 :1039
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ init_type pull(const_iterator position); ``` 51/10000 · 51
273 :1191
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Insert Node or Visit 20/10000 · 20
273 :1201
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class InputIterator, class F1, class F2> size_type insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class InputIterator, class F1, class F2> size_type insert_or_cvisit(InputIterator first, InputIterator last, F1 f1, F2 f2); ``` 275/10000 · 275
273 :1114
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class F1, class F2> bool insert_and_visit(const value_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit(const value_type& obj, F1 f1, F2 f2); ``` 189/10000 · 189
:1042 :1042
	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
273 :1114
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class InputIterator,class F> size_type insert_or_visit(InputIterator first, InputIterator last, F f); template<class InputIterator,class F> size_type insert_or_cvisit(InputIterator first, InputIterator last, F f); ``` 233/10000 · 233
273 :1128
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. 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 to be greater than the maximum load. + + 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. 731/10000 · 731
:1017 :1017
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
273 :1037
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — merge 5/10000 · 5
273 :1126
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. 67/10000 · 67
274 :427
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — link:../../../../type_traits/index.html[aligned storage^] to store the types. This changes the way the allocator is used to construct nodes. It used to construct the node with two calls to the allocator's `construct` method - once for the pointers and once for the value. It now constructs the node with a single call to construct and then constructs the value using in place construction. 389/10000 · 389
:1134 :1134
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
:1078 :1078
	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
274 :1043
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Move-constructs an `init_value` `x` from the element pointed to by `position`, erases the element and returns `x`. 114/10000 · 114
274 :1192
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class F> insert_return_type insert_or_visit(node_type&& nh, F f); template<class F> insert_return_type insert_or_cvisit(node_type&& nh, F f); ``` 161/10000 · 161
:1208 :1208
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Equivalent to [listing,subs="+macros,+quotes"] 46/10000 · 46
:1119 :1119
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Inserts `obj` in the table if and only if there is no element in the table with an equivalent key, and then invokes `f1` with a const reference to the newly created element. Otherwise, invokes `f2` with a const reference to the equivalent element. 247/10000 · 247