Synopsis

template <class Key,
    class Hash  = std::tr1::hash<Key>,
    class Pred  = std::equal_to<Key>,
    class Alloc= std::allocator<Key> >
    class unordered_set {
public:
    typedef Key key_type;
    typedef Key value_type;
    typedef Hash hasher;
    typedef Pred key_equal;
    typedef Alloc allocator_type;

    typedef Alloc::pointer pointer;
    typedef Alloc::const_pointer const_pointer;
    typedef Alloc::reference reference;
    typedef Alloc::const_reference const_reference;

    typedef T0 iterator;
    typedef T1 const_iterator;
    typedef T2 size_type;
    typedef T3 difference_type;
    typedef T4 local_iterator;
    typedef T5 const_local_iterator;

    unordered_set {
        const unordered_set& right);
    explicit unordered_set(
        size_type nbuckets = N0,
        const Hash& hfn = Hash(),
        const Pred& comp = Pred(),
        const Alloc& al = Alloc());
    template<class InIt>
        unordered_set(
        InIt first, InIt last,
        size_type nbuckets = N0,
        const Hash& hfn = Hash(),
        const Pred& comp = Pred(),
        const Alloc& al = Alloc());

    iterator begin();
    const_iterator begin() const;
    local_iterator begin(size_type nbucket);
    const_local_iterator begin(size_type nbucket) const;

    iterator end();
    const_iterator end() const;
    local_iterator end(size_type nbucket);
    const_local_iterator end(size_type nbucket) const;

    size_type size() const;
    size_type max_size() const;
    bool empty() const;

    size_type bucket_count() const;
    size_type max_bucket_count() const;
    size_type bucket(const Key& keyval) const;
    size_type bucket_size(size_type nbucket) const;
    
    Hash hash_function() const;
    Pred key_eq() const;
    Alloc get_allocator() const;

    float load_factor() const;
    float max_load_factor() const;
    void max_load_factor(float factor);
    void rehash(size_type nbuckets);

    iterator insert(const value_type& val);
    iterator insert(iterator where, const value_type& val);
    template<class InIt>
        void insert(InIt first, InIt last);

    iterator erase(iterator where);
    iterator erase(iterator first, iterator last);
    size_type erase(const Key& keyval);
    void clear();

    void swap(unordered_set& right);

    const_iterator find(const Key& keyval) const;
    size_type count(const Key& keyval) const;
    std::pair<iterator, iterator>
        equal_range(const Key& keyval);
    std::pair<const_iterator, const_iterator>
        equal_range(const Key& keyval) const;
    };