[unord.set] (original) (raw)

An unordered_set is an unordered associative container that supports unique keys (an unordered_set contains at most one of each key value) and in which the elements' keys are the elements themselves.

The unordered_set class supports forward iterators.

It provides the operations described in the preceding requirements table for unique keys; that is, an unordered_set supports the a_uniq operations in that table, not the a_eq operations.

For an unordered_set<Key> the key_typeand the value_type are both Key.

The iterator and const_iterator types are both constant iterator types.

It is unspecified whether they are the same type.

Subclause [unord.set] only describes operations on unordered_set that are not described in one of the requirement tables, or for which there is additional semantic information.

namespace std { template<class Key,class Hash = hash<Key>,class Pred = equal_to<Key>,class Allocator = allocator<Key>> class unordered_set { public: using 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>;constexpr unordered_set();constexpr explicit unordered_set(size_type n, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());template<container-compatible-range<value_type> R> constexpr unordered_set(from_range_t, R&& rg, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_set(const unordered_set&);constexpr unordered_set(unordered_set&&);constexpr explicit unordered_set(const Allocator&);constexpr unordered_set(const unordered_set&, const type_identity_t<Allocator>&);constexpr unordered_set(unordered_set&&, const type_identity_t<Allocator>&);constexpr unordered_set(initializer_list<value_type> il, size_type n = see below, const hasher& hf = hasher(),const key_equal& eql = key_equal(),const allocator_type& a = allocator_type());constexpr unordered_set(size_type n, const allocator_type& a) : unordered_set(n, hasher(), key_equal(), a) { } constexpr unordered_set(size_type n, const hasher& hf, const allocator_type& a) : unordered_set(n, hf, key_equal(), a) { } template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n,const allocator_type& a) : unordered_set(f, l, n, hasher(), key_equal(), a) { } template<class InputIterator> constexpr unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,const allocator_type& a) : unordered_set(f, l, n, hf, key_equal(), a) { } constexpr unordered_set(initializer_list<value_type> il, size_type n,const allocator_type& a) : unordered_set(il, n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range<value_type> R> constexpr unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf,const allocator_type& a) : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { } constexpr 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) { } constexpr ~unordered_set();constexpr unordered_set& operator=(const unordered_set&);constexpr 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>);constexpr unordered_set& operator=(initializer_list<value_type>);constexpr allocator_type get_allocator() const noexcept;constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;constexpr size_type max_size() const noexcept;template<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& obj);constexpr pair<iterator, bool> insert(value_type&& obj);template<class K> constexpr pair<iterator, bool> insert(K&& obj);constexpr iterator insert(const_iterator hint, const value_type& obj);constexpr iterator insert(const_iterator hint, value_type&& obj);template<class K> constexpr iterator insert(const_iterator hint, K&& obj);template<class InputIterator> constexpr 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<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 (<iterator, const_iterator>);constexpr iterator erase(const_iterator position);constexpr size_type erase(const key_type& k);template<class K> constexpr size_type erase(K&& x);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(unordered_set&) noexcept(allocator_traits<Allocator>::is_always_equal::value && is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);constexpr void clear() noexcept;template<class H2, class P2> constexpr void merge(unordered_set<Key, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_set<Key, H2, P2, Allocator>&& source);template<class H2, class P2> constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>& source);template<class H2, class P2> constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);constexpr hasher hash_function() const;constexpr key_equal key_eq() const;constexpr iterator find(const key_type& k);constexpr const_iterator find(const key_type& k) const;template<class K> constexpr iterator find(const K& k);template<class K> constexpr const_iterator find(const K& k) const;constexpr size_type count(const key_type& k) const;template<class K> constexpr size_type count(const K& k) const;constexpr bool contains(const key_type& k) const;template<class K> constexpr bool contains(const K& k) const;constexpr pair<iterator, iterator> equal_range(const key_type& k);constexpr pair<const_iterator, const_iterator> equal_range(const key_type& k) const;template<class K> constexpr pair<iterator, iterator> equal_range(const K& k);template<class K> constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;constexpr size_type bucket_count() const noexcept;constexpr size_type max_bucket_count() const noexcept;constexpr size_type bucket_size(size_type n) const;constexpr size_type bucket(const key_type& k) const;template<class K> constexpr size_type bucket(const K& k) const;constexpr local_iterator begin(size_type n);constexpr const_local_iterator begin(size_type n) const;constexpr local_iterator end(size_type n);constexpr const_local_iterator end(size_type n) const;constexpr const_local_iterator cbegin(size_type n) const;constexpr const_local_iterator cend(size_type n) const;constexpr float load_factor() const noexcept;constexpr float max_load_factor() const noexcept;constexpr void max_load_factor(float z);constexpr void rehash(size_type n);constexpr void reserve(size_type n);};template<class InputIterator,class Hash = hash<_iter-value-type_<InputIterator>>,class Pred = equal_to<_iter-value-type_<InputIterator>>,class Allocator = allocator<_iter-value-type_<InputIterator>>> unordered_set(InputIterator, InputIterator, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<_iter-value-type_<InputIterator>, Hash, Pred, Allocator>;template<ranges::input_range R,class Hash = hash<ranges::range_value_t<R>>,class Pred = equal_to<ranges::range_value_t<R>>,class Allocator = allocator<ranges::range_value_t<R>>> unordered_set(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<ranges::range_value_t<R>, 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 below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<T, Hash, Pred, Allocator>;template<class InputIterator, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type, Allocator) -> unordered_set<_iter-value-type_<InputIterator>, hash<_iter-value-type_<InputIterator>>, equal_to<_iter-value-type_<InputIterator>>, Allocator>;template<class InputIterator, class Hash, class Allocator> unordered_set(InputIterator, InputIterator, typename see below::size_type, Hash, Allocator) -> unordered_set<_iter-value-type_<InputIterator>, Hash, equal_to<_iter-value-type_<InputIterator>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Allocator) -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>, equal_to<ranges::range_value_t<R>>, Allocator>;template<ranges::input_range R, class Allocator> unordered_set(from_range_t, R&&, Allocator) -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>, equal_to<ranges::range_value_t<R>>, Allocator>;template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator) -> unordered_set<ranges::range_value_t<R>, Hash, equal_to<ranges::range_value_t<R>>, Allocator>;template<class T, class Allocator> unordered_set(initializer_list<T>, typename see below::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 below::size_type, Hash, Allocator) -> unordered_set<T, Hash, equal_to<T>, Allocator>;}

A size_type parameter type in an unordered_set deduction guide refers to the size_type member type of the type deduced by the deduction guide.