• Log in

#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))); // erasure for unordered_settemplate<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_multisettemplate<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>>;}}

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 InputIter>    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<value_type> 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<Allocator>&);    unordered_set(unordered_set&&,const type_identity_t<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 InputIter>    unordered_set(InputIter f, InputIter l, size_type n,const allocator_type& a): unordered_set(f, l, n, hasher(), key_equal(), a){}template<class InputIter>    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<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>    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>    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){}    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; // capacitybool 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);template<class K>    pair<iterator,bool> insert(K&& obj);    iterator insert(const_iterator hint,const value_type& obj);    iterator insert(const_iterator hint, value_type&& obj);template<class K>    iterator insert(const_iterator hint, K&& obj);template<class InputIter>void insert(InputIter first, InputIter last);template<container-compatible-range<value_type> R>void insert_range(R&& rg);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)      requires(!same_as<iterator, const_iterator>);    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); // 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;template<class K>    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 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 InputIter,class Hash= hash</*iter-value-type*/<InputIter>>,class Pred= equal_to</*iter-value-type*/<InputIter>>,class Allocator= allocator</*iter-value-type*/<InputIter>>>  unordered_set(InputIter,                InputIter,typename/* see description */::size_type=/* see description */,                Hash= Hash(),                Pred= Pred(),                Allocator= Allocator())-> unordered_set</*iter-value-type*/<InputIter>, 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 description */::size_type=/* see description */,                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 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*/<InputIter>,                                            hash</*iter-value-type*/<InputIter>>,                                            equal_to</*iter-value-type*/<InputIter>>,                                            Allocator>; template<class InputIter,class Hash,class Allocator>  unordered_set(InputIter,                InputIter,typename/* see description */::size_type,                Hash,                Allocator)-> unordered_set</*iter-value-type*/<InputIter>,                                            Hash,                                            equal_to</*iter-value-type*/<InputIter>>,                                            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<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 description */::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 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>;}

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 InputIter>    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<value_type> 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<Allocator>&);    unordered_multiset(unordered_multiset&&,const type_identity_t<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 InputIter>    unordered_multiset(InputIter f, InputIter l, size_type n,const allocator_type& a): unordered_multiset(f, l, n, hasher(), key_equal(), a){}template<class InputIter>    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<value_type> R>    unordered_multiset(from_range_t, R&& rg, size_type n,const allocator_type& a): unordered_multiset(from_range,std::forward<R>(rg), n, hasher(), key_equal(), a){}template<container-compatible-range<value_type> R>    unordered_multiset(from_range_t,                       R&& rg,                       size_type n,const hasher& hf,const allocator_type& a): unordered_multiset(from_range,std::forward<R>(rg), 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; // capacitybool 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 InputIter>void insert(InputIter first, InputIter last);template<container-compatible-range<value_type> R>void insert_range(R&& rg);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)      requires(!same_as<iterator, const_iterator>);    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); // 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;template<class K>    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 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 InputIter,class Hash= hash</*iter-value-type*/<InputIter>>,class Pred= equal_to</*iter-value-type*/<InputIter>>,class Allocator= allocator</*iter-value-type*/<InputIter>>>  unordered_multiset(InputIter,                     InputIter,/* see description */::size_type=/* see description */,                     Hash= Hash(),                     Pred= Pred(),                     Allocator= Allocator())-> unordered_multiset</*iter-value-type*/<InputIter>, 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_multiset(from_range_t,                     R&&,typename/* see description */::size_type=/* see description */,                     Hash= Hash(),                     Pred= Pred(),                     Allocator= Allocator())-> unordered_multiset<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_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 InputIter,class Allocator>  unordered_multiset(InputIter,                     InputIter,typename/* see description */::size_type,                     Allocator)-> unordered_multiset</*iter-value-type*/<InputIter>,                          hash</*iter-value-type*/<InputIter>>,                          equal_to</*iter-value-type*/<InputIter>>,                          Allocator>; template<class InputIter,class Hash,class Allocator>  unordered_multiset(InputIter,                     InputIter,typename/* see description */::size_type,                     Hash,                     Allocator)-> unordered_multiset</*iter-value-type*/<InputIter>,                          Hash,                          equal_to</*iter-value-type*/<InputIter>>,                          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<R>,                                                      hash<ranges::range_value_t<R>>,                                                      equal_to<ranges::range_value_t<R>>,                                                      Allocator>; template<ranges::input_range R,class Allocator>  unordered_multiset(from_range_t, R&&, Allocator)-> unordered_multiset<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_multiset(from_range_t,                     R&&,typename/* see description */::size_type,                     Hash,                     Allocator)-> unordered_multiset<ranges::range_value_t<R>,                                                      Hash,                                                      equal_to<ranges::range_value_t<R>>,                                                      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>;}