depish/cppdraft_translate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
cppdraft_translate/cppdraft/unord/multimap.md
Leonov Artur (Depish) 043225d523 Init
2025-10-25 03:02:53 +03:00

205 lines
20 KiB
Markdown
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

[unord.multimap]
# 23 Containers library [[containers]](./#containers)
## 23.5 Unordered associative containers [[unord]](unord#multimap)
### 23.5.4 Class template unordered_multimap [unord.multimap]
#### [23.5.4.1](#overview) Overview [[unord.multimap.overview]](unord.multimap.overview)
[1](#overview-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14202)
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[.](#overview-1.sentence-1)
The unordered_multimap class
supports forward iterators[.](#overview-1.sentence-2)
[2](#overview-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14212)
An unordered_multimap meets all of the requirements
of a container ([[container.reqmts]](container.reqmts "23.2.2.2 Container requirements")),
of an allocator-aware container ([[container.alloc.reqmts]](container.alloc.reqmts "23.2.2.5 Allocator-aware containers")), and
of an unordered associative container ([[unord.req]](unord.req "23.2.8 Unordered associative containers"))[.](#overview-2.sentence-1)
It provides the operations described in the
preceding requirements table for equivalent keys; that is, an unordered_multimap supports the a_eq operations in that table, not the a_uniq operations[.](#overview-2.sentence-2)
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>[.](#overview-2.sentence-3)
[3](#overview-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14224)
Subclause [unord.multimap] only describes operations on unordered_multimap that are not described in one of the requirement tables, or for which
there is additional semantic information[.](#overview-3.sentence-1)
[4](#overview-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14229)
The types iterator and const_iterator meet
the constexpr iterator requirements ([[iterator.requirements.general]](iterator.requirements.general "24.3.1 General"))[.](#overview-4.sentence-1)
[🔗](#lib:unordered_multimap_)
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:// typesusing 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*; // see [[container.requirements]](container.requirements "23.2 Requirements")using difference_type = *implementation-defined*; // see [[container.requirements]](container.requirements "23.2 Requirements")using iterator = *implementation-defined*; // see [[container.requirements]](container.requirements "23.2 Requirements")using const_iterator = *implementation-defined*; // see [[container.requirements]](container.requirements "23.2 Requirements")using local_iterator = *implementation-defined*; // see [[container.requirements]](container.requirements "23.2 Requirements")using const_local_iterator = *implementation-defined*; // see [[container.requirements]](container.requirements "23.2 Requirements")using node_type = *unspecified*; // [[unord.multimap.cnstr]](#cnstr "23.5.4.2 Constructors"), construct/copy/destroyconstexpr 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*](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(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*](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, const allocator_type& a): unordered_multimap(from_range, std::forward<R>(rg),
n, hasher(), key_equal(), a) { }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, 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; // iteratorsconstexpr 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; // capacityconstexpr bool empty() const noexcept; constexpr size_type size() const noexcept; constexpr size_type max_size() const noexcept; // [[unord.multimap.modifiers]](#modifiers "23.5.4.3 Modifiers"), modifierstemplate<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*](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<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); // observersconstexpr hasher hash_function() const; constexpr key_equal key_eq() const; // map operationsconstexpr 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; // bucket interfaceconstexpr 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; // hash policyconstexpr 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](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") 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](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") 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](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") 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](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") 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>;}
[5](#overview-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14493)
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[.](#overview-5.sentence-1)
#### [23.5.4.2](#cnstr) Constructors [[unord.multimap.cnstr]](unord.multimap.cnstr)
[🔗](#lib:unordered_multimap,constructor)
`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());
`
[1](#cnstr-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14508)
*Effects*: Constructs an empty unordered_multimap using the
specified hash function, key equality predicate, and allocator, and
using at least n buckets[.](#cnstr-1.sentence-1)
For the default constructor,
the number of buckets is implementation-defined[.](#cnstr-1.sentence-2)
max_load_factor() returns 1.0[.](#cnstr-1.sentence-3)
[2](#cnstr-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14517)
*Complexity*: Constant[.](#cnstr-2.sentence-1)
[🔗](#lib:unordered_multimap,constructor_)
`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());
`
[3](#cnstr-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14541)
*Effects*: Constructs an empty unordered_multimap using the
specified hash function, key equality predicate, and allocator, and
using at least n buckets[.](#cnstr-3.sentence-1)
If n is not
provided, the number of buckets is implementation-defined[.](#cnstr-3.sentence-2)
Then
inserts elements from the range [f, l), rg, or il,
respectively[.](#cnstr-3.sentence-3)
max_load_factor() returns 1.0[.](#cnstr-3.sentence-4)
[4](#cnstr-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14552)
*Complexity*: Average case linear, worst case quadratic[.](#cnstr-4.sentence-1)
#### [23.5.4.3](#modifiers) Modifiers [[unord.multimap.modifiers]](unord.multimap.modifiers)
[🔗](#lib:unordered_multimap,insert)
`template<class P>
constexpr iterator insert(P&& obj);
`
[1](#modifiers-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14566)
*Constraints*: is_constructible_v<value_type, P&&> is true[.](#modifiers-1.sentence-1)
[2](#modifiers-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14570)
*Effects*: Equivalent to: return emplace(std​::​forward<P>(obj));
[🔗](#lib:unordered_multimap,insert_)
`template<class P>
constexpr iterator insert(const_iterator hint, P&& obj);
`
[3](#modifiers-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14582)
*Constraints*: is_constructible_v<value_type, P&&> is true[.](#modifiers-3.sentence-1)
[4](#modifiers-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14586)
*Effects*: Equivalent to:return emplace_hint(hint, std​::​forward<P>(obj));
#### [23.5.4.4](#erasure) Erasure [[unord.multimap.erasure]](unord.multimap.erasure)
[🔗](#lib:erase_if,unordered_multimap)
`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);
`
[1](#erasure-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L14602)
*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();
Reference in New Issue View Git Blame Copy Permalink