23 Containers library [containers]

23.4 Associative containers [associative]

23.4.7 Class template multiset [multiset]

23.4.7.1 Overview [multiset.overview]

Amultiset is an associative container that supports equivalent keys (i.e., possibly contains multiple copies of the same key value) and provides for fast retrieval of the keys themselves.

Themultiset class supports bidirectional iterators.

A multiset meets all of the requirements of a container ([container.reqmts]), of a reversible container ([container.rev.reqmts]), of an allocator-aware container ([container.alloc.reqmts]), and of an associative container ([associative.reqmts]).

multiset also provides most operations described in [associative.reqmts] for duplicate keys.

This means that amultiset supports thea_eq operations in [associative.reqmts] but not thea_uniq operations.

For amultiset both thekey_type andvalue_type areKey.

Descriptions are provided here only for operations onmultiset that are not described in one of these tables and for operations where there is additional semantic information.

The types iterator and const_iterator meet the constexpr iterator requirements ([iterator.requirements.general]).

namespace std {template<class Key, class Compare = less, class Allocator = allocator>class multiset {public:// typesusing key_type = Key; using key_compare = Compare; using value_type = Key; using value_compare = Compare; using allocator_type = Allocator; using pointer = typename allocator_traits::pointer; using const_pointer = typename allocator_traits::const_pointer; using reference = value_type&; using const_reference = const value_type&; using size_type = implementation-defined; // see [container.requirements]using difference_type = implementation-defined; // see [container.requirements]using iterator = implementation-defined; // see [container.requirements]using const_iterator = implementation-defined; // see [container.requirements]using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using node_type = unspecified; // [multiset.cons], construct/copy/destroyconstexpr multiset() : multiset(Compare()) { }constexpr explicit multiset(const Compare& comp, const Allocator& = Allocator()); templateconstexpr multiset(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); template<container-compatible-range<value_type> R>constexpr multiset(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); constexpr multiset(const multiset& x); constexpr multiset(multiset&& x); constexpr explicit multiset(const Allocator&); constexpr multiset(const multiset&, const type_identity_t&); constexpr multiset(multiset&&, const type_identity_t&); constexpr multiset(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); templateconstexpr multiset(InputIterator first, InputIterator last, const Allocator& a): multiset(first, last, Compare(), a) { }template<container-compatible-range<value_type> R>constexpr multiset(from_range_t, R&& rg, const Allocator& a)): multiset(from_range, std::forward(rg), Compare(), a) { }constexpr multiset(initializer_list<value_type> il, const Allocator& a): multiset(il, Compare(), a) { }constexpr ~multiset(); constexpr multiset& operator=(const multiset& x); constexpr multiset& operator=(multiset&& x)noexcept(allocator_traits::is_always_equal::value && is_nothrow_move_assignable_v); constexpr multiset& 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 reverse_iterator rbegin() noexcept; constexpr const_reverse_iterator rbegin() const noexcept; constexpr reverse_iterator rend() noexcept; constexpr const_reverse_iterator rend() const noexcept; constexpr const_iterator cbegin() const noexcept; constexpr const_iterator cend() const noexcept; constexpr const_reverse_iterator crbegin() const noexcept; constexpr const_reverse_iterator crend() const noexcept; // capacityconstexpr bool empty() const noexcept; constexpr size_type size() const noexcept; constexpr size_type max_size() const noexcept; // 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& x); constexpr iterator insert(value_type&& x); constexpr iterator insert(const_iterator position, const value_type& x); constexpr iterator insert(const_iterator position, value_type&& x); templateconstexpr 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 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 (<iterator, const_iterator>); constexpr iterator erase(const_iterator position); constexpr size_type erase(const key_type& x); template constexpr size_type erase(K&& x); constexpr iterator erase(const_iterator first, const_iterator last); constexpr void swap(multiset&)noexcept(allocator_traits::is_always_equal::value && is_nothrow_swappable_v); constexpr void clear() noexcept; templateconstexpr void merge(multiset<Key, C2, Allocator>& source); templateconstexpr void merge(multiset<Key, C2, Allocator>&& source); templateconstexpr void merge(set<Key, C2, Allocator>& source); templateconstexpr void merge(set<Key, C2, Allocator>&& source); // observersconstexpr key_compare key_comp() const; constexpr value_compare value_comp() const; // set operationsconstexpr iterator find(const key_type& x); constexpr const_iterator find(const key_type& x) const; template constexpr iterator find(const K& x); template constexpr const_iterator find(const K& x) const; constexpr size_type count(const key_type& x) const; template constexpr size_type count(const K& x) const; constexpr bool contains(const key_type& x) const; template constexpr bool contains(const K& x) const; constexpr iterator lower_bound(const key_type& x); constexpr const_iterator lower_bound(const key_type& x) const; template constexpr iterator lower_bound(const K& x); template constexpr const_iterator lower_bound(const K& x) const; constexpr iterator upper_bound(const key_type& x); constexpr const_iterator upper_bound(const key_type& x) const; template constexpr iterator upper_bound(const K& x); template constexpr const_iterator upper_bound(const K& x) const; constexpr pair<iterator, iterator> equal_range(const key_type& x); constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const; templateconstexpr pair<iterator, iterator> equal_range(const K& x); templateconstexpr pair<const_iterator, const_iterator> equal_range(const K& x) const; }; template<class InputIterator, class Compare = less<iter-value-type>, class Allocator = allocator<iter-value-type>> multiset(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())-> multiset<iter-value-type, Compare, Allocator>; template<ranges::input_range R, class Compare = less<ranges::range_value_t>, class Allocator = allocator<ranges::range_value_t>> multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())-> multiset<ranges::range_value_t, Compare, Allocator>; template<class Key, class Compare = less, class Allocator = allocator> multiset(initializer_list, Compare = Compare(), Allocator = Allocator())-> multiset<Key, Compare, Allocator>; template<class InputIterator, class Allocator> multiset(InputIterator, InputIterator, Allocator)-> multiset<iter-value-type, less<iter-value-type>, Allocator>; template<ranges::input_range R, class Allocator> multiset(from_range_t, R&&, Allocator)-> multiset<ranges::range_value_t, less<ranges::range_value_t>, Allocator>; template<class Key, class Allocator> multiset(initializer_list, Allocator) -> multiset<Key, less, Allocator>;}

23.4.7.2 Constructors [multiset.cons]

constexpr explicit multiset(const Compare& comp, const Allocator& = Allocator());

Effects: Constructs an empty multiset using the specified comparison object and allocator.

Complexity: Constant.

template<class InputIterator> constexpr multiset(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator());

Effects: Constructs an emptymultiset using the specified comparison object and allocator, and inserts elements from the range [first, last).

Complexity: Linear in N if the range [first, last) is already sorted with respect to comp and otherwise NlogN, where N islast - first.

template<[container-compatible-range](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<value_type> R> constexpr multiset(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());

Effects: Constructs an empty multiset using the specified comparison object and allocator, and inserts elements from the range rg.

Complexity: Linear in N if rg is already sorted with respect to comp and otherwise NlogN, where N is ranges::distance(rg).

23.4.7.3 Erasure [multiset.erasure]

template<class Key, class Compare, class Allocator, class Predicate> constexpr typename multiset<Key, Compare, Allocator>::size_type erase_if(multiset<Key, Compare, Allocator>& 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();

13 KiB Raw Permalink Blame History Unescape Escape