Exit Zen
:1328
:1328
English
Otherwise if the insertion took place, `inserted` is true and `node` is empty.
41/780 · 78
:1151
:1151
English
---
3/100 · 3
312
:1246
English
Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * bucket_count()`
72/830 · 83
312
:1243
English
```c++ template<class InputIterator,class F1, class F2> size_type insert_and_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); template<class InputIterator,class F1, class f2> size_type insert_and_cvisit(InputIterator first, InputIterator last, F1 f1, F2 f2); ```
315/2750 · 275
312
:1367
English
The `template<class K, class\... Args, class F1, class F2>` 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.
203/3930 · 393
:1129
:1129
English
Invalidates iterators, pointers and references, and changes the order of elements.
22/820 · 82
312
:1154
English
```c++ std::pair<iterator, iterator> equal_range(const key_type& k); std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const; template<class K> std::pair<iterator, iterator> equal_range(const K& k); template<class K> std::pair<const_iterator, const_iterator> equal_range(const K& k) const; ```
454/3440 · 344
312
:1227
English
```c++ bool contains(const key_type& k) const; template<class K> bool contains(const K& k) const; ```
142/1230 · 123
312
:1262
English
Returns:;; The iterator following the erased elements - i.e. `last`. 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.
117/3070 · 307
313
:1253
English
```c++ template<class ExecutionPolicy, class F> void erase_if(ExecutionPolicy&& policy, F f); ```
122/980 · 98
313
:1183
English
find
4/100 · 4
313
:1146
English
```c++ iterator find(const key_type& k); const_iterator find(const key_type& k) const; template<class K> iterator find(const K& k); template<class K> const_iterator find(const K& k) const; template<typename CompatibleKey, typename CompatibleHash, typename CompatiblePredicate> iterator find(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate const& eq); template<typename CompatibleKey, typename CompatibleHash, typename CompatiblePredicate> const_iterator find(CompatibleKey const& k, CompatibleHash const& hash, CompatiblePredicate const& eq) const;
684/5940 · 594
:1329
:1329
English
If the insertion failed, `inserted` is false and `node` has the previous value of `nh`.
51/870 · 87
313
:1153
English
equal_range
11/110 · 11
:1248
:1248
English
---
3/100 · 3
:1250
:1250
English
Equivalent to [listing,subs="+macros,+quotes"]
36/460 · 46
:1369
:1369
English
--
2/100 · 2
:1132
:1132
English
Throws:;; The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.
40/1400 · 140
313
:1164
English
Returns:;; A range containing all elements with key equivalent to `k`. If the container doesn't contain any such elements, returns `std::make_pair(b.end(), b.end())`. 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.
267/5330 · 533
313
:1234
English
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.
217/4740 · 474