23 Containers library [containers]

23.4 Associative containers [associative]

23.4.6 Class template set [set]

23.4.6.1 Overview [set.overview]

Aset is an associative container that supports unique keys (i.e., contains at most one of each key value) and provides for fast retrieval of the keys themselves.

Theset class supports bidirectional iterators.

A set 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]).

Aset also provides most operations described in [associative.reqmts] for unique keys.

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

For aset both thekey_type andvalue_type areKey.

Descriptions are provided here only for operations onset 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 set {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; using insert_return_type = insert-return-type<iterator, node_type>; // [set.cons], construct/copy/destroyconstexpr set() : set(Compare()) { }constexpr explicit set(const Compare& comp, const Allocator& = Allocator()); templateconstexpr set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); template<container-compatible-range<value_type> R>constexpr set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); constexpr set(const set& x); constexpr set(set&& x); constexpr explicit set(const Allocator&); constexpr set(const set&, const type_identity_t&); constexpr set(set&&, const type_identity_t&); constexpr set(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); templateconstexpr set(InputIterator first, InputIterator last, const Allocator& a): set(first, last, Compare(), a) { }template<container-compatible-range<value_type> R>constexpr set(from_range_t, R&& rg, const Allocator& a)): set(from_range, std::forward(rg), Compare(), a) { }constexpr set(initializer_list<value_type> il, const Allocator& a): set(il, Compare(), a) { }constexpr ~set(); constexpr set& operator=(const set& x); constexpr set& operator=(set&& x)noexcept(allocator_traits::is_always_equal::value && is_nothrow_move_assignable_v); constexpr set& 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; // [set.modifiers], modifierstemplate<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args); template<class... Args>constexpr iterator emplace_hint(const_iterator position, Args&&... args); constexpr pair<iterator,bool> insert(const value_type& x); constexpr pair<iterator,bool> insert(value_type&& x); template constexpr pair<iterator, bool> insert(K&& x); constexpr iterator insert(const_iterator position, const value_type& x); constexpr iterator insert(const_iterator position, value_type&& x); template constexpr iterator insert(const_iterator position, K&& 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 insert_return_type 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(set&)noexcept(allocator_traits::is_always_equal::value && is_nothrow_swappable_v); constexpr void clear() noexcept; templateconstexpr void merge(set<Key, C2, Allocator>& source); templateconstexpr void merge(set<Key, C2, Allocator>&& source); templateconstexpr void merge(multiset<Key, C2, Allocator>& source); templateconstexpr void merge(multiset<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>> set(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())-> set<iter-value-type, Compare, Allocator>; template<ranges::input_range R, class Compare = less<ranges::range_value_t>, class Allocator = allocator<ranges::range_value_t>> set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())-> set<ranges::range_value_t, Compare, Allocator>; template<class Key, class Compare = less, class Allocator = allocator> set(initializer_list, Compare = Compare(), Allocator = Allocator())-> set<Key, Compare, Allocator>; template<class InputIterator, class Allocator> set(InputIterator, InputIterator, Allocator)-> set<iter-value-type, less<iter-value-type>, Allocator>; template<ranges::input_range R, class Allocator> set(from_range_t, R&&, Allocator)-> set<ranges::range_value_t, less<ranges::range_value_t>, Allocator>; template<class Key, class Allocator> set(initializer_list, Allocator) -> set<Key, less, Allocator>;}

23.4.6.2 Constructors, copy, and assignment [set.cons]

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

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

Complexity: Constant.

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

Effects: Constructs an emptyset 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 set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());

Effects: Constructs an empty set 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.6.3 Erasure [set.erasure]

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

23.4.6.4 Modifiers [set.modifiers]

template<class K> constexpr pair<iterator, bool> insert(K&& x); template<class K> constexpr iterator insert(const_iterator hint, K&& x);

Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.

For the second overload,is_convertible_v<K&&, const_iterator> andis_convertible_v<K&&, iterator> are both false.

Preconditions: value_type is Cpp17EmplaceConstructible into set fromstd::forward(x).

Effects: If the set already contains an element that is equivalent to x, there is no effect.

Otherwise, let r be equal_range(x).

Constructs an object u of type value_type with std::forward(x).

If equal_range(u) == r is false, the behavior is undefined.

Inserts u into *this.

Returns: For the first overload, the bool component of the returned pair is true if and only if the insertion took place.

The returned iterator points to the set element that is equivalent to x.

Complexity: Logarithmic.

15 KiB Raw Permalink Blame History Unescape Escape