[set]

# 23 Containers library [[containers]](./#containers)

## 23.4 Associative containers [[associative]](associative#set)

### 23.4.6 Class template set [set]

#### [23.4.6.1](#overview) Overview [[set.overview]](set.overview)

[1](#overview-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12627)

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[.](#overview-1.sentence-1)

Theset class
supports bidirectional iterators[.](#overview-1.sentence-2)

[2](#overview-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12637)

A set meets all of the requirements
of a container ([[container.reqmts]](container.reqmts "23.2.2.2 Container requirements")),
of a reversible container ([[container.rev.reqmts]](container.rev.reqmts "23.2.2.3 Reversible container requirements")),
of an allocator-aware container ([[container.alloc.reqmts]](container.alloc.reqmts "23.2.2.5 Allocator-aware containers")), and
of an associative container ([[associative.reqmts]](associative.reqmts "23.2.7 Associative containers"))[.](#overview-2.sentence-1)

Aset also provides most operations described in [[associative.reqmts]](associative.reqmts "23.2.7 Associative containers") for unique keys[.](#overview-2.sentence-2)

This means that aset supports thea_uniq operations in [[associative.reqmts]](associative.reqmts "23.2.7 Associative containers") but not thea_eq operations[.](#overview-2.sentence-3)

For aset<Key> both thekey_type andvalue_type areKey[.](#overview-2.sentence-4)

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[.](#overview-2.sentence-5)

[3](#overview-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12668)

The types iterator and const_iterator meet
the constexpr iterator requirements ([[iterator.requirements.general]](iterator.requirements.general "24.3.1 General"))[.](#overview-3.sentence-1)

namespace std {template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>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<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 reverse_iterator = std::reverse_iterator<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]](#cons "23.4.6.2 Constructors, copy, and assignment"), construct/copy/destroyconstexpr set() : set(Compare()) { }constexpr explicit set(const Compare& comp, const Allocator& = Allocator()); template<class InputIterator>constexpr set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); 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()); constexpr set(const set& x); constexpr set(set&& x); constexpr explicit set(const Allocator&); constexpr set(const set&, const type_identity_t<Allocator>&); constexpr set(set&&, const type_identity_t<Allocator>&); constexpr set(initializer_list<value_type>, const Compare& = Compare(), const Allocator& = Allocator()); template<class InputIterator>constexpr set(InputIterator first, InputIterator last, const Allocator& a): set(first, last, Compare(), a) { }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 Allocator& a)): set(from_range, std::forward<R>(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<Allocator>::is_always_equal::value && is_nothrow_move_assignable_v<Compare>); 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]](#modifiers "23.4.6.4 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<class K> 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<class K> constexpr iterator insert(const_iterator position, K&& x); 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 insert_return_type insert(node_type&& nh); constexpr iterator insert(const_iterator hint, node_type&& nh); constexpr iterator erase(iterator position)requires (![same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<iterator, const_iterator>); constexpr iterator erase(const_iterator position); constexpr size_type erase(const key_type& x); template<class K> constexpr size_type erase(K&& x); constexpr iterator erase(const_iterator first, const_iterator last); constexpr void swap(set&)noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Compare>); constexpr void clear() noexcept; template<class C2>constexpr void merge(set<Key, C2, Allocator>& source); template<class C2>constexpr void merge(set<Key, C2, Allocator>&& source); template<class C2>constexpr void merge(multiset<Key, C2, Allocator>& source); template<class C2>constexpr 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<class K> constexpr iterator find(const K& x); template<class K> constexpr const_iterator find(const K& x) const; constexpr size_type count(const key_type& x) const; template<class K> constexpr size_type count(const K& x) const; constexpr bool contains(const key_type& x) const; template<class K> 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<class K> constexpr iterator lower_bound(const K& x); template<class K> 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<class K> constexpr iterator upper_bound(const K& x); template<class K> 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; template<class K>constexpr pair<iterator, iterator> equal_range(const K& x); template<class K>constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const; }; template<class InputIterator, class Compare = less<*iter-value-type*<InputIterator>>, class Allocator = allocator<*iter-value-type*<InputIterator>>> set(InputIterator, InputIterator,
 Compare = Compare(), Allocator = Allocator())-> set<*iter-value-type*<InputIterator>, Compare, Allocator>; template<ranges::[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") R, class Compare = less<ranges::range_value_t<R>>, class Allocator = allocator<ranges::range_value_t<R>>> set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())-> set<ranges::range_value_t<R>, Compare, Allocator>; template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>> set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())-> set<Key, Compare, Allocator>; template<class InputIterator, class Allocator> set(InputIterator, InputIterator, Allocator)-> set<*iter-value-type*<InputIterator>,
 less<*iter-value-type*<InputIterator>>, Allocator>; template<ranges::[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") R, class Allocator> set(from_range_t, R&&, Allocator)-> set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>; template<class Key, class Allocator> set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>;}

#### [23.4.6.2](#cons) Constructors, copy, and assignment [[set.cons]](set.cons)

[ð](#lib:set,constructor)

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

[1](#cons-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12866)

*Effects*: Constructs an empty set using the specified comparison object and allocator[.](#cons-1.sentence-1)

[2](#cons-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12870)

*Complexity*: Constant[.](#cons-2.sentence-1)

[ð](#lib:set,constructor_)

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

[3](#cons-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12883)

*Effects*: Constructs an emptyset using the specified comparison object and allocator,
and inserts elements from the range
[first, last)[.](#cons-3.sentence-1)

[4](#cons-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12891)

*Complexity*: Linear in N if the range
[first, last)
is already sorted with respect to comp and otherwise NlogN,
where N islast - first[.](#cons-4.sentence-1)

[ð](#lib:set,constructor__)

`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());
`

[5](#cons-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12909)

*Effects*: Constructs an empty set using the specified comparison object and allocator,
and inserts elements from the range rg[.](#cons-5.sentence-1)

[6](#cons-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12914)

*Complexity*: Linear in N if rg is already sorted with respect to comp and
otherwise NlogN, where N is ranges​::​distance(rg)[.](#cons-6.sentence-1)

#### [23.4.6.3](#erasure) Erasure [[set.erasure]](set.erasure)

[ð](#lib:erase_if,set)

`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);
`

[1](#erasure-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12930)

*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) Modifiers [[set.modifiers]](set.modifiers)

[ð](#lib:insert,set)

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

[1](#modifiers-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12955)

*Constraints*: The [*qualified-id*](expr.prim.id.qual#nt:qualified-id "7.5.5.3 Qualified names [expr.prim.id.qual]") Compare​::​is_transparent is valid and denotes a type[.](#modifiers-1.sentence-1)

For the second overload,is_convertible_v<K&&, const_iterator> andis_convertible_v<K&&, iterator> are both false[.](#modifiers-1.sentence-2)

[2](#modifiers-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12963)

*Preconditions*: value_type is *Cpp17EmplaceConstructible* into set fromstd​::​forward<K>(x)[.](#modifiers-2.sentence-1)

[3](#modifiers-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12968)

*Effects*: If the set already contains an element that is equivalent to x,
there is no effect[.](#modifiers-3.sentence-1)

Otherwise, let r be equal_range(x)[.](#modifiers-3.sentence-2)

Constructs an object u of type value_type with std​::​forward<K>(x)[.](#modifiers-3.sentence-3)

If equal_range(u) == r is false, the behavior is undefined[.](#modifiers-3.sentence-4)

Inserts u into *this[.](#modifiers-3.sentence-5)

[4](#modifiers-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12978)

*Returns*: For the first overload,
the bool component of the returned pair is true if and only if the insertion took place[.](#modifiers-4.sentence-1)

The returned iterator points to the set element that is equivalent to x[.](#modifiers-4.sentence-2)

[5](#modifiers-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/containers.tex#L12985)

*Complexity*: Logarithmic[.](#modifiers-5.sentence-1)
