(1) | ||
iterator erase( iterator pos ); | (since C++11) | |
iterator erase( const_iterator pos ); | (since C++11) | |
(2) | ||
iterator erase( const_iterator first, const_iterator last ); | (since C++11) | |
size_type erase( const Key& key ); | (3) | (since C++11) |
template< class K > size_type erase( K&& x ); | (4) | (since C++23) |
Removes specified elements from the container.
pos
. [first; last)
, which must be a valid range in *this
.key
.x
. This overload participates in overload resolution only if Hash::is_transparent
and KeyEqual::is_transparent
are valid and each denotes a type, and neither iterator
nor const_iterator
is implicitly convertible from K
. This assumes that such Hash
is callable with both K
and Key
type, and that the KeyEqual
is transparent, which, together, allows calling this function without constructing an instance of Key
.References and iterators to the erased elements are invalidated. Other iterators and references are not invalidated.
The iterator pos
must be valid and dereferenceable. Thus the end()
iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos
.
The order of the elements that are not erased is preserved. (This makes it possible to erase individual elements while iterating through the container.).
pos | - | iterator to the element to remove |
first, last | - | range of elements to remove |
key | - | key value of the elements to remove |
x | - | a value of any type that can be transparently compared with a key denoting the elements to remove |
Hash
and KeyEqual
object.Given an instance c
of unordered_multimap
:
c.size()
c.count(key)
, worst case: c.size()
c.count(x)
, worst case: c.size()
Feature-test macro | Comment |
---|---|
__cpp_lib_associative_heterogeneous_erasure | for overload (4) |
#include <unordered_map> #include <iostream> int main() { std::unordered_multimap<int, std::string> c = { {1, "one" }, {2, "two" }, {3, "three"}, {4, "four"}, {5, "five"}, {6, "six" } }; // erase all odd numbers from c for(auto it = c.begin(); it != c.end(); ) { if(it->first % 2 != 0) it = c.erase(it); else ++it; } for(auto& p : c) { std::cout << p.second << ' '; } }
Possible output:
two four six
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 2059 | C++11 | overload for one const_iterator introduced new ambiguity | overload for iterator added |
LWG 2356 | C++11 | the order of element that are not erased was unspecified | required to be preserved |
(C++11) | clears the contents (public member function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/container/unordered_multimap/erase