Заголовочный файл стандартной библиотеки <unordered_set>

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов(C++20)

Библиотека метапрограммирования(C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов(C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения(C++11)

Атомарные операции(C++11)

Библиотека поддержки конкуренции(C++11)

Библиотека файловой системы(C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Заголовочные файлы стандартной библиотеки

Языковая поддержка
<cstddef> <cstdlib> <version>(C++20) <limits> <climits>	<cfloat> <cstdint>(C++11) <stdfloat>(C++23) <new> <typeinfo>	<source_location>(C++20) <exception> <initializer_list>(C++11) <compare>(C++20)	<coroutine>(C++20) <csignal> <csetjmp> <cstdarg>
Концепты
<concepts>(C++20)
Диагностика
<stdexcept> <stacktrace>(C++23)	<cassert>	<cerrno>	<system_error>(C++11)
Управление памятью
<memory>	<memory_resource>(C++17)	<scoped_allocator>(C++11)
Метапрограммирование
<type_traits>(C++11)	<ratio>(C++11)
Общие утилиты
<utility> <tuple>(C++11) <optional>(C++17) <variant>(C++17)	<any>(C++17) <expected>(C++23) <bitset>	<functional> <typeindex>(C++11) <execution>(C++17)	<charconv>(C++17) <format>(C++20) <bit>(C++20)
Строки
<string_view>(C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar>(C++11)
Контейнеры
<array>(C++11) <deque> <forward_list>(C++11) <list>	<vector> <map> <set> <unordered_map>(C++11)	<unordered_set>(C++11) <queue> <stack> <flat_map>(C++23)	<flat_set>(C++23) <span>(C++20) <mdspan>(C++23)
Итераторы
<iterator>
Диапазоны
<ranges>(C++20)	<generator>(C++23)
Алгоритмы
<algorithm>	<numeric>
Числа
<cfenv>(C++11) <complex>	<random>(C++11) <valarray>	<cmath>	<numbers>(C++20)
Время
<chrono>(C++11)	<ctime>
Локализация
<locale>	<clocale>	<codecvt>(C++11/17*)
Ввод/вывод
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print>(C++23)	<sstream> <spanstream>(C++23) <fstream> <syncstream>(C++20)	<filesystem>(C++17) <cstdio> <cinttypes>(C++11) <strstream>(C++98*)
Регулярные выражения
<regex>(C++11)
Поддержка конкуренции
<stop_token>(C++20) <thread>(C++11) <atomic>(C++11)	<stdatomic.h>(C++23) <mutex>(C++11) <shared_mutex>(C++14)	<condition_variable>(C++11)   <semaphore>(C++20) <latch>(C++20)	<barrier>(C++20) <future>(C++11)
Совместимость с C
<cstdbool>(C++11/17/20*)   <ccomplex>(C++11/17/20*)	<ctgmath>(C++11/17/20*)	<cstdalign>(C++11/17/20*)	<ciso646>(до C++20)

 

Этот заголовок является частью библиотеки контейнеров.

Includes
<compare> (C++20)	Поддержка оператора трёхстороннего сравнения
<initializer_list> (C++11)	Шаблонный класс std::initializer_list
Classes
unordered_set (начиная с C++11)	коллекция уникальных ключей, хэшированная по ключам (шаблон класса)
unordered_multiset (начиная с C++11)	коллекция ключей, хэшированная по ключам (шаблон класса)
Functions
operator==operator!= (удалено в C++20)	сравнивает значения в unordered_set (шаблон функции)
std::swap(std::unordered_set) (C++11)	специализация алгоритма std::swap (шаблон функции)
erase_if(std::unordered_set) (C++20)	стирает все элементы, соответствующие определённым критериям (шаблон функции)
operator==operator!= (удалено в C++20)	сравнивает значения в unordered_multiset (шаблон функции)
std::swap(std::unordered_multiset) (C++11)	специализация алгоритма std::swap (шаблон функции)
erase_if(std::unordered_multiset) (C++20)	стирает все элементы, соответствующие определённым критериям (шаблон функции)
Range access
begincbegin (C++11)(C++14)	возвращает итератор на начало контейнера или массива (шаблон функции)
endcend (C++11)(C++14)	возвращает итератор на конец контейнера или массива (шаблон функции)
rbegincrbegin (C++14)	возвращает обратный итератор на начало контейнера или массива (шаблон функции)
rendcrend (C++14)	возвращает обратный конечный итератор для контейнера или массива (шаблон функции)
sizessize (C++17)(C++20)	возвращает размер контейнера или массива (шаблон функции)
empty (C++17)	проверяет, пустой ли контейнер (шаблон функции)
data (C++17)	получает указатель на базовый массив (шаблон функции)

Синопсис

#include <compare>#include <initializer_list>   namespace std {// шаблон класса unordered_settemplate<class Key, class Hash = hash<Key>, class Pred = equal_to<Key>, class Alloc = allocator<Key>>class unordered_set;   // шаблон класса 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, class Predicate>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, class Predicate>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>>;}}

Шаблон класса 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>;   // создание/копирование/разрушение 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;   // итераторы iterator begin()noexcept; const_iterator begin()constnoexcept; iterator end()noexcept; const_iterator end()constnoexcept; const_iterator cbegin()constnoexcept; const_iterator cend()constnoexcept;   // емкость[[nodiscard]]bool empty()constnoexcept; size_type size()constnoexcept; size_type max_size()constnoexcept;   // модификаторыtemplate<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);template<class K> node_type extract(K&& 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);template<class K> size_type erase(K&& x); 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);   // наблюдатели hasher hash_function()const; key_equal key_eq()const;   // набор операция 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;   // политика хешированияfloat 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)));}

Шаблон класса 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 */;   // создание/копирование/разрушение 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;   // итераторы iterator begin()noexcept; const_iterator begin()constnoexcept; iterator end()noexcept; const_iterator end()constnoexcept; const_iterator cbegin()constnoexcept; const_iterator cend()constnoexcept;   // емкость[[nodiscard]]bool empty()constnoexcept; size_type size()constnoexcept; size_type max_size()constnoexcept;   // модификаторыtemplate<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);template<class K> node_type extract(K&& 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);template<class K> size_type erase(K&& x); 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);   // наблюдатели hasher hash_function()const; key_equal key_eq()const;   // набор операций 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;   // политика хешированияfloat 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)));}