stl_set

//不允许相同值得set
//#include<rb_tree.h>
//#include<stl_function.h>

template<class key , class Compare = less<key>>//默认状态下按递增排序
class set
{
public:
    typedef key key_type;
    typedef key value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
private:
    typedef rb_tree<key_type, value_type, identity<value_type>, key_compare> rep_type;
    rep_type t;
public:
    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::size_type size_type;
    typedef typename rep_type::difference_type difference_type;

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

    template<class I>
    set(I first, I last） : t(Compare())
    {
        t.insert_unique(first, last);
    }

    template<class I>
    set(I first, I last,const Compare& cmp） : t(cmp)
    {
        t.insert_unique(first, last);
    }

    set(const set<key, Compare >& x) :t(x.t){}
    set<key, Compare >&operator =(const set<key, Compare>& x)
    {
        t = x.t;
        return *this;
    }

    key_compare key_comp()const
    {
        return t.key_comp();
    }
    value_compare key_comp()const
    {
        return key_comp();
    }
    iterator begin() const
    {
        return t.begin();
    }

    iterator end() cosnt
    {
        return t.end();
    }
    bool empty() const 
    {
        return t.empty();
    }

    size_type size() cosnt
    {
        return t.size();
    }
    size_type max_size() cosnt
    {
        return t.max_size();
    }

    typedef pair<iterator, bool> pair_iteartor_bool;
    pair<iterator, bool > insert(const value_typed& 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 I>
    void insert(I first, I last)
    {
        t.insert_unique(first, last);
    }
    size_type erase(const key_type& x)
    {
        return t.erase(x);
    }
    void clear()
    {
        t.clear();
    }

};