[unord] (original) (raw)

The header defines the class templates unordered_map and unordered_multimap; the header defines the class templates unordered_set and unordered_multiset.

The exposition-only alias templates_iter-value-type_, iter-key-type,iter-mapped-type, iter-to-alloc-type,range-key-type, range-mapped-type, and _range-to-alloc-type_defined in [associative.general] may appear in deduction guides for unordered containers.

23.5.2 Header <unordered_map> synopsis [unord.map.syn]

23.5.3 Class template unordered_map [unord.map]

23.5.3.1 Overview [unord.map.overview]

An unordered_map is an unordered associative container that supports unique keys (an unordered_map contains at most one of each key value) and that associates values of another typemapped_type with the keys.

The unordered_map class supports forward iterators.

It provides the operations described in the preceding requirements table for unique keys; that is, an unordered_map supports the a_uniq operations in that table, not the a_eq operations.

For an unordered_map<Key, T> the key_type is Key, the mapped_type is T, and the value_type is pair<const Key, T>.

Subclause [unord.map] only describes operations on unordered_map that are not described in one of the requirement tables, or for which there is additional semantic information.

namespace std { template<class Key,class T,class Hash = hash<Key>,class Pred = equal_to<Key>,class Allocator = allocator<pair<const Key, T>>> class unordered_map { public: using key_type = Key;using mapped_type = T;using value_type = pair<const Key, T>;using hasher = Hash;using key_equal = Pred;using allocator_type = Allocator;using pointer = allocator_traits<Allocator>::pointer;using const_pointer = allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using size_type = implementation-defined; using difference_type = implementation-defined; using iterator = implementation-defined; using const_iterator = implementation-defined; using local_iterator = implementation-defined; using const_local_iterator = implementation-defined; using node_type = unspecified;using insert_return_type = insert-return-type<iterator, node_type>;constexpr unordered_map();constexpr explicit unordered_map(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<class InputIterator> constexpr unordered_map(InputIterator f, InputIterator l, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<container-compatible-range<value_type> R> constexpr unordered_map(from_range_t, R&& rg, size_type n = see below,const hasher& hf = hasher(), const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_map(const unordered_map&);constexpr unordered_map(unordered_map&&);constexpr explicit unordered_map(const Allocator&);constexpr unordered_map(const unordered_map&, const type_identity_t<Allocator>&);constexpr unordered_map(unordered_map&&, const type_identity_t<Allocator>&);constexpr unordered_map(initializer_list<value_type> il, size_type n = see below,const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_map(size_type n, const allocator_type& a) : unordered_map(n, hasher(), key_equal(), a) { } constexpr unordered_map(size_type n, const hasher& hf, const allocator_type& a) : unordered_map(n, hf, key_equal(), a) { } template<class InputIterator> constexpr unordered_map(InputIterator f, InputIterator l, size_type n,const allocator_type& a) : unordered_map(f, l, n, hasher(), key_equal(), a) { } template<class InputIterator> constexpr unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,const allocator_type& a) : unordered_map(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf,const allocator_type& a) : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } constexpr unordered_map(initializer_list<value_type> il, size_type n,const allocator_type& a) : unordered_map(il, n, hasher(), key_equal(), a) { } constexpr unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,const allocator_type& a) : unordered_map(il, n, hf, key_equal(), a) { } constexpr ~unordered_map();constexpr unordered_map& operator=(const unordered_map&);constexpr unordered_map& operator=(unordered_map&&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);constexpr unordered_map& operator=(initializer_list<value_type>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);template<class... Args> constexpr iterator emplace_hint(const_iterator position, Args&&... args);constexpr pair<iterator, bool> insert(const value_type& obj);constexpr pair<iterator, bool> insert(value_type&& obj);template<class P> constexpr pair<iterator, bool> insert(P&& obj);constexpr iterator insert(const_iterator hint, const value_type& obj);constexpr iterator insert(const_iterator hint, value_type&& obj);template<class P> constexpr iterator insert(const_iterator hint, P&& obj);template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);template<container-compatible-range<value_type> R> constexpr void insert_range(R&& rg);constexpr void insert(initializer_list<value_type>);constexpr node_type extract(const_iterator position);constexpr node_type extract(const key_type& x);template<class K> constexpr node_type extract(K&& x);constexpr insert_return_type insert(node_type&& nh);constexpr iterator insert(const_iterator hint, node_type&& nh);template<class... Args> constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);template<class... Args> constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);template<class K, class... Args> constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);template<class... Args> constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);template<class... Args> constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);template<class K, class... Args> constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);template<class M> constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);template<class M> constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);template<class K, class M> constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);template<class M> constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);template<class M> constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);template<class K, class M> constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);constexpr iterator erase(iterator position);constexpr iterator erase(const_iterator position);constexpr size_type erase(const key_type& k);template<class K> constexpr size_type erase(K&& x);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(unordered_map&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);constexpr void clear() noexcept;template<class H2, class P2> constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);template<class H2, class P2> constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);constexpr hasher hash_function() const;constexpr key_equal key_eq() const;constexpr iterator find(const key_type& k);constexpr const_iterator find(const key_type& k) const;template<class K> constexpr iterator find(const K& k);template<class K> constexpr const_iterator find(const K& k) const;constexpr size_type count(const key_type& k) const;template<class K> constexpr size_type count(const K& k) const;constexpr bool contains(const key_type& k) const;template<class K> constexpr bool contains(const K& k) const;constexpr pair<iterator, iterator> equal_range(const key_type& k);constexpr pair<const_iterator, const_iterator> equal_range(const key_type& k) const;template<class K> constexpr pair<iterator, iterator> equal_range(const K& k);template<class K> constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;constexpr mapped_type& operator[](const key_type& k);constexpr mapped_type& operator[](key_type&& k);template<class K> constexpr mapped_type& operator[](K&& k);constexpr mapped_type& at(const key_type& k);constexpr const mapped_type& at(const key_type& k) const;template<class K> constexpr mapped_type& at(const K& k);template<class K> constexpr const mapped_type& at(const K& k) const;constexpr size_type bucket_count() const noexcept;constexpr size_type max_bucket_count() const noexcept;constexpr size_type bucket_size(size_type n) const;constexpr size_type bucket(const key_type& k) const;template<class K> constexpr size_type bucket(const K& k) const;constexpr local_iterator begin(size_type n);constexpr const_local_iterator begin(size_type n) const;constexpr local_iterator end(size_type n);constexpr const_local_iterator end(size_type n) const;constexpr const_local_iterator cbegin(size_type n) const;constexpr const_local_iterator cend(size_type n) const;constexpr float load_factor() const noexcept;constexpr float max_load_factor() const noexcept;constexpr void max_load_factor(float z);constexpr void rehash(size_type n);constexpr void reserve(size_type n);};template<class InputIterator,class Hash = hash<_iter-key-type_<InputIterator>>,class Pred = equal_to<_iter-key-type_<InputIterator>>,class Allocator = allocator<_iter-to-alloc-type_<InputIterator>>> unordered_map(InputIterator, InputIterator, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_map<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred, Allocator>;template<ranges::input_range R, class Hash = hash<_range-key-type_<R>>,class Pred = equal_to<_range-key-type_<R>>,class Allocator = allocator<_range-to-alloc-type_<R>>> unordered_map(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_map<_range-key-type_<R>, range-mapped-type<R>, Hash, Pred, Allocator>;template<class Key, class T, class Hash = hash<Key>,class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>> unordered_map(initializer_list<pair<Key, T>>,typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_map<Key, T, Hash, Pred, Allocator>;template<class InputIterator, class Allocator> unordered_map(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_map<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, hash<_iter-key-type_<InputIterator>>, equal_to<_iter-key-type_<InputIterator>>, Allocator>;template<class InputIterator, class Allocator> unordered_map(InputIterator, InputIterator, Allocator) -> unordered_map<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, hash<_iter-key-type_<InputIterator>>, equal_to<_iter-key-type_<InputIterator>>, Allocator>;template<class InputIterator, class Hash, class Allocator> unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_map<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, Hash, equal_to<_iter-key-type_<InputIterator>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_map<_range-key-type_<R>, range-mapped-type<R>, hash<_range-key-type_<R>>, equal_to<_range-key-type_<R>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_map(from_range_t, R&&, Allocator) -> unordered_map<_range-key-type_<R>, range-mapped-type<R>, hash<_range-key-type_<R>>, equal_to<_range-key-type_<R>>, Allocator>;template<ranges::input_range R, class Hash, class Allocator> unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_map<_range-key-type_<R>, range-mapped-type<R>, Hash, equal_to<_range-key-type_<R>>, Allocator>;template<class Key, class T, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Allocator) -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;template<class Key, class T, class Allocator> unordered_map(initializer_list<pair<Key, T>>, Allocator) -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>;template<class Key, class T, class Hash, class Allocator> unordered_map(initializer_list<pair<Key, T>>, typename see below::size_type, Hash, Allocator) -> unordered_map<Key, T, Hash, equal_to<Key>, Allocator>;}

A size_type parameter type in an unordered_map deduction guide refers to the size_type member type of the type deduced by the deduction guide.

23.5.3.2 Constructors [unord.map.cnstr]

constexpr unordered_map() : unordered_map(size_type(_see below_)) { } constexpr explicit unordered_map(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_map using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

For the default constructor, the number of buckets is implementation-defined.

max_load_factor() returns 1.0.

template<class InputIterator> constexpr unordered_map(InputIterator f, InputIterator l, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<value_type> R> constexpr unordered_map(from_range_t, R&& rg, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_map(initializer_list<value_type> il, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_map using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

If n is not provided, the number of buckets is implementation-defined.

Then inserts elements from the range [f, l), rg, or il, respectively.

max_load_factor() returns 1.0.

Complexity: Average case linear, worst case quadratic.

23.5.3.3 Element access [unord.map.elem]

constexpr mapped_type& operator[](const key_type& k);

Effects: Equivalent to: return try_emplace(k).first->second;

constexpr mapped_type& operator[](key_type&& k);

Effects: Equivalent to: return try_emplace(std::move(k)).first->second;

template<class K> constexpr mapped_type& operator[](K&& k);

Constraints: The qualified-ids Hash::is_transparent andPred::is_transparent are valid and denote types.

Effects: Equivalent to: return try_emplace(std::forward<K>(k)).first->second;

constexpr mapped_type& at(const key_type& k);constexpr const mapped_type& at(const key_type& k) const;

Returns: A reference to x.second, where x is the (unique) element whose key is equivalent to k.

Throws: An exception object of type out_of_range if no such element is present.

template<class K> constexpr mapped_type& at(const K& k);template<class K> constexpr const mapped_type& at(const K& k) const;

Constraints: The qualified-ids Hash::is_transparent andPred::is_transparent are valid and denote types.

Preconditions: The expression find(k) is well-formed and has well-defined behavior.

Returns: A reference to find(k)->second.

Throws: An exception object of type out_of_rangeif find(k) == end() is true.

23.5.3.4 Modifiers [unord.map.modifiers]

template<class P> constexpr pair<iterator, bool> insert(P&& obj);

Constraints: is_constructible_v<value_type, P&&> is true.

Effects: Equivalent to: return emplace(std::forward<P>(obj));

template<class P> constexpr iterator insert(const_iterator hint, P&& obj);

Constraints: is_constructible_v<value_type, P&&> is true.

Effects: Equivalent to:return emplace_hint(hint, std::forward<P>(obj));

template<class... Args> constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);template<class... Args> constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);

Preconditions: value_type is Cpp17EmplaceConstructible into unordered_mapfrom piecewise_construct, forward_as_tuple(k),forward_as_tuple(std::forward<Args>(args)...).

Effects: If the map already contains an element whose key is equivalent to k, there is no effect.

Otherwise inserts an object of type value_typeconstructed with piecewise_construct, forward_as_tuple(k),forward_as_tuple(std::forward<Args>(args)...).

Returns: In the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the map element whose key is equivalent to k.

Complexity: The same as emplace and emplace_hint, respectively.

template<class... Args> constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);template<class... Args> constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);

Preconditions: value_type is Cpp17EmplaceConstructible into unordered_mapfrom piecewise_construct, forward_as_tuple(std::move(k)),forward_as_tuple(std::forward<Args>(args)...).

Effects: If the map already contains an element whose key is equivalent to k, there is no effect.

Otherwise inserts an object of type value_typeconstructed with piecewise_construct, forward_as_tuple(std::move(k)),forward_as_tuple(std::forward<Args>(args)...).

Returns: In the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the map element whose key is equivalent to k.

Complexity: The same as emplace and emplace_hint, respectively.

template<class K, class... Args> constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);template<class K, class... Args> constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);

Constraints: The qualified-ids Hash::is_transparent andPred::is_transparent are valid and denote types.

For the first overload,is_convertible_v<K&&, const_iterator> andis_convertible_v<K&&, iterator> are both false.

Preconditions: value_type is _Cpp17EmplaceConstructible_into unordered_map frompiecewise_construct, forward_as_tuple(std::forward<K>(k)), forward_as_tuple(std::forward<Args>
(args)...).

Effects: If the map already contains an element whose key is equivalent to k, there is no effect.

Otherwise, let h be hash_function()(k).

Constructs an object u of type value_typewith piecewise_construct, forward_as_tuple(std::forward<K>(k)), forward_as_tuple(std::forward<Args>(args)...).

If hash_function()(u.first) != h || contains(u.first) is true, the behavior is undefined.

Inserts u into *this.

Returns: For the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the map element whose key is equivalent to k.

Complexity: The same as emplace and emplace_hint, respectively.

template<class M> constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);template<class M> constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);

Mandates: is_assignable_v<mapped_type&, M&&> is true.

Preconditions: value_type is Cpp17EmplaceConstructible into unordered_mapfrom k, std::forward<M>(obj).

Effects: If the map already contains an element ewhose key is equivalent to k, assigns std::forward<M>(obj) to e.second.

Otherwise inserts an object of type value_typeconstructed with k, std::forward<M>(obj).

Returns: In the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the map element whose key is equivalent to k.

Complexity: The same as emplace and emplace_hint, respectively.

template<class M> constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);template<class M> constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);

Mandates: is_assignable_v<mapped_type&, M&&> is true.

Preconditions: value_type is Cpp17EmplaceConstructible into unordered_mapfrom std::move(k), std::forward<M>(obj).

Effects: If the map already contains an element ewhose key is equivalent to k, assigns std::forward<M>(obj) to e.second.

Otherwise inserts an object of type value_typeconstructed with std::move(k), std::forward<M>(obj).

Returns: In the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the map element whose key is equivalent to k.

Complexity: The same as emplace and emplace_hint, respectively.

template<class K, class M> constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);template<class K, class M> constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);

Constraints: The qualified-ids Hash::is_transparent andPred::is_transparent are valid and denote types.

Mandates: is_assignable_v<mapped_type&, M&&> is true.

Preconditions: value_type is _Cpp17EmplaceConstructible_into unordered_mapfrom std::forward<K>
(k), std::forward<M>(obj).

Effects: If the map already contains an element ewhose key is equivalent to k, assigns std::forward<M>
(obj) to e.second.

Otherwise, let h be hash_function()(k).

Constructs an object u of type value_typewith std::forward<K>(k), std::forward<M>(obj).

If hash_function()(u.first) != h || contains(u.first) is true, the behavior is undefined.

Inserts u into *this.

Returns: For the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the map element whose key is equivalent to k.

Complexity: The same as emplace and emplace_hint, respectively.

23.5.3.5 Erasure [unord.map.erasure]

template<class K, class T, class H, class P, class A, class Predicate> constexpr typename unordered_map<K, T, H, P, A>::size_type erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);

Effects: Equivalent to:auto original_size = c.size();for (auto i = c.begin(), last = c.end(); i != last; ) { if (pred(*i)) { i = c.erase(i);} else { ++i;} } return original_size - c.size();

23.5.4 Class template unordered_multimap [unord.multimap]

23.5.4.1 Overview [unord.multimap.overview]

An unordered_multimap is an unordered associative container that supports equivalent keys (an instance of unordered_multimap may contain multiple copies of each key value) and that associates values of another type mapped_type with the keys.

The unordered_multimap class supports forward iterators.

It provides the operations described in the preceding requirements table for equivalent keys; that is, an unordered_multimapsupports the a_eq operations in that table, not the a_uniq operations.

For an unordered_multimap<Key, T> the key_type is Key, the mapped_type is T, and the value_type is pair<const Key, T>.

Subclause [unord.multimap] only describes operations on unordered_multimapthat are not described in one of the requirement tables, or for which there is additional semantic information.

namespace std { template<class Key,class T,class Hash = hash<Key>,class Pred = equal_to<Key>,class Allocator = allocator<pair<const Key, T>>> class unordered_multimap { public: using key_type = Key;using mapped_type = T;using value_type = pair<const Key, T>;using hasher = Hash;using key_equal = Pred;using allocator_type = Allocator;using pointer = allocator_traits<Allocator>::pointer;using const_pointer = allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using size_type = implementation-defined; using difference_type = implementation-defined; using iterator = implementation-defined; using const_iterator = implementation-defined; using local_iterator = implementation-defined; using const_local_iterator = implementation-defined; using node_type = unspecified;constexpr unordered_multimap();constexpr explicit unordered_multimap(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<class InputIterator> constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<container-compatible-range<value_type> R> constexpr unordered_multimap(from_range_t, R&& rg, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_multimap(const unordered_multimap&);constexpr unordered_multimap(unordered_multimap&&);constexpr explicit unordered_multimap(const Allocator&);constexpr unordered_multimap(const unordered_multimap&, const type_identity_t<Allocator>&);constexpr unordered_multimap(unordered_multimap&&, const type_identity_t<Allocator>&);constexpr unordered_multimap(initializer_list<value_type> il, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_multimap(size_type n, const allocator_type& a) : unordered_multimap(n, hasher(), key_equal(), a) { } constexpr unordered_multimap(size_type n, const hasher& hf, const allocator_type& a) : unordered_multimap(n, hf, key_equal(), a) { } template<class InputIterator> constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n,const allocator_type& a) : unordered_multimap(f, l, n, hasher(), key_equal(), a) { } template<class InputIterator> constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n,const hasher& hf, const allocator_type& a) : unordered_multimap(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_multimap(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,const allocator_type& a) : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } constexpr unordered_multimap(initializer_list<value_type> il, size_type n,const allocator_type& a) : unordered_multimap(il, n, hasher(), key_equal(), a) { } constexpr unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,const allocator_type& a) : unordered_multimap(il, n, hf, key_equal(), a) { } constexpr ~unordered_multimap();constexpr unordered_multimap& operator=(const unordered_multimap&);constexpr unordered_multimap& operator=(unordered_multimap&&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);constexpr unordered_multimap& operator=(initializer_list<value_type>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;template<class... Args> constexpr iterator emplace(Args&&... args);template<class... Args> constexpr iterator emplace_hint(const_iterator position, Args&&... args);constexpr iterator insert(const value_type& obj);constexpr iterator insert(value_type&& obj);template<class P> constexpr iterator insert(P&& obj);constexpr iterator insert(const_iterator hint, const value_type& obj);constexpr iterator insert(const_iterator hint, value_type&& obj);template<class P> constexpr iterator insert(const_iterator hint, P&& obj);template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);template<container-compatible-range<value_type> R> constexpr void insert_range(R&& rg);constexpr void insert(initializer_list<value_type>);constexpr node_type extract(const_iterator position);constexpr node_type extract(const key_type& x);template<class K> constexpr node_type extract(K&& x);constexpr iterator insert(node_type&& nh);constexpr iterator insert(const_iterator hint, node_type&& nh);constexpr iterator erase(iterator position);constexpr iterator erase(const_iterator position);constexpr size_type erase(const key_type& k);template<class K> constexpr size_type erase(K&& x);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(unordered_multimap&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);constexpr void clear() noexcept;template<class H2, class P2> constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);template<class H2, class P2> constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);constexpr hasher hash_function() const;constexpr key_equal key_eq() const;constexpr iterator find(const key_type& k);constexpr const_iterator find(const key_type& k) const;template<class K> constexpr iterator find(const K& k);template<class K> constexpr const_iterator find(const K& k) const;constexpr size_type count(const key_type& k) const;template<class K> constexpr size_type count(const K& k) const;constexpr bool contains(const key_type& k) const;template<class K> constexpr bool contains(const K& k) const;constexpr pair<iterator, iterator> equal_range(const key_type& k);constexpr pair<const_iterator, const_iterator> equal_range(const key_type& k) const;template<class K> constexpr pair<iterator, iterator> equal_range(const K& k);template<class K> constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;constexpr size_type bucket_count() const noexcept;constexpr size_type max_bucket_count() const noexcept;constexpr size_type bucket_size(size_type n) const;constexpr size_type bucket(const key_type& k) const;template<class K> constexpr size_type bucket(const K& k) const;constexpr local_iterator begin(size_type n);constexpr const_local_iterator begin(size_type n) const;constexpr local_iterator end(size_type n);constexpr const_local_iterator end(size_type n) const;constexpr const_local_iterator cbegin(size_type n) const;constexpr const_local_iterator cend(size_type n) const;constexpr float load_factor() const noexcept;constexpr float max_load_factor() const noexcept;constexpr void max_load_factor(float z);constexpr void rehash(size_type n);constexpr void reserve(size_type n);};template<class InputIterator,class Hash = hash<_iter-key-type_<InputIterator>>,class Pred = equal_to<_iter-key-type_<InputIterator>>,class Allocator = allocator<_iter-to-alloc-type_<InputIterator>>> unordered_multimap(InputIterator, InputIterator,typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multimap<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, Hash, Pred, Allocator>;template<ranges::input_range R,class Hash = hash<_range-key-type_<R>>,class Pred = equal_to<_range-key-type_<R>>,class Allocator = allocator<_range-to-alloc-type_<R>>> unordered_multimap(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multimap<_range-key-type_<R>, range-mapped-type<R>, Hash, Pred, Allocator>;template<class Key, class T, class Hash = hash<Key>,class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>> unordered_multimap(initializer_list<pair<Key, T>>,typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multimap<Key, T, Hash, Pred, Allocator>;template<class InputIterator, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_multimap<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, hash<_iter-key-type_<InputIterator>>, equal_to<_iter-key-type_<InputIterator>>, Allocator>;template<class InputIterator, class Allocator> unordered_multimap(InputIterator, InputIterator, Allocator) -> unordered_multimap<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, hash<_iter-key-type_<InputIterator>>, equal_to<_iter-key-type_<InputIterator>>, Allocator>;template<class InputIterator, class Hash, class Allocator> unordered_multimap(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_multimap<_iter-key-type_<InputIterator>, iter-mapped-type<InputIterator>, Hash, equal_to<_iter-key-type_<InputIterator>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_multimap<_range-key-type_<R>, range-mapped-type<R>, hash<_range-key-type_<R>>, equal_to<_range-key-type_<R>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_multimap(from_range_t, R&&, Allocator) -> unordered_multimap<_range-key-type_<R>, range-mapped-type<R>, hash<_range-key-type_<R>>, equal_to<_range-key-type_<R>>, Allocator>;template<ranges::input_range R, class Hash, class Allocator> unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_multimap<_range-key-type_<R>, range-mapped-type<R>, Hash, equal_to<_range-key-type_<R>>, Allocator>;template<class Key, class T, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Allocator) -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;template<class Key, class T, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, Allocator) -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>;template<class Key, class T, class Hash, class Allocator> unordered_multimap(initializer_list<pair<Key, T>>, typename see below::size_type, Hash, Allocator) -> unordered_multimap<Key, T, Hash, equal_to<Key>, Allocator>;}

A size_type parameter type in an unordered_multimap deduction guide refers to the size_type member type of the type deduced by the deduction guide.

23.5.4.2 Constructors [unord.multimap.cnstr]

constexpr unordered_multimap() : unordered_multimap(size_type(_see below_)) { } constexpr explicit unordered_multimap(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_multimap using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

For the default constructor, the number of buckets is implementation-defined.

max_load_factor() returns 1.0.

template<class InputIterator> constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<value_type> R> constexpr unordered_multimap(from_range_t, R&& rg, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_multimap(initializer_list<value_type> il, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_multimap using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

If n is not provided, the number of buckets is implementation-defined.

Then inserts elements from the range [f, l), rg, or il, respectively.

max_load_factor() returns 1.0.

Complexity: Average case linear, worst case quadratic.

23.5.4.3 Modifiers [unord.multimap.modifiers]

template<class P> constexpr iterator insert(P&& obj);

Constraints: is_constructible_v<value_type, P&&> is true.

Effects: Equivalent to: return emplace(std::forward<P>(obj));

template<class P> constexpr iterator insert(const_iterator hint, P&& obj);

Constraints: is_constructible_v<value_type, P&&> is true.

Effects: Equivalent to:return emplace_hint(hint, std::forward<P>(obj));

23.5.4.4 Erasure [unord.multimap.erasure]

template<class K, class T, class H, class P, class A, class Predicate> constexpr typename unordered_multimap<K, T, H, P, A>::size_type erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);

Effects: Equivalent to:auto original_size = c.size();for (auto i = c.begin(), last = c.end(); i != last; ) { if (pred(*i)) { i = c.erase(i);} else { ++i;} } return original_size - c.size();

23.5.5 Header <unordered_set> synopsis [unord.set.syn]

23.5.6 Class template unordered_set [unord.set]

23.5.6.1 Overview [unord.set.overview]

An unordered_set is an unordered associative container that supports unique keys (an unordered_set contains at most one of each key value) and in which the elements' keys are the elements themselves.

The unordered_set class supports forward iterators.

It provides the operations described in the preceding requirements table for unique keys; that is, an unordered_set supports the a_uniq operations in that table, not the a_eq operations.

For an unordered_set<Key> the key_typeand the value_type are both Key.

The iterator and const_iterator types are both constant iterator types.

It is unspecified whether they are the same type.

Subclause [unord.set] only describes operations on unordered_set that are not described in one of the requirement tables, or for which there is additional semantic information.

namespace std { template<class Key,class Hash = hash<Key>,class Pred = equal_to<Key>,class Allocator = allocator<Key>> class unordered_set { public: using key_type = Key;using value_type = Key;using hasher = Hash;using key_equal = Pred;using allocator_type = Allocator;using pointer = allocator_traits<Allocator>::pointer;using const_pointer = allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using size_type = implementation-defined; using difference_type = implementation-defined; using iterator = implementation-defined; using const_iterator = implementation-defined; using local_iterator = implementation-defined; using const_local_iterator = implementation-defined; using node_type = unspecified;using insert_return_type = insert-return-type<iterator, node_type>;constexpr unordered_set();constexpr explicit unordered_set(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<container-compatible-range<value_type> R> constexpr unordered_set(from_range_t, R&& rg, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_set(const unordered_set&);constexpr unordered_set(unordered_set&&);constexpr explicit unordered_set(const Allocator&);constexpr unordered_set(const unordered_set&, const type_identity_t<Allocator>&);constexpr unordered_set(unordered_set&&, const type_identity_t<Allocator>&);constexpr unordered_set(initializer_list<value_type> il, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_set(size_type n, const allocator_type& a) : unordered_set(n, hasher(), key_equal(), a) { } constexpr unordered_set(size_type n, const hasher& hf, const allocator_type& a) : unordered_set(n, hf, key_equal(), a) { } template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n,const allocator_type& a) : unordered_set(f, l, n, hasher(), key_equal(), a) { } template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,const allocator_type& a) : unordered_set(f, l, n, hf, key_equal(), a) { } constexpr unordered_set(initializer_list<value_type> il, size_type n,const allocator_type& a) : unordered_set(il, n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf,const allocator_type& a) : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } constexpr unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf,const allocator_type& a) : unordered_set(il, n, hf, key_equal(), a) { } constexpr ~unordered_set();constexpr unordered_set& operator=(const unordered_set&);constexpr unordered_set& operator=(unordered_set&&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);constexpr unordered_set& operator=(initializer_list<value_type>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);template<class... Args> constexpr iterator emplace_hint(const_iterator position, Args&&... args);constexpr pair<iterator, bool> insert(const value_type& obj);constexpr pair<iterator, bool> insert(value_type&& obj);template<class K> constexpr pair<iterator, bool> insert(K&& obj);constexpr iterator insert(const_iterator hint, const value_type& obj);constexpr iterator insert(const_iterator hint, value_type&& obj);template<class K> constexpr iterator insert(const_iterator hint, K&& obj);template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);template<container-compatible-range<value_type> R> constexpr void insert_range(R&& rg);constexpr void insert(initializer_list<value_type>);constexpr node_type extract(const_iterator position);constexpr node_type extract(const key_type& x);template<class K> constexpr node_type extract(K&& x);constexpr insert_return_type insert(node_type&& nh);constexpr iterator insert(const_iterator hint, node_type&& nh);constexpr iterator erase(iterator position) requires ( $same\_as$ <iterator, const_iterator>);constexpr iterator erase(const_iterator position);constexpr size_type erase(const key_type& k);template<class K> constexpr size_type erase(K&& x);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(unordered_set&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);constexpr void clear() noexcept;template<class H2, class P2> constexpr void merge(unordered_set<Key, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_set<Key, H2, P2, Allocator>&& source);template<class H2, class P2> constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);constexpr hasher hash_function() const;constexpr key_equal key_eq() const;constexpr iterator find(const key_type& k);constexpr const_iterator find(const key_type& k) const;template<class K> constexpr iterator find(const K& k);template<class K> constexpr const_iterator find(const K& k) const;constexpr size_type count(const key_type& k) const;template<class K> constexpr size_type count(const K& k) const;constexpr bool contains(const key_type& k) const;template<class K> constexpr bool contains(const K& k) const;constexpr pair<iterator, iterator> equal_range(const key_type& k);constexpr pair<const_iterator, const_iterator> equal_range(const key_type& k) const;template<class K> constexpr pair<iterator, iterator> equal_range(const K& k);template<class K> constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;constexpr size_type bucket_count() const noexcept;constexpr size_type max_bucket_count() const noexcept;constexpr size_type bucket_size(size_type n) const;constexpr size_type bucket(const key_type& k) const;template<class K> constexpr size_type bucket(const K& k) const;constexpr local_iterator begin(size_type n);constexpr const_local_iterator begin(size_type n) const;constexpr local_iterator end(size_type n);constexpr const_local_iterator end(size_type n) const;constexpr const_local_iterator cbegin(size_type n) const;constexpr const_local_iterator cend(size_type n) const;constexpr float load_factor() const noexcept;constexpr float max_load_factor() const noexcept;constexpr void max_load_factor(float z);constexpr void rehash(size_type n);constexpr void reserve(size_type n);};template<class InputIterator,class Hash = hash<_iter-value-type_<InputIterator>>,class Pred = equal_to<_iter-value-type_<InputIterator>>,class Allocator = allocator<_iter-value-type_<InputIterator>>> unordered_set(InputIterator, InputIterator, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<_iter-value-type_<InputIterator>, Hash, Pred, Allocator>;template<ranges::input_range R,class Hash = hash<ranges::range_value_t<R>>,class Pred = equal_to<ranges::range_value_t<R>>,class Allocator = allocator<ranges::range_value_t<R>>> unordered_set(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<ranges::range_value_t<R>, Hash, Pred, Allocator>;template<class T, class Hash = hash<T>,class Pred = equal_to<T>, class Allocator = allocator<T>> unordered_set(initializer_list<T>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<T, Hash, Pred, Allocator>;template<class InputIterator, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_set<_iter-value-type_<InputIterator>, hash<_iter-value-type_<InputIterator>>, equal_to<_iter-value-type_<InputIterator>>, Allocator>;template<class InputIterator, class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_set<_iter-value-type_<InputIterator>, Hash, equal_to<_iter-value-type_<InputIterator>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>, equal_to<ranges::range_value_t<R>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_set(from_range_t, R&&, Allocator) -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>, equal_to<ranges::range_value_t<R>>, Allocator>;template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_set<ranges::range_value_t<R>, Hash, equal_to<ranges::range_value_t<R>>, Allocator>;template<class T, class Allocator> unordered_set(initializer_list<T>, typename see below::size_type, Allocator) -> unordered_set<T, hash<T>, equal_to<T>, Allocator>;template<class T, class Hash, class Allocator> unordered_set(initializer_list<T>, typename see below::size_type, Hash, Allocator) -> unordered_set<T, Hash, equal_to<T>, Allocator>;}

A size_type parameter type in an unordered_set deduction guide refers to the size_type member type of the type deduced by the deduction guide.

23.5.6.2 Constructors [unord.set.cnstr]

constexpr unordered_set() : unordered_set(size_type(_see below_)) { } constexpr explicit unordered_set(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_set using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

For the default constructor, the number of buckets is implementation-defined.

max_load_factor() returns 1.0.

template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<value_type> R> constexpr unordered_multiset(from_range_t, R&& rg, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_set(initializer_list<value_type> il, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_set using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

If n is not provided, the number of buckets is implementation-defined.

Then inserts elements from the range [f, l), rg, or il, respectively.

max_load_factor() returns 1.0.

Complexity: Average case linear, worst case quadratic.

23.5.6.3 Erasure [unord.set.erasure]

template<class K, class H, class P, class A, class Predicate> constexpr typename unordered_set<K, H, P, A>::size_type erase_if(unordered_set<K, H, P, A>& c, Predicate pred);

Effects: Equivalent to:auto original_size = c.size();for (auto i = c.begin(), last = c.end(); i != last; ) { if (pred(*i)) { i = c.erase(i);} else { ++i;} } return original_size - c.size();

23.5.6.4 Modifiers [unord.set.modifiers]

template<class K> constexpr pair<iterator, bool> insert(K&& obj);template<class K> constexpr iterator insert(const_iterator hint, K&& obj);

Constraints: The qualified-ids Hash::is_transparent andPred::is_transparent are valid and denote types.

For the second overload,is_convertible_v<K&&, const_iterator> andis_convertible_v<K&&, iterator> are both false.

Preconditions: value_type is _Cpp17EmplaceConstructible_into unordered_set from std::forward<K>
(obj).

Effects: If the set already contains an element that is equivalent to obj, there is no effect.

Otherwise, let h be hash_function()(obj).

Constructs an object u of type value_typewith std::forward<K>(obj).

If hash_function()(u) != h || contains(u) is true, the behavior is undefined.

Inserts u into *this.

Returns: For the first overload, the bool component of the returned pair is trueif and only if the insertion took place.

The returned iterator points to the set element that is equivalent to obj.

Complexity: Average case constant, worst case linear.

23.5.7 Class template unordered_multiset [unord.multiset]

23.5.7.1 Overview [unord.multiset.overview]

An unordered_multiset is an unordered associative container that supports equivalent keys (an instance of unordered_multiset may contain multiple copies of the same key value) and in which each element's key is the element itself.

The unordered_multiset class supports forward iterators.

It provides the operations described in the preceding requirements table for equivalent keys; that is, an unordered_multisetsupports the a_eq operations in that table, not the a_uniq operations.

For an unordered_multiset<Key> the key_type and the value_type are both Key.

The iterator and const_iterator types are both constant iterator types.

It is unspecified whether they are the same type.

Subclause [unord.multiset] only describes operations on unordered_multiset that are not described in one of the requirement tables, or for which there is additional semantic information.

namespace std { template<class Key,class Hash = hash<Key>,class Pred = equal_to<Key>,class Allocator = allocator<Key>> class unordered_multiset { public: using key_type = Key;using value_type = Key;using hasher = Hash;using key_equal = Pred;using allocator_type = Allocator;using pointer = allocator_traits<Allocator>::pointer;using const_pointer = allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using size_type = implementation-defined; using difference_type = implementation-defined; using iterator = implementation-defined; using const_iterator = implementation-defined; using local_iterator = implementation-defined; using const_local_iterator = implementation-defined; using node_type = unspecified;constexpr unordered_multiset();constexpr explicit unordered_multiset(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<class InputIterator> constexpr unordered_multiset(InputIterator f, InputIterator l, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<container-compatible-range<value_type> R> constexpr unordered_multiset(from_range_t, R&& rg, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_multiset(const unordered_multiset&);constexpr unordered_multiset(unordered_multiset&&);constexpr explicit unordered_multiset(const Allocator&);constexpr unordered_multiset(const unordered_multiset&, const type_identity_t<Allocator>&);constexpr unordered_multiset(unordered_multiset&&, const type_identity_t<Allocator>&);constexpr unordered_multiset(initializer_list<value_type> il, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_multiset(size_type n, const allocator_type& a) : unordered_multiset(n, hasher(), key_equal(), a) { } constexpr unordered_multiset(size_type n, const hasher& hf, const allocator_type& a) : unordered_multiset(n, hf, key_equal(), a) { } template<class InputIterator> constexpr unordered_multiset(InputIterator f, InputIterator l, size_type n,const allocator_type& a) : unordered_multiset(f, l, n, hasher(), key_equal(), a) { } template<class InputIterator> constexpr unordered_multiset(InputIterator f, InputIterator l, size_type n,const hasher& hf, const allocator_type& a) : unordered_multiset(f, l, n, hf, key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_multiset(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,const allocator_type& a) : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } constexpr unordered_multiset(initializer_list<value_type> il, size_type n,const allocator_type& a) : unordered_multiset(il, n, hasher(), key_equal(), a) { } constexpr unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,const allocator_type& a) : unordered_multiset(il, n, hf, key_equal(), a) { } constexpr ~unordered_multiset();constexpr unordered_multiset& operator=(const unordered_multiset&);constexpr unordered_multiset& operator=(unordered_multiset&&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);constexpr unordered_multiset& operator=(initializer_list<value_type>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;template<class... Args> constexpr iterator emplace(Args&&... args);template<class... Args> constexpr iterator emplace_hint(const_iterator position, Args&&... args);constexpr iterator insert(const value_type& obj);constexpr iterator insert(value_type&& obj);constexpr iterator insert(const_iterator hint, const value_type& obj);constexpr iterator insert(const_iterator hint, value_type&& obj);template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);template<container-compatible-range<value_type> R> constexpr void insert_range(R&& rg);constexpr void insert(initializer_list<value_type>);constexpr node_type extract(const_iterator position);constexpr node_type extract(const key_type& x);template<class K> constexpr node_type extract(K&& x);constexpr iterator insert(node_type&& nh);constexpr iterator insert(const_iterator hint, node_type&& nh);constexpr iterator erase(iterator position) requires ( $same\_as$ <iterator, const_iterator>);constexpr iterator erase(const_iterator position);constexpr size_type erase(const key_type& k);template<class K> constexpr size_type erase(K&& x);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(unordered_multiset&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);constexpr void clear() noexcept;template<class H2, class P2> constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);template<class H2, class P2> constexpr void merge(unordered_set<Key, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_set<Key, H2, P2, Allocator>&& source);constexpr hasher hash_function() const;constexpr key_equal key_eq() const;constexpr iterator find(const key_type& k);constexpr const_iterator find(const key_type& k) const;template<class K> constexpr iterator find(const K& k);template<class K> constexpr const_iterator find(const K& k) const;constexpr size_type count(const key_type& k) const;template<class K> constexpr size_type count(const K& k) const;constexpr bool contains(const key_type& k) const;template<class K> constexpr bool contains(const K& k) const;constexpr pair<iterator, iterator> equal_range(const key_type& k);constexpr pair<const_iterator, const_iterator> equal_range(const key_type& k) const;template<class K> constexpr pair<iterator, iterator> equal_range(const K& k);template<class K> constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;constexpr size_type bucket_count() const noexcept;constexpr size_type max_bucket_count() const noexcept;constexpr size_type bucket_size(size_type n) const;constexpr size_type bucket(const key_type& k) const;template<class K> constexpr size_type bucket(const K& k) const;constexpr local_iterator begin(size_type n);constexpr const_local_iterator begin(size_type n) const;constexpr local_iterator end(size_type n);constexpr const_local_iterator end(size_type n) const;constexpr const_local_iterator cbegin(size_type n) const;constexpr const_local_iterator cend(size_type n) const;constexpr float load_factor() const noexcept;constexpr float max_load_factor() const noexcept;constexpr void max_load_factor(float z);constexpr void rehash(size_type n);constexpr void reserve(size_type n);};template<class InputIterator,class Hash = hash<_iter-value-type_<InputIterator>>,class Pred = equal_to<_iter-value-type_<InputIterator>>,class Allocator = allocator<_iter-value-type_<InputIterator>>> unordered_multiset(InputIterator, InputIterator, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multiset<_iter-value-type_<InputIterator>, Hash, Pred, Allocator>;template<ranges::input_range R,class Hash = hash<ranges::range_value_t<R>>,class Pred = equal_to<ranges::range_value_t<R>>,class Allocator = allocator<ranges::range_value_t<R>>> unordered_multiset(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Allocator>;template<class T, class Hash = hash<T>,class Pred = equal_to<T>, class Allocator = allocator<T>> unordered_multiset(initializer_list<T>, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multiset<T, Hash, Pred, Allocator>;template<class InputIterator, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_multiset<_iter-value-type_<InputIterator>, hash<_iter-value-type_<InputIterator>>, equal_to<_iter-value-type_<InputIterator>>, Allocator>;template<class InputIterator, class Hash, class Allocator> unordered_multiset(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_multiset<_iter-value-type_<InputIterator>, Hash, equal_to<_iter-value-type_<InputIterator>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_multiset(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>, equal_to<ranges::range_value_t<R>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_multiset(from_range_t, R&&, Allocator) -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>, equal_to<ranges::range_value_t<R>>, Allocator>;template<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_multiset<ranges::range_value_t<R>, Hash, equal_to<ranges::range_value_t<R>>, Allocator>;template<class T, class Allocator> unordered_multiset(initializer_list<T>, typename see below::size_type, Allocator) -> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>;template<class T, class Hash, class Allocator> unordered_multiset(initializer_list<T>, typename see below::size_type, Hash, Allocator) -> unordered_multiset<T, Hash, equal_to<T>, Allocator>;}

A size_type parameter type in an unordered_multiset deduction guide refers to the size_type member type of the type deduced by the deduction guide.

23.5.7.2 Constructors [unord.multiset.cnstr]

constexpr unordered_multiset() : unordered_multiset(size_type(_see below_)) { } constexpr explicit unordered_multiset(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_multiset using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

For the default constructor, the number of buckets is implementation-defined.

max_load_factor() returns 1.0.

template<class InputIterator> constexpr unordered_multiset(InputIterator f, InputIterator l, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<value_type> R> constexpr unordered_multiset(from_range_t, R&& rg, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_multiset(initializer_list<value_type> il, size_type n = _see below_, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());

Effects: Constructs an empty unordered_multiset using the specified hash function, key equality predicate, and allocator, and using at least n buckets.

If n is not provided, the number of buckets is implementation-defined.

Then inserts elements from the range [f, l), rg, or il, respectively.

max_load_factor() returns 1.0.

Complexity: Average case linear, worst case quadratic.

23.5.7.3 Erasure [unord.multiset.erasure]

template<class K, class H, class P, class A, class Predicate> constexpr typename unordered_multiset<K, H, P, A>::size_type erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);

Effects: Equivalent to:auto original_size = c.size();for (auto i = c.begin(), last = c.end(); i != last; ) { if (pred(*i)) { i = c.erase(i);} else { ++i;} } return original_size - c.size();