Standard library header <set>

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library(C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library(C++17)

Regular expressions library(C++11)

Atomic operations library(C++11)

Thread support library(C++11)

Technical Specifications

 

Standard Library headers

Language Support
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list> <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <ctime>
Strings
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Ranges
<ranges>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable> <future>	<stop_token> <semaphore>	<latch> <barrier>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

This header is part of the containers library.

Includes
<compare> (C++20)	Three-way comparison operator support
<initializer_list> (C++11)	std::initializer_list class template
Classes
set	collection of unique keys, sorted by keys (class template)
multiset	collection of keys, sorted by keys (class template)
Functions
operator==operator!=operator<operator<=operator>operator>=operator<=> (removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)	lexicographically compares the values in the set (function template)
std::swap(std::set)	specializes the std::swap algorithm (function template)
erase_if(std::set) (C++20)	Erases all elements satisfying specific criteria (function template)
operator==operator!=operator<operator<=operator>operator>=operator<=> (removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)	lexicographically compares the values in the multiset (function template)
std::swap(std::multiset)	specializes the std::swap algorithm (function template)
erase_if(std::multiset) (C++20)	Erases all elements satisfying specific criteria (function template)
Range access
begincbegin (C++11)(C++14)	returns an iterator to the beginning of a container or array (function template)
endcend (C++11)(C++14)	returns an iterator to the end of a container or array (function template)
rbegincrbegin (C++14)	returns a reverse iterator to a container or array (function template)
rendcrend (C++14)	returns a reverse end iterator for a container or array (function template)
sizessize (C++17)(C++20)	returns the size of a container or array (function template)
empty (C++17)	checks whether the container is empty (function template)
data (C++17)	obtains the pointer to the underlying array (function template)

Synopsis

#include <compare>#include <initializer_list>   namespace std {// class template settemplate<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>class set;   template<class Key, class Compare, class Allocator>bool operator==(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y);template<class Key, class Compare, class Allocator>/*synth-three-way-result*/<Key> operator<=>(const set<Key, Compare, Allocator>& x, const set<Key, Compare, Allocator>& y);   template<class Key, class Compare, class Allocator>void swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)noexcept(noexcept(x.swap(y)));   template<class Key, class Compare, class Allocator, classPredicate>typename set<Key, Compare, Allocator>::size_type erase_if(set<Key, Compare, Allocator>& c, Predicate pred);   // class template multisettemplate<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>class multiset;   template<class Key, class Compare, class Allocator>bool operator==(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y);template<class Key, class Compare, class Allocator>/*synth-three-way-result*/<Key> operator<=>(const multiset<Key, Compare, Allocator>& x, const multiset<Key, Compare, Allocator>& y);   template<class Key, class Compare, class Allocator>void swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)noexcept(noexcept(x.swap(y)));   template<class Key, class Compare, class Allocator, classPredicate>typename multiset<Key, Compare, Allocator>::size_type erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);   namespace pmr {template<class Key, class Compare = less<Key>>using set =std::set<Key, Compare, polymorphic_allocator<Key>>;   template<class Key, class Compare = less<Key>>using multiset =std::multiset<Key, Compare, polymorphic_allocator<Key>>;}}

Class template std::set

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 */;using difference_type =/* implementation-defined */;using iterator =/* implementation-defined */;using const_iterator =/* implementation-defined */;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>;   // construct/copy/destroy set(): set(Compare()){}explicit set(const Compare& comp, const Allocator&= Allocator());template<class InputIt> set(InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator&= Allocator()); set(const set& x); set(set&& x);explicit set(const Allocator&); set(const set&, const Allocator&); set(set&&, const Allocator&); set(initializer_list<value_type>, const Compare&= Compare(), const Allocator&= Allocator());template<class InputIt> set(InputIt first, InputIt last, const Allocator& a): set(first, last, Compare(), a){} set(initializer_list<value_type> il, const Allocator& a): set(il, Compare(), a){} ~set(); set& operator=(const set& x); set& operator=(set&& x)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_move_assignable_v<Compare>); set& operator=(initializer_list<value_type>); allocator_type get_allocator()constnoexcept;   // iterators iterator begin()noexcept; const_iterator begin()constnoexcept; iterator end()noexcept; const_iterator end()constnoexcept;   reverse_iterator rbegin()noexcept; const_reverse_iterator rbegin()constnoexcept; reverse_iterator rend()noexcept; const_reverse_iterator rend()constnoexcept;   const_iterator cbegin()constnoexcept; const_iterator cend()constnoexcept; const_reverse_iterator crbegin()constnoexcept; const_reverse_iterator crend()constnoexcept;   // capacity[[nodiscard]]bool empty()constnoexcept; size_type size()constnoexcept; size_type max_size()constnoexcept;   // modifierstemplate<class... Args> pair<iterator, bool> emplace(Args&&... args);template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator,bool> insert(const value_type& x); pair<iterator,bool> insert(value_type&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x);template<class InputIt>void insert(InputIt first, InputIt last);void insert(initializer_list<value_type>);   node_type extract(const_iterator position); node_type extract(const key_type& x); insert_return_type insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh);   iterator erase(iterator position); iterator erase(const_iterator position); size_type erase(const key_type& x); iterator erase(const_iterator first, const_iterator last);void swap(set&)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_swappable_v<Compare>);void clear()noexcept;   template<class C2>void merge(set<Key, C2, Allocator>& source);template<class C2>void merge(set<Key, C2, Allocator>&& source);template<class C2>void merge(multiset<Key, C2, Allocator>& source);template<class C2>void merge(multiset<Key, C2, Allocator>&& source);   // observers key_compare key_comp()const; value_compare value_comp()const;   // set operations iterator find(const key_type& x); const_iterator find(const key_type& x)const;template<class K> iterator find(const K& x);template<class K> const_iterator find(const K& x)const;   size_type count(const key_type& x)const;template<class K> size_type count(const K& x)const;   bool contains(const key_type& x)const;template<class K>bool contains(const K& x)const;   iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x)const;template<class K> iterator lower_bound(const K& x);template<class K> const_iterator lower_bound(const K& x)const;   iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x)const;template<class K> iterator upper_bound(const K& x);template<class K> const_iterator upper_bound(const K& x)const;   pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x)const;template<class K> pair<iterator, iterator> equal_range(const K& x);template<class K> pair<const_iterator, const_iterator> equal_range(const K& x)const;};   template<class InputIt, class Compare = less</*iter-value-type*/<InputIt>>, class Allocator = allocator</*iter-value-type*/<InputIt>>> set(InputIt, InputIt, Compare = Compare(), Allocator = Allocator())-> set</*iter-value-type*/<InputIt>, 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 InputIt, class Allocator> set(InputIt, InputIt, Allocator)-> set</*iter-value-type*/<InputIt>, less</*iter-value-type*/<InputIt>>, Allocator>;   template<class Key, class Allocator> set(initializer_list<Key>, Allocator)-> set<Key, less<Key>, Allocator>;   // swaptemplate<class Key, class Compare, class Allocator>void swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)noexcept(noexcept(x.swap(y)));}

Class template std::multiset

namespace std {template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>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<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 */;using difference_type =/* implementation-defined */;using iterator =/* implementation-defined */;using const_iterator =/* implementation-defined */;using reverse_iterator =std::reverse_iterator<iterator>;using const_reverse_iterator =std::reverse_iterator<const_iterator>;using node_type =/* unspecified */;   // construct/copy/destroy multiset(): multiset(Compare()){}explicit multiset(const Compare& comp, const Allocator&= Allocator());template<class InputIt> multiset(InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator&= Allocator()); multiset(const multiset& x); multiset(multiset&& x);explicit multiset(const Allocator&); multiset(const multiset&, const Allocator&); multiset(multiset&&, const Allocator&); multiset(initializer_list<value_type>, const Compare&= Compare(), const Allocator&= Allocator());template<class InputIt> multiset(InputIt first, InputIt last, const Allocator& a): multiset(first, last, Compare(), a){} multiset(initializer_list<value_type> il, const Allocator& a): multiset(il, Compare(), a){} ~multiset(); multiset& operator=(const multiset& x); multiset& operator=(multiset&& x)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_move_assignable_v<Compare>); multiset& operator=(initializer_list<value_type>); allocator_type get_allocator()constnoexcept;   // iterators iterator begin()noexcept; const_iterator begin()constnoexcept; iterator end()noexcept; const_iterator end()constnoexcept;   reverse_iterator rbegin()noexcept; const_reverse_iterator rbegin()constnoexcept; reverse_iterator rend()noexcept; const_reverse_iterator rend()constnoexcept;   const_iterator cbegin()constnoexcept; const_iterator cend()constnoexcept; const_reverse_iterator crbegin()constnoexcept; const_reverse_iterator crend()constnoexcept;   // capacity[[nodiscard]]bool empty()constnoexcept; size_type size()constnoexcept; size_type max_size()constnoexcept;   // modifierstemplate<class... Args> iterator emplace(Args&&... args);template<class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& x); iterator insert(value_type&& x); iterator insert(const_iterator position, const value_type& x); iterator insert(const_iterator position, value_type&& x);template<class InputIt>void insert(InputIt first, InputIt last);void insert(initializer_list<value_type>);   node_type extract(const_iterator position); node_type extract(const key_type& x); iterator insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh);   iterator erase(iterator position); iterator erase(const_iterator position); size_type erase(const key_type& x); iterator erase(const_iterator first, const_iterator last);void swap(multiset&)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_swappable_v<Compare>);void clear()noexcept;   template<class C2>void merge(multiset<Key, C2, Allocator>& source);template<class C2>void merge(multiset<Key, C2, Allocator>&& source);template<class C2>void merge(set<Key, C2, Allocator>& source);template<class C2>void merge(set<Key, C2, Allocator>&& source);   // observers key_compare key_comp()const; value_compare value_comp()const;   // set operations iterator find(const key_type& x); const_iterator find(const key_type& x)const;template<class K> iterator find(const K& x);template<class K> const_iterator find(const K& x)const;   size_type count(const key_type& x)const;template<class K> size_type count(const K& x)const;   bool contains(const key_type& x)const;template<class K>bool contains(const K& x)const;   iterator lower_bound(const key_type& x); const_iterator lower_bound(const key_type& x)const;template<class K> iterator lower_bound(const K& x);template<class K> const_iterator lower_bound(const K& x)const;   iterator upper_bound(const key_type& x); const_iterator upper_bound(const key_type& x)const;template<class K> iterator upper_bound(const K& x);template<class K> const_iterator upper_bound(const K& x)const;   pair<iterator, iterator> equal_range(const key_type& x); pair<const_iterator, const_iterator> equal_range(const key_type& x)const;template<class K> pair<iterator, iterator> equal_range(const K& x);template<class K> pair<const_iterator, const_iterator> equal_range(const K& x)const;};   template<class InputIt, class Compare = less</*iter-value-type*/<InputIt>>, class Allocator = allocator</*iter-value-type*/<InputIt>>> multiset(InputIt, InputIt, Compare = Compare(), Allocator = Allocator())-> multiset</*iter-value-type*/<InputIt>, Compare, Allocator>;   template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>> multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())-> multiset<Key, Compare, Allocator>;   template<class InputIt, class Allocator> multiset(InputIt, InputIt, Allocator)-> multiset</*iter-value-type*/<InputIt>, less<iter-value-type<InputIt>>, Allocator>;   template<class Key, class Allocator> multiset(initializer_list<Key>, Allocator)-> multiset<Key, less<Key>, Allocator>;   // swaptemplate<class Key, class Compare, class Allocator>void swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)noexcept(noexcept(x.swap(y)));}