Standard library header  (C++11) (original) (raw)

This header is part of the containers library.

[edit] Synopsis

#include #include   namespace std { // class template unordered_set template<class Key, class Hash = hash, class Pred = equal_to, class Alloc = allocator> class unordered_set;   // class template unordered_multiset template<class Key, class Hash = hash, class Pred = equal_to, class Alloc = allocator> 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)));   // erasure for unordered_set 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);   // erasure for unordered_multiset 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, class Pred = equal_to> using unordered_set = std::unordered_set<Key, Hash, Pred, polymorphic_allocator>;   template<class Key, class Hash = hash, class Pred = equal_to> using unordered_multiset = std::unordered_multiset<Key, Hash, Pred, polymorphic_allocator>; } }

[edit] Class template std::unordered_set

namespace std { template<class Key, class Hash = hash, class Pred = equal_to, class Allocator = allocator> class unordered_set { public: // types using key_type = Key; using value_type = Key; using hasher = Hash; using key_equal = Pred; using allocator_type = Allocator; using pointer = typename allocator_traits::pointer; using const_pointer = typename allocator_traits::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 unordered_set(InputIter f, InputIter l, size_type n = / see description /, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); template<container-compatible-range R> unordered_set(from_range_t, R&& rg, 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 type_identity_t&); unordered_set(unordered_set&&, const type_identity_t&); unordered_set(initializer_list 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 unordered_set(InputIter f, InputIter l, size_type n, const allocator_type& a) : unordered_set(f, l, n, hasher(), key_equal(), a) { } template unordered_set(InputIter f, InputIter l, size_type n, const hasher& hf, const allocator_type& a) : unordered_set(f, l, n, hf, key_equal(), a) { } unordered_set(initializer_list il, size_type n, const allocator_type& a) : unordered_set(il, n, hasher(), key_equal(), a) { } template<container-compatible-range R> unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_set(from_range, std::forward(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range R> unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a) : unordered_set(from_range, std::forward(rg), n, hf, key_equal(), a) { } unordered_set(initializer_list 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::is_always_equal::value&& is_nothrow_move_assignable_v&& is_nothrow_move_assignable_v); unordered_set& operator=(initializer_list); allocator_type get_allocator() const noexcept;   // iterators iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept;   // capacity bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept;   // modifiers 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); template pair<iterator, bool> insert(K&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); template iterator insert(const_iterator hint, K&& obj); template void insert(InputIter first, InputIter last); template<container-compatible-range R> void insert_range(R&& rg); void insert(initializer_list);   node_type extract(const_iterator position); node_type extract(const key_type& x); template node_type extract(K&& x); insert_return_type insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh);   iterator erase(iterator position) requires(!same_as<iterator, const_iterator>); iterator erase(const_iterator position); size_type erase(const key_type& k); template size_type erase(K&& x); iterator erase(const_iterator first, const_iterator last); void swap(unordered_set&) noexcept( allocator_traits::is_always_equal::value&& is_nothrow_swappable_v&& is_nothrow_swappable_v); 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 iterator find(const K& k); template const_iterator find(const K& k) const; size_type count(const key_type& k) const; template size_type count(const K& k) const; bool contains(const key_type& k) const; template 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 pair<iterator, iterator> equal_range(const K& k); template pair<const_iterator, const_iterator> equal_range(const K& k) const;   // bucket interface size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; template size_type bucket(const K& 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 policy float load_factor() const noexcept; float max_load_factor() const noexcept; void max_load_factor(float z); void rehash(size_type n); void reserve(size_type n); };   template<class InputIter, class Hash = hash</*iter-value-type*/>, class Pred = equal_to</*iter-value-type*/>, class Allocator = allocator</*iter-value-type*/>> unordered_set(InputIter, InputIter, typename / see description / ::size_type = / see description /, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set</*iter-value-type*/, Hash, Pred, Allocator>;   template<ranges::input_range R, class Hash = hash<ranges::range_value_t>, class Pred = equal_to<ranges::range_value_t>, class Allocator = allocator<ranges::range_value_t>> unordered_set(from_range_t, R&&, typename / see description / ::size_type = / see description /, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<ranges::range_value_t, Hash, Pred, Allocator>;   template<class T, class Hash = hash, class Pred = equal_to, class Allocator = allocator> unordered_set(initializer_list, typename / see description / ::size_type = / see description /, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_set<T, Hash, Pred, Allocator>;   template<class InputIter, class Allocator> unordered_set(InputIter, InputIter, typename / see description / ::size_type, Allocator) -> unordered_set</*iter-value-type*/, hash</*iter-value-type*/>, equal_to</*iter-value-type*/>, Allocator>;   template<class InputIter, class Hash, class Allocator> unordered_set(InputIter, InputIter, typename / see description / ::size_type, Hash, Allocator) -> unordered_set</*iter-value-type*/, Hash, equal_to</*iter-value-type*/>, Allocator>;   template<ranges::input_range R, class Allocator> unordered_set(from_range_t, R&&, typename / see description / ::size_type, Allocator) -> unordered_set<ranges::range_value_t, hash<ranges::range_value_t>, equal_to<ranges::range_value_t>, Allocator>;   template<ranges::input_range R, class Allocator> unordered_set(from_range_t, R&&, Allocator) -> unordered_set<ranges::range_value_t, hash<ranges::range_value_t>, equal_to<ranges::range_value_t>, Allocator>;   template<ranges::input_range R, class Hash, class Allocator> unordered_set(from_range_t, R&&, typename / see description / ::size_type, Hash, Allocator) -> unordered_set<ranges::range_value_t, Hash, equal_to<ranges::range_value_t>, Allocator>;   template<class T, class Allocator> unordered_set(initializer_list, typename / see description / ::size_type, Allocator) -> unordered_set<T, hash, equal_to, Allocator>;   template<class T, class Hash, class Allocator> unordered_set(initializer_list, typename / see description */ ::size_type, Hash, Allocator) -> unordered_set<T, Hash, equal_to, Allocator>; }

[edit] Class template std::unordered_multiset

namespace std { template<class Key, class Hash = hash, class Pred = equal_to, class Allocator = allocator> class unordered_multiset { public: // types using key_type = Key; using value_type = Key; using hasher = Hash; using key_equal = Pred; using allocator_type = Allocator; using pointer = typename allocator_traits::pointer; using const_pointer = typename allocator_traits::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 unordered_multiset(InputIter f, InputIter l, size_type n = / see description /, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); template<container-compatible-range R> unordered_multiset(from_range_t, R&& rg, 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 type_identity_t&); unordered_multiset(unordered_multiset&&, const type_identity_t&); unordered_multiset(initializer_list 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 unordered_multiset(InputIter f, InputIter l, size_type n, const allocator_type& a) : unordered_multiset(f, l, n, hasher(), key_equal(), a) { } template unordered_multiset(InputIter f, InputIter l, size_type n, const hasher& hf, const allocator_type& a) : unordered_multiset(f, l, n, hf, key_equal(), a) { } template<container-compatible-range R> unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a) : unordered_multiset(from_range, std::forward(rg), n, hasher(), key_equal(), a) { } template<container-compatible-range R> unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a) : unordered_multiset(from_range, std::forward(rg), n, hf, key_equal(), a) { } unordered_multiset(initializer_list il, size_type n, const allocator_type& a) : unordered_multiset(il, n, hasher(), key_equal(), a) { } unordered_multiset(initializer_list 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::is_always_equal::value&& is_nothrow_move_assignable_v&& is_nothrow_move_assignable_v); unordered_multiset& operator=(initializer_list); allocator_type get_allocator() const noexcept;   // iterators iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept;   // capacity bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept;   // modifiers 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 void insert(InputIter first, InputIter last); template<container-compatible-range R> void insert_range(R&& rg); void insert(initializer_list);   node_type extract(const_iterator position); node_type extract(const key_type& x); template node_type extract(K&& x); iterator insert(node_type&& nh); iterator insert(const_iterator hint, node_type&& nh);   iterator erase(iterator position) requires(!same_as<iterator, const_iterator>); iterator erase(const_iterator position); size_type erase(const key_type& k); template size_type erase(K&& x); iterator erase(const_iterator first, const_iterator last); void swap(unordered_multiset&) noexcept( allocator_traits::is_always_equal::value&& is_nothrow_swappable_v&& is_nothrow_swappable_v); 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 iterator find(const K& k); template const_iterator find(const K& k) const; size_type count(const key_type& k) const; template size_type count(const K& k) const; bool contains(const key_type& k) const; template 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 pair<iterator, iterator> equal_range(const K& k); template pair<const_iterator, const_iterator> equal_range(const K& k) const;   // bucket interface size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; template size_type bucket(const K& 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 policy float load_factor() const noexcept; float max_load_factor() const noexcept; void max_load_factor(float z); void rehash(size_type n); void reserve(size_type n); };   template<class InputIter, class Hash = hash</*iter-value-type*/>, class Pred = equal_to</*iter-value-type*/>, class Allocator = allocator</*iter-value-type*/>> unordered_multiset(InputIter, InputIter, / see description / ::size_type = / see description /, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multiset</*iter-value-type*/, Hash, Pred, Allocator>;   template<ranges::input_range R, class Hash = hash<ranges::range_value_t>, class Pred = equal_to<ranges::range_value_t>, class Allocator = allocator<ranges::range_value_t>> unordered_multiset(from_range_t, R&&, typename / see description / ::size_type = / see description /, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multiset<ranges::range_value_t, Hash, Pred, Allocator>;   template<class T, class Hash = hash, class Pred = equal_to, class Allocator = allocator> unordered_multiset(initializer_list, typename / see description / ::size_type = / see description /, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_multiset<T, Hash, Pred, Allocator>;   template<class InputIter, class Allocator> unordered_multiset(InputIter, InputIter, typename / see description / ::size_type, Allocator) -> unordered_multiset</*iter-value-type*/, hash</*iter-value-type*/>, equal_to</*iter-value-type*/>, Allocator>;   template<class InputIter, class Hash, class Allocator> unordered_multiset(InputIter, InputIter, typename / see description / ::size_type, Hash, Allocator) -> unordered_multiset</*iter-value-type*/, Hash, equal_to</*iter-value-type*/>, Allocator>;   template<ranges::input_range R, class Allocator> unordered_multiset(from_range_t, R&&, typename / see description / ::size_type, Allocator) -> unordered_multiset<ranges::range_value_t, hash<ranges::range_value_t>, equal_to<ranges::range_value_t>, Allocator>;   template<ranges::input_range R, class Allocator> unordered_multiset(from_range_t, R&&, Allocator) -> unordered_multiset<ranges::range_value_t, hash<ranges::range_value_t>, equal_to<ranges::range_value_t>, Allocator>;   template<ranges::input_range R, class Hash, class Allocator> unordered_multiset(from_range_t, R&&, typename / see description / ::size_type, Hash, Allocator) -> unordered_multiset<ranges::range_value_t, Hash, equal_to<ranges::range_value_t>, Allocator>;   template<class T, class Allocator> unordered_multiset(initializer_list, typename / see description / ::size_type, Allocator) -> unordered_multiset<T, hash, equal_to, Allocator>;   template<class T, class Hash, class Allocator> unordered_multiset(initializer_list, typename / see description */ ::size_type, Hash, Allocator) -> unordered_multiset<T, Hash, equal_to, Allocator>; }