stl源码剖析 详细学习笔记 set map

//

//  set map.cpp

//  笔记

//

//  Created by fam on 15/3/23.

//

//

//---------------------------15/03/23----------------------------

//set

{

    /*

        set概述：

        1:所有的元素都会被自动排序，

        2:所有的元素只有"键"没有“值” 或者说他们的“值”就是“键”

        3:不允许出现两个相同的键值

        4:不能通过迭代器改变set的值，因为set的值就是键，

        如果可以改变，我们要先删除键，平衡二叉树，再加改变后的键，再平衡

        这么做严重破坏了set的组织，iterator也会变得无效，到底是指向之前的位置

        还是指向改变后的位置等等。所以stl中不允许改变set的值。

        5:set用RB_tree作为底层机制(废话，不然干嘛花大篇幅介绍RB_tree)

    */

    

    //class

    template<class Key, class Compare = less<Key>,

            class Alloc = alloc>

    class set

    {

    public:

        typedef Key key_type;

        typedef Key value_type;

        typedef Compare key_compare;

        typedef Compare value_compare;

        

    private:

        

        //identity<value_type> 可以根据key值得到value值

        typedef rb_tree<key_type, value_type,

        identity<value_type>, key_compare, Alloc> rep_type;

        rep_type t;

        

    public:

        //由于上面说的set不能改变值，所以指针和迭代器引用这些 全都用RB_tree中的const类型的来指定

        typedef typename rep_type::const_pointer pointer;

        typedef typename rep_type::const_pointer const_pointer;

        typedef typename rep_type::const_reference reference;

        typedef typename rep_type::const_reference const_reference;

        typedef typename rep_type::const_iterator   iterator;

        typedef typename rep_type::const_iterator   const_iterator;

        typedef typename rep_type::const_reverse_iterator reverse_iterator;

        typedef typename rep_type::const_reverse_iterator const_reverse_iterator;

        typedef typename rep_type::size_type    size_type;

        typedef typename rep_type::difference_type difference_type;

        

        

        set() : t(Compare()){}

        explicit set(const Compare& comp) : t(comp){}

        

        //inset_unique 是不允许相同值出现的插入

        template<class InputIterator>

        set(InputIterator first, InputIterator last)

            : t(Compare()){ t.insert_unique(first, last);}

        

        template<class InputIterator>

        set(InputIterator first, InputIterator last,const Compare& comp)

            : t(comp){t.insert_unique(first, last);}

        

        set(const set<Key, Compare, Alloc>& x): t(x.t){}

        set<Key, Compare, Alloc>& operator=(const set<Key, Compare, Alloc>& x)

        {

            t = x.t;

            return *this;

        }

        

        key_compare key_comp() const { return t.key_comp();}

        //set中的值就是键 所以调用key_comp()

        value_compare       value_comp()    const {return t.key_comp();}

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

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

        reverse_iterator    rbegin()        const {return t.rbegin();}

        reverse_iterator    rend()          const {return t.end();}

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

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

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

        void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t);}

        

        //insert erase

        typedef pair<iterator, bool> pair_interator_bool;

        

        pair<iterator, bool> inset(const value_type& x)

        {

            pair<typename rep_type::iterator, bool> p =t.insert_unique(x);

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

        }

        

        iterator insert(iterator position, const value_type& x)

        {

            typedef typename rep_type::iterator rep_iterator;

            return t.insert_unique((rep_iterator&)position, x);

        }

        

        template<class InputIterator>

        void insert(InputIterator first, InputIterator last)

        {

            t.insert_unique(first, last);

        }

        

        void erase(iterator position)

        {

            typedef typename rep_type::iterator rep_iterator;

            t.erase((rep_iterator&)position);

        }

        

        size_type erase(const key_type& x)

        {

            return t.erase(x);

        }

        void erase(iterator first, iterator last)

        {

            typedef typename rep_type::iterator rep_iterator;

            t.erase((rep_iterator&)first, (rep_iterator&)last);

        }

        

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

        

        //

        iterator find(const key_type& x) const { return t.find(x); }

        size_type count(const key_type& x) const { return t.count(x); }

        iterator lower_bound(const key_type& x) const

        {

            return t.lower_bound(x);

        }

        iterator upper_bound(const key_type& x) const

        {

            return t.upper_bound(x);

        }

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

        {

            return t.equal_range(x);

        }

        

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

        friend bool operator<  __STL_NULL_TMPL_ARGS (const set&, const set&);

        

    };

    

    

    template<class Key, class Compare, class Alloc>

    inline bool operator==(const set<Key, Compare, Alloc>& x,

                           const set<Key, Compare, Alloc>& y)

    {

        return x.t == y.t;

    }

    

    template<class Key, class Compare, class Alloc>

    inline bool operator<(const set<Key, Compare, Alloc>& x,

                           const set<Key, Compare, Alloc>& y)

    {

        return x.t < y.t;

    }

    

    // 总结

    //没什么好总结的，这里只是不断调用底层的东西，没有技术可言

    

}

//map

{

    /*

        map概述：

        和set不同的就是，多了一个值的概念，每一个键都可以存储一个实值

        排序是根据key(键)来排序的。一般都是根据key来取其中的值。

        和set一样的原理，我们不能改变键。和set不同的是，可以改变data(实值)

        实值只是节点所存储的东西，当然可以改，改了不会影响排序

    */

    

    //struct pair

    

    template<class T1, class T2>

    struct pair

    {

        typedef T1 first_type;

        typedef T2 second_type;

        

        T1 first;

        T2 second;

        

        pair() : first(T1()), second(T2()){}

        pair(const T1& a,const T2& b) : first(a), second(b){}

    };

    

    

    template<class Key, class T, class Compare = less<Key>,

                                    class Alloc = alloc>

    class map

    {

    public:

        typedef Key key_type;

        typedef T data_type;

        typedef T mapped_type;

        typedef pair<const Key, T> value_type;

        typedef Compare key_compare;

        typedef Compare value_compare;

        

        

        class value_compare

        : public binary_function<value_type, value_type, bool>

        {

            friend class map<Key, T, Compare, Alloc>;

            

        protected:

            Compare comp;

            value_compare(Compare c) : comp(c) {}

            

        public:

            bool operator()(const value_type& x, const value_type& y) const

            {

                return comp(x.first, y.first);

            }

        };

        

    private:

        

       

        typedef rb_tree<key_type, value_type,

        select1st<value_type>, key_compare, Alloc> rep_type;

        rep_type t;

        

    public:

        

        typedef typename rep_type::pointer pointer;

        typedef typename rep_type::const_pointer const_pointer;

        typedef typename rep_type::reference reference;

        typedef typename rep_type::const_reference const_reference;

        typedef typename rep_type::iterator   iterator;

        typedef typename rep_type::const_iterator   const_iterator;

        typedef typename rep_type::reverse_iterator reverse_iterator;

        typedef typename rep_type::const_reverse_iterator const_reverse_iterator;

        typedef typename rep_type::size_type    size_type;

        typedef typename rep_type::difference_type difference_type;

        

        

        map() : t(Compare()){}

        explicit map(const Compare& comp) : t(comp){}

        

        //inset_unique 是不允许相同值出现的插入

        template<class InputIterator>

        map(InputIterator first, InputIterator last)

        : t(Compare()){ t.insert_unique(first, last);}

        

        template<class InputIterator>

        map(InputIterator first, InputIterator last,const Compare& comp)

        : t(comp){t.insert_unique(first, last);}

        

        map(const set<Key, Compare, Alloc>& x): t(x.t){}

        map<Key, Compare, Alloc>& operator=(const map<Key, Compare, Alloc>& x)

        {

            t = x.t;

            return *this;

        }

        

        key_compare         key_comp()      const { return t.key_comp();}

        value_compare       value_comp()    const { return t.value_compare(t.key_comp());}

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

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

        reverse_iterator    rbegin()        const { return t.rbegin();}

        reverse_iterator    rend()          const { return t.end();}

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

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

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

        void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t);}

        

        //map可以根据 键 来取 值， 如果不存在就插入一个新的 键值对

        T& operator[] (const key_type& k)

        {

            return (*((insert(value_type(k,T()))).first)).second;

        }

        

        //insert erase

        

        pair<iterator, bool> inset(const value_type& x)

        {

            pair<typename rep_type::iterator, bool> p =t.insert_unique(x);

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

        }

        

        iterator insert(iterator position, const value_type& x)

        {

            typedef typename rep_type::iterator rep_iterator;

            return t.insert_unique((rep_iterator&)position, x);

        }

        

        template<class InputIterator>

        void insert(InputIterator first, InputIterator last)

        {

            t.insert_unique(first, last);

        }

        

        void erase(iterator position)

        {

            typedef typename rep_type::iterator rep_iterator;

            t.erase((rep_iterator&)position);

        }

        

        size_type erase(const key_type& x)

        {

            return t.erase(x);

        }

        void erase(iterator first, iterator last)

        {

            typedef typename rep_type::iterator rep_iterator;

            t.erase((rep_iterator&)first, (rep_iterator&)last);

        }

        

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

        

        //

        iterator find(const key_type& x) const { return t.find(x); }

        size_type count(const key_type& x) const { return t.count(x); }

        iterator lower_bound(const key_type& x) const

        {

            return t.lower_bound(x);

        }

        iterator upper_bound(const key_type& x) const

        {

            return t.upper_bound(x);

        }

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

        {

            return t.equal_range(x);

        }

        

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

        friend bool operator<  __STL_NULL_TMPL_ARGS (const set&, const set&);

        

    };

    

    

    template<class Key, class Compare, class Alloc>

    inline bool operator==(const set<Key, Compare, Alloc>& x,

                           const set<Key, Compare, Alloc>& y)

    {

        return x.t == y.t;

    }

    

    template<class Key, class Compare, class Alloc>

    inline bool operator<(const set<Key, Compare, Alloc>& x,

                          const set<Key, Compare, Alloc>& y)

    {

        return x.t < y.t;

    }

    

    /*

        总结:

        map和set不同的是有了data这个概念，并且可以更改这个data值了

        set插入时插的就是key， map插入时插的是value(键值对)

        插入时，函数会调用keyofvalue仿函数取得value的key

        之后排序会根据key_compare(也就是模版参数中的Compare)来比较key的大小

        最后都是用key来比较的，不同的是set存的值也是key，map存的值是data。

        

    */

    

    

}

//multiset 和multimap

/*

    这两个容器和之前的基本相同，不同的就是把inset_unique改成inset_equel

    具体的底层实现在RB_tree 中已经实现了，只要调用就行了

*/