From Jason Turner

[unord.multimap]

C++23 → Trunk 19.3 KB 240 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game
C++ Weekly: Ep 193

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpbzb6_n3y/{from.md → to.md} +114 -117
tmp/tmpbzb6_n3y/{from.md → to.md} RENAMED
@@ -19,10 +19,13 @@ the `mapped_type` is `T`, and the `value_type` is `pair<const Key, T>`.
19
 
20
  Subclause  [[unord.multimap]] only describes operations on
21
  `unordered_multimap` that are not described in one of the requirement
22
  tables, or for which there is additional semantic information.
23
 
 
 
 
24
  ``` cpp
25
  namespace std {
26
  template<class Key,
27
  class T,
28
  class Hash = hash<Key>,
@@ -35,12 +38,12 @@ namespace std {
35
  using mapped_type = T;
36
  using value_type = pair<const Key, T>;
37
  using hasher = Hash;
38
  using key_equal = Pred;
39
  using allocator_type = Allocator;
40
- using pointer = typename allocator_traits<Allocator>::pointer;
41
- using const_pointer = typename allocator_traits<Allocator>::const_pointer;
42
  using reference = value_type&;
43
  using const_reference = const value_type&;
44
  using size_type = implementation-defined // type of unordered_multimap::size_type; // see [container.requirements]
45
  using difference_type = implementation-defined // type of unordered_multimap::difference_type; // see [container.requirements]
46
 
@@ -49,165 +52,163 @@ namespace std {
49
  using local_iterator = implementation-defined // type of unordered_multimap::local_iterator; // see [container.requirements]
50
  using const_local_iterator = implementation-defined // type of unordered_multimap::const_local_iterator; // see [container.requirements]
51
  using node_type = unspecified;
52
 
53
  // [unord.multimap.cnstr], construct/copy/destroy
54
- unordered_multimap();
55
- explicit unordered_multimap(size_type n,
56
- const hasher& hf = hasher(),
57
  const key_equal& eql = key_equal(),
58
  const allocator_type& a = allocator_type());
59
  template<class InputIterator>
60
- unordered_multimap(InputIterator f, InputIterator l,
61
- size_type n = see below,
62
- const hasher& hf = hasher(),
63
  const key_equal& eql = key_equal(),
64
  const allocator_type& a = allocator_type());
65
  template<container-compatible-range<value_type> R>
66
- unordered_multimap(from_range_t, R&& rg,
67
- size_type n = see below,
68
- const hasher& hf = hasher(),
69
  const key_equal& eql = key_equal(),
70
  const allocator_type& a = allocator_type());
71
- unordered_multimap(const unordered_multimap&);
72
- unordered_multimap(unordered_multimap&&);
73
- explicit unordered_multimap(const Allocator&);
74
- unordered_multimap(const unordered_multimap&, const type_identity_t<Allocator>&);
75
- unordered_multimap(unordered_multimap&&, const type_identity_t<Allocator>&);
76
- unordered_multimap(initializer_list<value_type> il,
77
- size_type n = see below,
78
- const hasher& hf = hasher(),
79
  const key_equal& eql = key_equal(),
80
  const allocator_type& a = allocator_type());
81
- unordered_multimap(size_type n, const allocator_type& a)
82
  : unordered_multimap(n, hasher(), key_equal(), a) { }
83
- unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
84
  : unordered_multimap(n, hf, key_equal(), a) { }
85
  template<class InputIterator>
86
- unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
 
87
  : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
88
  template<class InputIterator>
89
- unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
90
- const allocator_type& a)
91
  : unordered_multimap(f, l, n, hf, key_equal(), a) { }
92
  template<container-compatible-range<value_type> R>
93
- unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
94
  : unordered_multimap(from_range, std::forward<R>(rg),
95
  n, hasher(), key_equal(), a) { }
96
  template<container-compatible-range<value_type> R>
97
- unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,
98
  const allocator_type& a)
99
  : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
100
- unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
 
101
  : unordered_multimap(il, n, hasher(), key_equal(), a) { }
102
- unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
103
  const allocator_type& a)
104
  : unordered_multimap(il, n, hf, key_equal(), a) { }
105
- ~unordered_multimap();
106
- unordered_multimap& operator=(const unordered_multimap&);
107
- unordered_multimap& operator=(unordered_multimap&&)
108
  noexcept(allocator_traits<Allocator>::is_always_equal::value &&
109
- is_nothrow_move_assignable_v<Hash> &&
110
- is_nothrow_move_assignable_v<Pred>);
111
- unordered_multimap& operator=(initializer_list<value_type>);
112
- allocator_type get_allocator() const noexcept;
113
 
114
  // iterators
115
- iterator begin() noexcept;
116
- const_iterator begin() const noexcept;
117
- iterator end() noexcept;
118
- const_iterator end() const noexcept;
119
- const_iterator cbegin() const noexcept;
120
- const_iterator cend() const noexcept;
121
 
122
  // capacity
123
- [[nodiscard]] bool empty() const noexcept;
124
- size_type size() const noexcept;
125
- size_type max_size() const noexcept;
126
 
127
  // [unord.multimap.modifiers], modifiers
128
- template<class... Args> iterator emplace(Args&&... args);
129
- template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
130
- iterator insert(const value_type& obj);
131
- iterator insert(value_type&& obj);
132
- template<class P> iterator insert(P&& obj);
133
- iterator insert(const_iterator hint, const value_type& obj);
134
- iterator insert(const_iterator hint, value_type&& obj);
135
- template<class P> iterator insert(const_iterator hint, P&& obj);
136
- template<class InputIterator> void insert(InputIterator first, InputIterator last);
 
137
  template<container-compatible-range<value_type> R>
138
- void insert_range(R&& rg);
139
- void insert(initializer_list<value_type>);
140
 
141
- node_type extract(const_iterator position);
142
- node_type extract(const key_type& x);
143
- template<class K> node_type extract(K&& x);
144
- iterator insert(node_type&& nh);
145
- iterator insert(const_iterator hint, node_type&& nh);
146
 
147
- iterator erase(iterator position);
148
- iterator erase(const_iterator position);
149
- size_type erase(const key_type& k);
150
- template<class K> size_type erase(K&& x);
151
- iterator erase(const_iterator first, const_iterator last);
152
- void swap(unordered_multimap&)
153
  noexcept(allocator_traits<Allocator>::is_always_equal::value &&
154
- is_nothrow_swappable_v<Hash> &&
155
- is_nothrow_swappable_v<Pred>);
156
- void clear() noexcept;
157
 
158
  template<class H2, class P2>
159
- void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
160
  template<class H2, class P2>
161
- void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
162
  template<class H2, class P2>
163
- void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
164
  template<class H2, class P2>
165
- void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
166
 
167
  // observers
168
- hasher hash_function() const;
169
- key_equal key_eq() const;
170
 
171
  // map operations
172
- iterator find(const key_type& k);
173
- const_iterator find(const key_type& k) const;
174
  template<class K>
175
- iterator find(const K& k);
176
  template<class K>
177
- const_iterator find(const K& k) const;
178
- size_type count(const key_type& k) const;
179
  template<class K>
180
- size_type count(const K& k) const;
181
- bool contains(const key_type& k) const;
182
  template<class K>
183
- bool contains(const K& k) const;
184
- pair<iterator, iterator> equal_range(const key_type& k);
185
- pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
186
  template<class K>
187
- pair<iterator, iterator> equal_range(const K& k);
188
  template<class K>
189
- pair<const_iterator, const_iterator> equal_range(const K& k) const;
190
 
191
  // bucket interface
192
- size_type bucket_count() const noexcept;
193
- size_type max_bucket_count() const noexcept;
194
- size_type bucket_size(size_type n) const;
195
- size_type bucket(const key_type& k) const;
196
- local_iterator begin(size_type n);
197
- const_local_iterator begin(size_type n) const;
198
- local_iterator end(size_type n);
199
- const_local_iterator end(size_type n) const;
200
- const_local_iterator cbegin(size_type n) const;
201
- const_local_iterator cend(size_type n) const;
 
202
 
203
  // hash policy
204
- float load_factor() const noexcept;
205
- float max_load_factor() const noexcept;
206
- void max_load_factor(float z);
207
- void rehash(size_type n);
208
- void reserve(size_type n);
209
  };
210
 
211
  template<class InputIterator,
212
  class Hash = hash<iter-key-type<InputIterator>>,
213
  class Pred = equal_to<iter-key-type<InputIterator>>,
@@ -287,13 +288,12 @@ refers to the `size_type` member type of the type deduced by the
287
  deduction guide.
288
 
289
  #### Constructors <a id="unord.multimap.cnstr">[[unord.multimap.cnstr]]</a>
290
 
291
  ``` cpp
292
- unordered_multimap() : unordered_multimap(size_type(see below)) { }
293
- explicit unordered_multimap(size_type n,
294
- const hasher& hf = hasher(),
295
  const key_equal& eql = key_equal(),
296
  const allocator_type& a = allocator_type());
297
  ```
298
 
299
  *Effects:* Constructs an empty `unordered_multimap` using the specified
@@ -303,24 +303,21 @@ hash function, key equality predicate, and allocator, and using at least
303
 
304
  *Complexity:* Constant.
305
 
306
  ``` cpp
307
  template<class InputIterator>
308
- unordered_multimap(InputIterator f, InputIterator l,
309
- size_type n = see below,
310
- const hasher& hf = hasher(),
311
  const key_equal& eql = key_equal(),
312
  const allocator_type& a = allocator_type());
313
  template<container-compatible-range<value_type> R>
314
- unordered_multimap(from_range_t, R&& rg,
315
- size_type n = see below,
316
- const hasher& hf = hasher(),
317
  const key_equal& eql = key_equal(),
318
  const allocator_type& a = allocator_type());
319
- unordered_multimap(initializer_list<value_type> il,
320
- size_type n = see below,
321
- const hasher& hf = hasher(),
322
  const key_equal& eql = key_equal(),
323
  const allocator_type& a = allocator_type());
324
  ```
325
 
326
  *Effects:* Constructs an empty `unordered_multimap` using the specified
@@ -333,20 +330,20 @@ hash function, key equality predicate, and allocator, and using at least
333
 
334
  #### Modifiers <a id="unord.multimap.modifiers">[[unord.multimap.modifiers]]</a>
335
 
336
  ``` cpp
337
  template<class P>
338
- iterator insert(P&& obj);
339
  ```
340
 
341
  *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
342
 
343
  *Effects:* Equivalent to: `return emplace(std::forward<P>(obj));`
344
 
345
  ``` cpp
346
  template<class P>
347
- iterator insert(const_iterator hint, P&& obj);
348
  ```
349
 
350
  *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
351
 
352
  *Effects:* Equivalent to:
@@ -354,11 +351,11 @@ template<class P>
354
 
355
  #### Erasure <a id="unord.multimap.erasure">[[unord.multimap.erasure]]</a>
356
 
357
  ``` cpp
358
  template<class K, class T, class H, class P, class A, class Predicate>
359
- typename unordered_multimap<K, T, H, P, A>::size_type
360
  erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
361
  ```
362
 
363
  *Effects:* Equivalent to:
364
 
 
19
 
20
  Subclause  [[unord.multimap]] only describes operations on
21
  `unordered_multimap` that are not described in one of the requirement
22
  tables, or for which there is additional semantic information.
23
 
24
+ The types `iterator` and `const_iterator` meet the constexpr iterator
25
+ requirements [[iterator.requirements.general]].
26
+
27
  ``` cpp
28
  namespace std {
29
  template<class Key,
30
  class T,
31
  class Hash = hash<Key>,
 
38
  using mapped_type = T;
39
  using value_type = pair<const Key, T>;
40
  using hasher = Hash;
41
  using key_equal = Pred;
42
  using allocator_type = Allocator;
43
+ using pointer = allocator_traits<Allocator>::pointer;
44
+ using const_pointer = allocator_traits<Allocator>::const_pointer;
45
  using reference = value_type&;
46
  using const_reference = const value_type&;
47
  using size_type = implementation-defined // type of unordered_multimap::size_type; // see [container.requirements]
48
  using difference_type = implementation-defined // type of unordered_multimap::difference_type; // see [container.requirements]
49
 
 
52
  using local_iterator = implementation-defined // type of unordered_multimap::local_iterator; // see [container.requirements]
53
  using const_local_iterator = implementation-defined // type of unordered_multimap::const_local_iterator; // see [container.requirements]
54
  using node_type = unspecified;
55
 
56
  // [unord.multimap.cnstr], construct/copy/destroy
57
+ constexpr unordered_multimap();
58
+ constexpr explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
 
59
  const key_equal& eql = key_equal(),
60
  const allocator_type& a = allocator_type());
61
  template<class InputIterator>
62
+ constexpr unordered_multimap(InputIterator f, InputIterator l,
63
+ size_type n = see below, const hasher& hf = hasher(),
 
64
  const key_equal& eql = key_equal(),
65
  const allocator_type& a = allocator_type());
66
  template<container-compatible-range<value_type> R>
67
+ constexpr unordered_multimap(from_range_t, R&& rg,
68
+ size_type n = see below, const hasher& hf = hasher(),
 
69
  const key_equal& eql = key_equal(),
70
  const allocator_type& a = allocator_type());
71
+ constexpr unordered_multimap(const unordered_multimap&);
72
+ constexpr unordered_multimap(unordered_multimap&&);
73
+ constexpr explicit unordered_multimap(const Allocator&);
74
+ constexpr unordered_multimap(const unordered_multimap&, const type_identity_t<Allocator>&);
75
+ constexpr unordered_multimap(unordered_multimap&&, const type_identity_t<Allocator>&);
76
+ constexpr unordered_multimap(initializer_list<value_type> il,
77
+ size_type n = see below, const hasher& hf = hasher(),
 
78
  const key_equal& eql = key_equal(),
79
  const allocator_type& a = allocator_type());
80
+ constexpr unordered_multimap(size_type n, const allocator_type& a)
81
  : unordered_multimap(n, hasher(), key_equal(), a) { }
82
+ constexpr unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
83
  : unordered_multimap(n, hf, key_equal(), a) { }
84
  template<class InputIterator>
85
+ constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n,
86
+ const allocator_type& a)
87
  : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
88
  template<class InputIterator>
89
+ constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n,
90
+ const hasher& hf, const allocator_type& a)
91
  : unordered_multimap(f, l, n, hf, key_equal(), a) { }
92
  template<container-compatible-range<value_type> R>
93
+ constexpr unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
94
  : unordered_multimap(from_range, std::forward<R>(rg),
95
  n, hasher(), key_equal(), a) { }
96
  template<container-compatible-range<value_type> R>
97
+ constexpr unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,
98
  const allocator_type& a)
99
  : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
100
+ constexpr unordered_multimap(initializer_list<value_type> il, size_type n,
101
+ const allocator_type& a)
102
  : unordered_multimap(il, n, hasher(), key_equal(), a) { }
103
+ constexpr unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
104
  const allocator_type& a)
105
  : unordered_multimap(il, n, hf, key_equal(), a) { }
106
+ constexpr ~unordered_multimap();
107
+ constexpr unordered_multimap& operator=(const unordered_multimap&);
108
+ constexpr unordered_multimap& operator=(unordered_multimap&&)
109
  noexcept(allocator_traits<Allocator>::is_always_equal::value &&
110
+ is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);
111
+ constexpr unordered_multimap& operator=(initializer_list<value_type>);
112
+ constexpr allocator_type get_allocator() const noexcept;
 
113
 
114
  // iterators
115
+ constexpr iterator begin() noexcept;
116
+ constexpr const_iterator begin() const noexcept;
117
+ constexpr iterator end() noexcept;
118
+ constexpr const_iterator end() const noexcept;
119
+ constexpr const_iterator cbegin() const noexcept;
120
+ constexpr const_iterator cend() const noexcept;
121
 
122
  // capacity
123
+ constexpr bool empty() const noexcept;
124
+ constexpr size_type size() const noexcept;
125
+ constexpr size_type max_size() const noexcept;
126
 
127
  // [unord.multimap.modifiers], modifiers
128
+ template<class... Args> constexpr iterator emplace(Args&&... args);
129
+ template<class... Args>
130
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
131
+ constexpr iterator insert(const value_type& obj);
132
+ constexpr iterator insert(value_type&& obj);
133
+ template<class P> constexpr iterator insert(P&& obj);
134
+ constexpr iterator insert(const_iterator hint, const value_type& obj);
135
+ constexpr iterator insert(const_iterator hint, value_type&& obj);
136
+ template<class P> constexpr iterator insert(const_iterator hint, P&& obj);
137
+ template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);
138
  template<container-compatible-range<value_type> R>
139
+ constexpr void insert_range(R&& rg);
140
+ constexpr void insert(initializer_list<value_type>);
141
 
142
+ constexpr node_type extract(const_iterator position);
143
+ constexpr node_type extract(const key_type& x);
144
+ template<class K> constexpr node_type extract(K&& x);
145
+ constexpr iterator insert(node_type&& nh);
146
+ constexpr iterator insert(const_iterator hint, node_type&& nh);
147
 
148
+ constexpr iterator erase(iterator position);
149
+ constexpr iterator erase(const_iterator position);
150
+ constexpr size_type erase(const key_type& k);
151
+ template<class K> constexpr size_type erase(K&& x);
152
+ constexpr iterator erase(const_iterator first, const_iterator last);
153
+ constexpr void swap(unordered_multimap&)
154
  noexcept(allocator_traits<Allocator>::is_always_equal::value &&
155
+ is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);
156
+ constexpr void clear() noexcept;
 
157
 
158
  template<class H2, class P2>
159
+ constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
160
  template<class H2, class P2>
161
+ constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
162
  template<class H2, class P2>
163
+ constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
164
  template<class H2, class P2>
165
+ constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
166
 
167
  // observers
168
+ constexpr hasher hash_function() const;
169
+ constexpr key_equal key_eq() const;
170
 
171
  // map operations
172
+ constexpr iterator find(const key_type& k);
173
+ constexpr const_iterator find(const key_type& k) const;
174
  template<class K>
175
+ constexpr iterator find(const K& k);
176
  template<class K>
177
+ constexpr const_iterator find(const K& k) const;
178
+ constexpr size_type count(const key_type& k) const;
179
  template<class K>
180
+ constexpr size_type count(const K& k) const;
181
+ constexpr bool contains(const key_type& k) const;
182
  template<class K>
183
+ constexpr bool contains(const K& k) const;
184
+ constexpr pair<iterator, iterator> equal_range(const key_type& k);
185
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
186
  template<class K>
187
+ constexpr pair<iterator, iterator> equal_range(const K& k);
188
  template<class K>
189
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;
190
 
191
  // bucket interface
192
+ constexpr size_type bucket_count() const noexcept;
193
+ constexpr size_type max_bucket_count() const noexcept;
194
+ constexpr size_type bucket_size(size_type n) const;
195
+ constexpr size_type bucket(const key_type& k) const;
196
+ template<class K> constexpr size_type bucket(const K& k) const;
197
+ constexpr local_iterator begin(size_type n);
198
+ constexpr const_local_iterator begin(size_type n) const;
199
+ constexpr local_iterator end(size_type n);
200
+ constexpr const_local_iterator end(size_type n) const;
201
+ constexpr const_local_iterator cbegin(size_type n) const;
202
+ constexpr const_local_iterator cend(size_type n) const;
203
 
204
  // hash policy
205
+ constexpr float load_factor() const noexcept;
206
+ constexpr float max_load_factor() const noexcept;
207
+ constexpr void max_load_factor(float z);
208
+ constexpr void rehash(size_type n);
209
+ constexpr void reserve(size_type n);
210
  };
211
 
212
  template<class InputIterator,
213
  class Hash = hash<iter-key-type<InputIterator>>,
214
  class Pred = equal_to<iter-key-type<InputIterator>>,
 
288
  deduction guide.
289
 
290
  #### Constructors <a id="unord.multimap.cnstr">[[unord.multimap.cnstr]]</a>
291
 
292
  ``` cpp
293
+ constexpr unordered_multimap() : unordered_multimap(size_type(see below)) { }
294
+ constexpr explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
 
295
  const key_equal& eql = key_equal(),
296
  const allocator_type& a = allocator_type());
297
  ```
298
 
299
  *Effects:* Constructs an empty `unordered_multimap` using the specified
 
303
 
304
  *Complexity:* Constant.
305
 
306
  ``` cpp
307
  template<class InputIterator>
308
+ constexpr unordered_multimap(InputIterator f, InputIterator l,
309
+ size_type n = see below, const hasher& hf = hasher(),
 
310
  const key_equal& eql = key_equal(),
311
  const allocator_type& a = allocator_type());
312
  template<container-compatible-range<value_type> R>
313
+ constexpr unordered_multimap(from_range_t, R&& rg,
314
+ size_type n = see below, const hasher& hf = hasher(),
 
315
  const key_equal& eql = key_equal(),
316
  const allocator_type& a = allocator_type());
317
+ constexpr unordered_multimap(initializer_list<value_type> il,
318
+ size_type n = see below, const hasher& hf = hasher(),
 
319
  const key_equal& eql = key_equal(),
320
  const allocator_type& a = allocator_type());
321
  ```
322
 
323
  *Effects:* Constructs an empty `unordered_multimap` using the specified
 
330
 
331
  #### Modifiers <a id="unord.multimap.modifiers">[[unord.multimap.modifiers]]</a>
332
 
333
  ``` cpp
334
  template<class P>
335
+ constexpr iterator insert(P&& obj);
336
  ```
337
 
338
  *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
339
 
340
  *Effects:* Equivalent to: `return emplace(std::forward<P>(obj));`
341
 
342
  ``` cpp
343
  template<class P>
344
+ constexpr iterator insert(const_iterator hint, P&& obj);
345
  ```
346
 
347
  *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
348
 
349
  *Effects:* Equivalent to:
 
351
 
352
  #### Erasure <a id="unord.multimap.erasure">[[unord.multimap.erasure]]</a>
353
 
354
  ``` cpp
355
  template<class K, class T, class H, class P, class A, class Predicate>
356
+ constexpr typename unordered_multimap<K, T, H, P, A>::size_type
357
  erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
358
  ```
359
 
360
  *Effects:* Equivalent to:
361