Standard library header <unordered_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
unordered_set (C++11)	collection of unique keys, hashed by keys (class template)
unordered_multiset (C++11)	collection of keys, hashed by keys (class template)
Functions
operator==operator!= (removed in C++20)	compares the values in the unordered_set (function template)
std::swap(std::unordered_set) (C++11)	specializes the std::swap algorithm (function template)
erase_if(std::unordered_set) (C++20)	Erases all elements satisfying specific criteria (function template)
operator==operator!= (removed in C++20)	compares the values in the unordered_multiset (function template)
std::swap(std::unordered_multiset) (C++11)	specializes the std::swap algorithm (function template)
erase_if(std::unordered_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 unordered_­settemplate<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>, class Alloc = allocator<Key>>class unordered_set;   // class template unordered_­multisettemplate<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>, class Alloc = allocator<Key>>class unordered_multiset;   template<class Key, class Hash, class Pred, class Alloc>bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a, const unordered_set<Key, Hash, Pred, Alloc>& b);   template<class Key, class Hash, class Pred, class Alloc>bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a, const unordered_multiset<Key, Hash, Pred, Alloc>& b);   template<class Key, class Hash, class Pred, class Alloc>void swap(unordered_set<Key, Hash, Pred, Alloc>& x, unordered_set<Key, Hash, Pred, Alloc>& y)noexcept(noexcept(x.swap(y)));   template<class Key, class Hash, class Pred, class Alloc>void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x, unordered_multiset<Key, Hash, Pred, Alloc>& y)noexcept(noexcept(x.swap(y)));   template<class K, class H, class P, class A, classPredicate>typename unordered_set<K, H, P, A>::size_type erase_if(unordered_set<K, H, P, A>& c, Predicate pred);   template<class K, class H, class P, class A, classPredicate>typename unordered_multiset<K, H, P, A>::size_type erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);   namespace pmr {template<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>>using unordered_set =std::unordered_set<Key, Hash, Pred, polymorphic_allocator<Key>>;   template<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>>using unordered_multiset =std::unordered_multiset<Key, Hash, Pred, polymorphic_allocator<Key>>;}}

Class template std::unordered_set

namespace std {template<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>, class Allocator = allocator<Key>>class unordered_set {public:// typesusing key_type = Key;using value_type = Key;using hasher = Hash;using key_equal = Pred;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 local_iterator =/* implementation-defined */;using const_local_iterator =/* implementation-defined */;using node_type =/* unspecified */;using insert_return_type =/*insert-return-type*/<iterator, node_type>;   // construct/copy/destroy unordered_set();explicit unordered_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type());template<class InputIt> unordered_set(InputIt f, InputIt l, size_type n =/* see description */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); unordered_set(const unordered_set&); unordered_set(unordered_set&&);explicit unordered_set(const Allocator&); unordered_set(const unordered_set&, const Allocator&); unordered_set(unordered_set&&, const Allocator&); unordered_set(initializer_list<value_type> il, size_type n =/* see description */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); unordered_set(size_type n, const allocator_type& a): unordered_set(n, hasher(), key_equal(), a){} unordered_set(size_type n, const hasher& hf, const allocator_type& a): unordered_set(n, hf, key_equal(), a){}template<class InputIt> unordered_set(InputIt f, InputIt l, size_type n, const allocator_type& a): unordered_set(f, l, n, hasher(), key_equal(), a){}template<class InputIt> unordered_set(InputIt f, InputIt l, size_type n, const hasher& hf, const allocator_type& a): unordered_set(f, l, n, hf, key_equal(), a){} unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a): unordered_set(il, n, hasher(), key_equal(), a){} unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf, const allocator_type& a): unordered_set(il, n, hf, key_equal(), a){} ~unordered_set(); unordered_set& operator=(const unordered_set&); unordered_set& operator=(unordered_set&&)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_move_assignable_v<Hash>&& is_nothrow_move_assignable_v<Pred>); unordered_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; const_iterator cbegin()constnoexcept; const_iterator cend()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& obj); pair<iterator, bool> insert(value_type&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj);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& k); iterator erase(const_iterator first, const_iterator last);void swap(unordered_set&)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_swappable_v<Hash>&& is_nothrow_swappable_v<Pred>);void clear()noexcept;   template<class H2, class P2>void merge(unordered_set<Key, H2, P2, Allocator>& source);template<class H2, class P2>void merge(unordered_set<Key, H2, P2, Allocator>&& source);template<class H2, class P2>void merge(unordered_multiset<Key, H2, P2, Allocator>& source);template<class H2, class P2>void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);   // observers hasher hash_function()const; key_equal key_eq()const;   // set operations iterator find(const key_type& k); const_iterator find(const key_type& k)const;template<class K> iterator find(const K& k);template<class K> const_iterator find(const K& k)const; size_type count(const key_type& k)const;template<class K> size_type count(const K& k)const;bool contains(const key_type& k)const;template<class K>bool contains(const K& k)const; pair<iterator, iterator> equal_range(const key_type& k); pair<const_iterator, const_iterator> equal_range(const key_type& k)const;template<class K> pair<iterator, iterator> equal_range(const K& k);template<class K> pair<const_iterator, const_iterator> equal_range(const K& k)const;   // bucket interface size_type bucket_count()constnoexcept; size_type max_bucket_count()constnoexcept; size_type bucket_size(size_type n)const; size_type bucket(const key_type& k)const; local_iterator begin(size_type n); const_local_iterator begin(size_type n)const; local_iterator end(size_type n); const_local_iterator end(size_type n)const; const_local_iterator cbegin(size_type n)const; const_local_iterator cend(size_type n)const;   // hash policyfloat load_factor()constnoexcept;float max_load_factor()constnoexcept;void max_load_factor(float z);void rehash(size_type n);void reserve(size_type n);};   template<class InputIt, class Hash = hash</*iter-value-type*/<InputIt>>, class Pred = equal_to</*iter-value-type*/<InputIt>>, class Allocator = allocator</*iter-value-type*/<InputIt>>> unordered_set(InputIt, InputIt, typename/* see description */::size_type=/* see description */, Hash = Hash(), Pred = Pred(), Allocator = Allocator())-> unordered_set</*iter-value-type*/<InputIt>, Hash, Pred, Allocator>;   template<class T, class Hash = hash<T>, class Pred = equal_to<T>, class Allocator = allocator<T>> unordered_set(initializer_list<T>, typename/* see description */::size_type=/* see description */, Hash = Hash(), Pred = Pred(), Allocator = Allocator())-> unordered_set<T, Hash, Pred, Allocator>;   template<class InputIt, class Allocator> unordered_set(InputIt, InputIt, typename/* see description */::size_type, Allocator)-> unordered_set</*iter-value-type*/<InputIt>, hash</*iter-value-type*/<InputIt>>, equal_to</*iter-value-type*/<InputIt>>, Allocator>;   template<class InputIt, class Hash, class Allocator> unordered_set(InputIt, InputIt, typename/* see description */::size_type, Hash, Allocator)-> unordered_set</*iter-value-type*/<InputIt>, Hash, equal_to</*iter-value-type*/<InputIt>>, Allocator>;   template<class T, class Allocator> unordered_set(initializer_list<T>, typename/* see description */::size_type, Allocator)-> unordered_set<T, hash<T>, equal_to<T>, Allocator>;   template<class T, class Hash, class Allocator> unordered_set(initializer_list<T>, typename/* see description */::size_type, Hash, Allocator)-> unordered_set<T, Hash, equal_to<T>, Allocator>;   // swaptemplate<class Key, class Hash, class Pred, class Alloc>void swap(unordered_set<Key, Hash, Pred, Alloc>& x, unordered_set<Key, Hash, Pred, Alloc>& y)noexcept(noexcept(x.swap(y)));}

Class template std::unordered_multiset

namespace std {template<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>, class Allocator = allocator<Key>>class unordered_multiset {public:// typesusing key_type = Key;using value_type = Key;using hasher = Hash;using key_equal = Pred;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 local_iterator =/* implementation-defined */;using const_local_iterator =/* implementation-defined */;using node_type =/* unspecified */;   // construct/copy/destroy unordered_multiset();explicit unordered_multiset(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type());template<class InputIt> unordered_multiset(InputIt f, InputIt l, size_type n =/* see description */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); unordered_multiset(const unordered_multiset&); unordered_multiset(unordered_multiset&&);explicit unordered_multiset(const Allocator&); unordered_multiset(const unordered_multiset&, const Allocator&); unordered_multiset(unordered_multiset&&, const Allocator&); unordered_multiset(initializer_list<value_type> il, size_type n =/* see description */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); unordered_multiset(size_type n, const allocator_type& a): unordered_multiset(n, hasher(), key_equal(), a){} unordered_multiset(size_type n, const hasher& hf, const allocator_type& a): unordered_multiset(n, hf, key_equal(), a){}template<class InputIt> unordered_multiset(InputIt f, InputIt l, size_type n, const allocator_type& a): unordered_multiset(f, l, n, hasher(), key_equal(), a){}template<class InputIt> unordered_multiset(InputIt f, InputIt l, size_type n, const hasher& hf, const allocator_type& a): unordered_multiset(f, l, n, hf, key_equal(), a){} unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a): unordered_multiset(il, n, hasher(), key_equal(), a){} unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf, const allocator_type& a): unordered_multiset(il, n, hf, key_equal(), a){} ~unordered_multiset(); unordered_multiset& operator=(const unordered_multiset&); unordered_multiset& operator=(unordered_multiset&&)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_move_assignable_v<Hash>&& is_nothrow_move_assignable_v<Pred>); unordered_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; const_iterator cbegin()constnoexcept; const_iterator cend()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& obj); iterator insert(value_type&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj);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& k); iterator erase(const_iterator first, const_iterator last);void swap(unordered_multiset&)noexcept(allocator_traits<Allocator>::is_always_equal::value&& is_nothrow_swappable_v<Hash>&& is_nothrow_swappable_v<Pred>);void clear()noexcept;   template<class H2, class P2>void merge(unordered_multiset<Key, H2, P2, Allocator>& source);template<class H2, class P2>void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);template<class H2, class P2>void merge(unordered_set<Key, H2, P2, Allocator>& source);template<class H2, class P2>void merge(unordered_set<Key, H2, P2, Allocator>&& source);   // observers hasher hash_function()const; key_equal key_eq()const;   // set operations iterator find(const key_type& k); const_iterator find(const key_type& k)const;template<class K> iterator find(const K& k);template<class K> const_iterator find(const K& k)const; size_type count(const key_type& k)const;template<class K> size_type count(const K& k)const;bool contains(const key_type& k)const;template<class K>bool contains(const K& k)const; pair<iterator, iterator> equal_range(const key_type& k); pair<const_iterator, const_iterator> equal_range(const key_type& k)const;template<class K> pair<iterator, iterator> equal_range(const K& k);template<class K> pair<const_iterator, const_iterator> equal_range(const K& k)const;   // bucket interface size_type bucket_count()constnoexcept; size_type max_bucket_count()constnoexcept; size_type bucket_size(size_type n)const; size_type bucket(const key_type& k)const; local_iterator begin(size_type n); const_local_iterator begin(size_type n)const; local_iterator end(size_type n); const_local_iterator end(size_type n)const; const_local_iterator cbegin(size_type n)const; const_local_iterator cend(size_type n)const;   // hash policyfloat load_factor()constnoexcept;float max_load_factor()constnoexcept;void max_load_factor(float z);void rehash(size_type n);void reserve(size_type n);};   template<class InputIt, class Hash = hash</*iter-value-type*/<InputIt>>, class Pred = equal_to</*iter-value-type*/<InputIt>>, class Allocator = allocator</*iter-value-type*/<InputIt>>> unordered_multiset(InputIt, InputIt, /* see description */::size_type=/* see description */, Hash = Hash(), Pred = Pred(), Allocator = Allocator())-> unordered_multiset</*iter-value-type*/<InputIt>, Hash, Pred, Allocator>;   template<class T, class Hash = hash<T>, class Pred = equal_to<T>, class Allocator = allocator<T>> unordered_multiset(initializer_list<T>, typename/* see description */::size_type=/* see description */, Hash = Hash(), Pred = Pred(), Allocator = Allocator())-> unordered_multiset<T, Hash, Pred, Allocator>;   template<class InputIt, class Allocator> unordered_multiset(InputIt, InputIt, typename/* see description */::size_type, Allocator)-> unordered_multiset</*iter-value-type*/<InputIt>, hash</*iter-value-type*/<InputIt>>, equal_to</*iter-value-type*/<InputIt>>, Allocator>;   template<class InputIt, class Hash, class Allocator> unordered_multiset(InputIt, InputIt, typename/* see description */::size_type, Hash, Allocator)-> unordered_multiset</*iter-value-type*/<InputIt>, Hash, equal_to</*iter-value-type*/<InputIt>>, Allocator>;   template<class T, class Allocator> unordered_multiset(initializer_list<T>, typename/* see description */::size_type, Allocator)-> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>;   template<class T, class Hash, class Allocator> unordered_multiset(initializer_list<T>, typename/* see description */::size_type, Hash, Allocator)-> unordered_multiset<T, Hash, equal_to<T>, Allocator>;   // swaptemplate<class Key, class Hash, class Pred, class Alloc>void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x, unordered_multiset<Key, Hash, Pred, Alloc>& y)noexcept(noexcept(x.swap(y)));}