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

:972 :972
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Equivalent to [listing,subs="+macros,+quotes"] 46/10000 · 46
234 :911
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Removes an element with key equivalent to `k`. 46/10000 · 46
234 :997
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class InputIterator> size_type insert(InputIterator first, InputIterator last); ``` 99/10000 · 99
:982 :982
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — If there is an existing element with key `k` this function does nothing. 72/10000 · 72
234 :915
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The iterator following the erased elements - i.e. `last`. Throws:;; Nothing in this implementation (neither the `hasher` nor the `key_equal` objects are called). 172/10000 · 172
:911 :911
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — `hint` is a suggestion to where the element should be inserted. 63/10000 · 63
:986 :986
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — -- 2/10000 · 2
235 :366
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — {svn-ticket-url}/3693[Ticket 3693^]: 36/10000 · 36
:986 :986
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) 133/10000 · 133
235 :944
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. Notes:;; In C++17 a node extracted using this method can be inserted into a compatible `unordered_multiset`, but that is not supported yet. + + The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. 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. 746/10000 · 746
:927 :927
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
235 :1064
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ size_type insert(std::initializer_list<value_type> il); ``` 66/10000 · 66
235 :1043
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Requires:;; `value_type` is constructible from `args`. 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 interface is exposition only, as C++ does not allow to declare a parameter `f` after a variadic parameter pack. 349/10000 · 349
:979 :979
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The number of elements inserted. 43/10000 · 43
235 :914
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`. + + The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. 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. 701/10000 · 701
:1001 :1001
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Equivalent to [listing,subs="+macros,+quotes"] 46/10000 · 46
235 :985
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The `bool` component of the return type is `true` if an insert took place. + + 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:;; This function is similiar to xref:#unordered_node_map_emplace[emplace], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++ 579/10000 · 579
:918 :918
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
235 :914
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Requires:;; `nh` is empty or `nh.get_allocator()` is equal to the container's allocator. Returns:;; If `nh` was empty, returns `end()`. + + Otherwise returns an iterator pointing to the newly inserted element. 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. + + This can be used to insert a node extracted from a compatible `unordered_set`. 798/10000 · 798
:988 :988
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3