[unord.multimap.overview] (original) (raw)

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 = typename allocator_traits<Allocator>::pointer;using const_pointer = typename 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.