stl源码剖析 详细学习笔记 hashset hashmap

//---------------------------15/03/26----------------------------

//hash_set

{

    /*

        hash_set概述：

        1:这是一个hash版本的set，RB_tree版本的set有自动排序功能，

        而hash_set没有这个功能。

        2:hash_set的使用方式，与set完全相同。

    */

    

    //class

    template<class Value, class HashFcn = hash<Value>,

                class EqualKey = equal_to<Value>, class Alloc=alloc>

    class hash_set

    {

    private:

        typedef hashtable<Value, Value, HashFcn, identity<Value>,

                            EqualKey, Alloc> ht;

        

        ht rep;

        

    public:

        typedef typename ht::key_type key_type;

        typedef typename ht::value_type value_type;

        typedef typename ht::hasher hasher;         //hashtable中: typedef HashFcn hasher

        typedef typename ht::key_equel key_equel;

        

        typedef typename ht::size_type size_type;

        typedef typename ht::difference_type difference_type;

        typedef typename ht::const_pointer pointer;

        typedef typename ht::const_pointer const_pointer;

        typedef typename ht::const_reference reference;

        typedef typename ht::const_reference const_reference;

        

        typedef typename ht::const_iterator iterator;

        typedef typename ht::const_iterator const_iterator;

        

        hasher hash_funct() const {return rep.hash_funct(); }

        key_equel key_eq() const { return rep.key_eq(); }

        

    public:

        

        //各种构造函数 ,不给定大小的话默认值为100,实际上找到的质数为193

        hash_set() : rep(100,hasher(), key_equel()){}

        explicit hash_set(size_type n) : rep(n, hasher(), key_equel()) {}

        hash_set(size_type n, const hasher& hf) : rep(n, hf, key_equel()) {}

        hash_set(size_type n, const hasher& hf, const key_equel& eql)

            : rep(n, hf, eql) {}

        

        template< class InputIterator>

        hash_set(InputIterator f, InputIterator l)

        : rep(100, hasher(), key_equel()) { rep.insert_unique(f, l); }

        

        template< class InputIterator>

        hash_set(InputIterator f, InputIterator l, size_type n)

        : rep(n, hasher(), key_equel()) { rep.insert_unique(f, l); }

        

        template< class InputIterator>

        hash_set(InputIterator f, InputIterator l, size_type n, const hasher& hf)

        : rep(n, hf, key_equel()) { rep.insert_unique(f, l); }

        

        template< class InputIterator>

        hash_set(InputIterator f, InputIterator l, size_type n, const hasher& hf

                    const key_equel& eql)

        : rep(100, hf, eql) { rep.insert_unique(f, l); }

    public:

        

        size_type size() const {return rep.size();}

        size_type max_size() const { return rep.max_size(); }

        bool empty() const {return rep.empty(); }

        void swap(hash_set& hs) { rep.swap(hs.rep); }

        friend bool operator== __STL_NULL_TMPL_ARGS (const hash_set&, const hash_set&);

        iterator begin() const { return rep.begin(); }

        iterator end() const { return rep.end(); }

    public:

        pair<iterator, bool> insert(const value_type& obj)

        {

            pair<typename ht::iterator, bool> p =rep.insert_unique(obj);

            return pair<iterator, bool>(p.first, p.second);

        }

        

        template<class InputIterator>

        void insert(InputIterator f, InputIterator l) { rep.insert_unique(f,l); }

        pair<iterator, bool> insert_noresize(const value_type& obj)

        {

            pair<typename ht::iterator, bool> p = rep.insert_unique_noresize(obj);

            return pair<iterator, bool>(p.first, p.second);

        }

        

        iterator find(const key_type& key) const { return rep.find(key); }

        

        size_type count(const key_type& key) const {return rep.count(key); }

        

        //相等的key的位置(是一个左闭右开的区间)，由迭代器给出

        pair<iterator, iterator> equal_range(const key_type& key) const

        { return rep.equal_range(key); }

        

        size_type erase(const key_type& key) { return rep.erase(key); }

        void erase(iterator it) { rep.erase(it); }

        void erase(iterator f, iterator l) { rep.erase(f, l); }

        void clear() { rep.clear(); }

        

    public:

        void    resize(size_type hint) { rep.resize(hint); }

        size_type bucket_count() const { return rep.bucket_count(); }

        size_type elems_in_bucket(size_type n) const

        { return rep.elems_in_bucket(n); }

        

        //class

        template<class Value, class HashFcn, class EqualKey, class Alloc>

        inline bool operator==(const hash_set<Value, HashFcn, EqualKey, Alloc>& hs1,

                               const hash_set<Value, HashFcn, EqualKey, Alloc>& hs2)

        {

            return has1.rep == has2.rep;

        }

    };

    

    

    

    

    

}

//hash_map

{

    /*

        hash_map概述：

        hash_map之于map就像hash_set之于set一样。

     */

    

    //class

    template<class Key, class T, class HashFcn = hash<Value>,

    class EqualKey = equal_to<Value>, class Alloc=alloc>

    class hash_map

    {

    private:

        typedef hashtable<pair<const Key, T>, Key, HashFcn,

                            select1st<pair<const Key, T>, EqualKey, Alloc> ht;

        

        ht rep;

        

    public:

        typedef typename ht::key_type key_type;

        typedef T data_type;

        typedef T mapped_type;

        typedef typename ht::value_type value_type;

        typedef typename ht::hasher hasher;         //hashtable中: typedef HashFcn hasher

        typedef typename ht::key_equel key_equel;

        

        typedef typename ht::size_type size_type;

        typedef typename ht::difference_type difference_type;

        typedef typename ht::pointer pointer;

        typedef typename ht::const_pointer const_pointer;

        typedef typename ht::reference reference;

        typedef typename ht::const_reference const_reference;

        

        typedef typename ht::iterator iterator;

        typedef typename ht::const_iterator const_iterator;

        

        hasher hash_funct() const {return rep.hash_funct(); }

        key_equel key_eq() const { return rep.key_eq(); }

        

    public:

        

        //各种构造函数 ,不给定大小的话默认值为100,实际上找到的质数为193

        hash_map() : rep(100, hasher(), key_equel()){}

        explicit hash_map(size_type n) : rep(n, hasher(), key_equel()) {}

        hash_map(size_type n, const hasher& hf) : rep(n, hf, key_equel()) {}

        hash_map(size_type n, const hasher& hf, const key_equel& eql)

        : rep(n, hf, eql) {}

        

        template< class InputIterator>

        hash_map(InputIterator f, InputIterator l)

        : rep(100, hasher(), key_equel()) { rep.insert_unique(f, l); }

        

        template< class InputIterator>

        hash_map(InputIterator f, InputIterator l, size_type n)

        : rep(n, hasher(), key_equel()) { rep.insert_unique(f, l); }

        

        template< class InputIterator>

        hash_map(InputIterator f, InputIterator l, size_type n, const hasher& hf)

        : rep(n, hf, key_equel()) { rep.insert_unique(f, l); }

        

        template< class InputIterator>

        hash_map(InputIterator f, InputIterator l, size_type n, const hasher& hf

                 const key_equel& eql)

        : rep(100, hf, eql) { rep.insert_unique(f, l); }

    public:

        

        size_type size() const {return rep.size();}

        size_type max_size() const { return rep.max_size(); }

        bool empty() const {return rep.empty(); }

        void swap(hash_map& hs) { rep.swap(hs.rep); }

        friend bool operator== __STL_NULL_TMPL_ARGS (const hash_map&, const hash_map&);

        

        iterator begin() const { return rep.begin(); }

        iterator end() const { return rep.end(); }

    public:

        pair<iterator, bool> insert(const value_type& obj)

        {

            //之前在set中就想过 为什么不直接返回 在map中看到时直接返回了，

            //不是像set中一样还要先申请一个临时变量 再返回临时变量

            //经过一番努力，发现：set的iterator是const_iterator，因为set不能更改值嘛

            //所以需要进行转化，所以set那里会复杂一些

            return rep.insert_unique(obj);

            

        }

        

        template<class InputIterator>

        void insert(InputIterator f, InputIterator l) { rep.insert_unique(f,l); }

        pair<iterator, bool> insert_noresize(const value_type& obj)

        {

           return  rep.insert_unique_noresize(obj);

            

        }

        

        iterator find(const key_type& key) const { return rep.find(key); }

        const_iterator find(const key_type& key) const { return rep.find(key);}

        

        T& operator[](const key_type& key)

        {

            return rep.find_or_insert(value_type(key, T())).second;

        }

        

        size_type count(const key_type& key) const {return rep.count(key); }

        

        //相等的key的位置(是一个左闭右开的区间)，由迭代器给出

        pair<iterator, iterator> equal_range(const key_type& key) const

        { return rep.equal_range(key); }

        

        size_type erase(const key_type& key) { return rep.erase(key); }

        void erase(iterator it) { rep.erase(it); }

        void erase(iterator f, iterator l) { rep.erase(f, l); }

        void clear() { rep.clear(); }

        

    public:

        void    resize(size_type hint) { rep.resize(hint); }

        size_type bucket_count() const { return rep.bucket_count(); }

        size_type elems_in_bucket(size_type n) const

        { return rep.elems_in_bucket(n); }

        

        //class

        template<class Value, class HashFcn, class EqualKey, class Alloc>

        inline bool operator==(const hash_map<Value, HashFcn, EqualKey, Alloc>& hm1,

                               const hash_map<Value, HashFcn, EqualKey, Alloc>& hm2)

        {

            return has1.rep == has2.rep;

        }

    };

    

    

    

    

    

}

//hash_multiset

{

    /*

     hash_multiset概述：

        同上

     */

    

    //class

    template<class Value, class HashFcn = hash<Value>,

    class EqualKey = equal_to<Value>, class Alloc=alloc>

    class hash_multiset

    {

    private:

        typedef hash_multiset<Value, Value, HashFcn, identity<Value>,

        EqualKey, Alloc> ht;

        

        ht rep;

        

    public:

        typedef typename ht::key_type key_type;

        typedef typename ht::value_type value_type;

        typedef typename ht::hasher hasher;         //hashtable中: typedef HashFcn hasher

        typedef typename ht::key_equel key_equel;

        

        typedef typename ht::size_type size_type;

        typedef typename ht::difference_type difference_type;

        typedef typename ht::const_pointer pointer;

        typedef typename ht::const_pointer const_pointer;

        typedef typename ht::const_reference reference;

        typedef typename ht::const_reference const_reference;

        

        typedef typename ht::const_iterator iterator;

        typedef typename ht::const_iterator const_iterator;

        

        hasher hash_funct() const {return rep.hash_funct(); }

        key_equel key_eq() const { return rep.key_eq(); }

        

    public:

        

        //各种构造函数 ,不给定大小的话默认值为100,实际上找到的质数为193

        hash_multiset() : rep(100,hasher(), key_equel()){}

        explicit hash_multiset(size_type n) : rep(n, hasher(), key_equel()) {}

        hash_multiset(size_type n, const hasher& hf) : rep(n, hf, key_equel()) {}

        hash_multiset(size_type n, const hasher& hf, const key_equel& eql)

        : rep(n, hf, eql) {}

        

        template< class InputIterator>

        hash_multiset(InputIterator f, InputIterator l)

        : rep(100, hasher(), key_equel()) { rep.insert_equal(f, l); }

        

        template< class InputIterator>

        hash_multiset(InputIterator f, InputIterator l, size_type n)

        : rep(n, hasher(), key_equel()) { rep.insert_equal(f, l); }

        

        template< class InputIterator>

        hash_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf)

        : rep(n, hf, key_equel()) { rep.insert_equal(f, l); }

        

        template< class InputIterator>

        hash_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf

                 const key_equel& eql)

        : rep(100, hf, eql) { rep.insert_equal(f, l); }

    public:

        

        size_type size() const {return rep.size();}

        size_type max_size() const { return rep.max_size(); }

        bool empty() const {return rep.empty(); }

        void swap(hash_multiset& hs) { rep.swap(hs.rep); }

        friend bool operator== __STL_NULL_TMPL_ARGS (const hash_multiset&, const hash_multiset&);

        iterator begin() const { return rep.begin(); }

        iterator end() const { return rep.end(); }

    public:

        iterator insert(const value_type& obj)

        {

            return rep.insert_equal(obj);

        }

        

        template<class InputIterator>

        void insert(InputIterator f, InputIterator l) { rep.insert_equal(f,l); }

        iterator insert_noresize(const value_type& obj)

        {

            return rep.insert_equal_noresize(obj);

        }

        

        iterator find(const key_type& key) const { return rep.find(key); }

        

        size_type count(const key_type& key) const {return rep.count(key); }

        

        //相等的key的位置(是一个左闭右开的区间)，由迭代器给出

        pair<iterator, iterator> equal_range(const key_type& key) const

        { return rep.equal_range(key); }

        

        size_type erase(const key_type& key) { return rep.erase(key); }

        void erase(iterator it) { rep.erase(it); }

        void erase(iterator f, iterator l) { rep.erase(f, l); }

        void clear() { rep.clear(); }

        

    public:

        void    resize(size_type hint) { rep.resize(hint); }

        size_type bucket_count() const { return rep.bucket_count(); }

        size_type elems_in_bucket(size_type n) const

        { return rep.elems_in_bucket(n); }

        

        //class

        template<class Value, class HashFcn, class EqualKey, class Alloc>

        inline bool operator==(const hash_multiset<Value, HashFcn, EqualKey, Alloc>& hs1,

                               const hash_multiset<Value, HashFcn, EqualKey, Alloc>& hs2)

        {

            return has1.rep == has2.rep;

        }

    };

    

    

    

}

//hash_multimap

{

    /*

        hash_multimap概述：

        同上

     */

    

    //class

    template<class Key, class T, class HashFcn = hash<Value>,

    class EqualKey = equal_to<Value>, class Alloc=alloc>

    class hash_multimap

    {

    private:

        typedef hashtable<pair<const Key, T>, Key, HashFcn,

        select1st<pair<const Key, T>, EqualKey, Alloc> ht;

        

        ht rep;

        

    public:

        typedef typename ht::key_type key_type;

        typedef T data_type;

        typedef T mapped_type;

        typedef typename ht::value_type value_type;

        typedef typename ht::hasher hasher;         //hashtable中: typedef HashFcn hasher

        typedef typename ht::key_equel key_equel;

        

        typedef typename ht::size_type size_type;

        typedef typename ht::difference_type difference_type;

        typedef typename ht::pointer pointer;

        typedef typename ht::const_pointer const_pointer;

        typedef typename ht::reference reference;

        typedef typename ht::const_reference const_reference;

        

        typedef typename ht::iterator iterator;

        typedef typename ht::const_iterator const_iterator;

        

        hasher hash_funct() const {return rep.hash_funct(); }

        key_equel key_eq() const { return rep.key_eq(); }

        

    public:

        

        //各种构造函数 ,不给定大小的话默认值为100,实际上找到的质数为193

        hash_multimap() : rep(100, hasher(), key_equel()){}

        explicit hash_multimap(size_type n) : rep(n, hasher(), key_equel()) {}

        hash_multimap(size_type n, const hasher& hf) : rep(n, hf, key_equel()) {}

        hash_multimap(size_type n, const hasher& hf, const key_equel& eql)

        : rep(n, hf, eql) {}

        

        template< class InputIterator>

        hash_multimap(InputIterator f, InputIterator l)

        : rep(100, hasher(), key_equel()) { rep.insert_equal(f, l); }

        

        template< class InputIterator>

        hash_multimap(InputIterator f, InputIterator l, size_type n)

        : rep(n, hasher(), key_equel()) { rep.insert_equal(f, l); }

        

        template< class InputIterator>

        hash_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf)

        : rep(n, hf, key_equel()) { rep.insert_equal(f, l); }

        

        template< class InputIterator>

        hash_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf

                 const key_equel& eql)

        : rep(100, hf, eql) { rep.insert_equal(f, l); }

    public:

        

        size_type size() const {return rep.size();}

        size_type max_size() const { return rep.max_size(); }

        bool empty() const {return rep.empty(); }

        void swap(hash_multimap& hs) { rep.swap(hs.rep); }

        friend bool operator== __STL_NULL_TMPL_ARGS (const hash_multimap&, const hash_multimap&);

        

        iterator begin() const { return rep.begin(); }

        iterator end() const { return rep.end(); }

    public:

        iterator insert(const value_type& obj)

        {

            return rep.insert_equal(obj);

        }

        

        template<class InputIterator>

        void insert(InputIterator f, InputIterator l) { rep.insert_equal(f,l); }

        iterator insert_noresize(const value_type& obj)

        {

            return  rep.insert_equal_noresize(obj);

            

        }

        

        iterator find(const key_type& key) const { return rep.find(key); }

        const_iterator find(const key_type& key) const { return rep.find(key);}

        

        

        size_type count(const key_type& key) const {return rep.count(key); }

        

        //相等的key的位置(是一个左闭右开的区间)，由迭代器给出

        pair<iterator, iterator> equal_range(const key_type& key) const

        { return rep.equal_range(key); }

        

        size_type erase(const key_type& key) { return rep.erase(key); }

        void erase(iterator it) { rep.erase(it); }

        void erase(iterator f, iterator l) { rep.erase(f, l); }

        void clear() { rep.clear(); }

        

    public:

        void    resize(size_type hint) { rep.resize(hint); }

        size_type bucket_count() const { return rep.bucket_count(); }

        size_type elems_in_bucket(size_type n) const

        { return rep.elems_in_bucket(n); }

        

        //class

        template<class Value, class HashFcn, class EqualKey, class Alloc>

        inline bool operator==(const hash_multimap<Value, HashFcn, EqualKey, Alloc>& hm1,

                               const hash_multimap<Value, HashFcn, EqualKey, Alloc>& hm2)

        {

            return has1.rep == has2.rep;

        }

    };

    

    

    

    

    

}