STL-链表

template<class T, class A = allocator<T> >
class list {
public:
    // 类型定义
    typedef A allocator_type;
    typedef A::size_type size_type;
    typedef A::difference_type difference_type;
    typedef A::reference reference;
    typedef A::const_reference const_reference;
    typedef A::value_type value_type;
    typedef T0 iterator;
    typedef T1 const_iterator;
    typedef reverse_bidirectional_iterator<iterator,
        value_type, reference, A::pointer,
        difference_type> reverse_iterator;
    typedef reverse_bidirectional_iterator<const_iterator,
        value_type, const_reference, A::const_pointer,
        difference_type> const_reverse_iterator;

    //构造函数
    explicit list(const A& al = A());
    explicit list(size_type n, const T& v = T(), const A& al = A());
    list(const list& x);
    list(const_iterator first, const_iterator last,
        const A& al = A());

    //获取第一个元素的迭代器
    iterator begin();
    const_iterator begin() const;
    //获取尾后元素的迭代
    iterator end();
    iterator end() const;

    //反向第一个元素的迭代（最后一个元素）
    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;

    //反向尾后迭代器元素（第一个的前一个）
    reverse_iterator rend();
    const_reverse_iterator rend() const;

    //重新分配list大小大小
    void resize(size_type n, T x = T());

    //获取list中元素大小
    size_type size() const;

    //获取最大可存元素大小
    size_type max_size() const;

    //返回元素是否为空
    bool empty() const;
    //获取分配器
    A get_allocator() const;

    //返回第一个元素的引用
    reference front();
    const_reference front() const;

    //返回最后一个元素的引用
    reference back();
    const_reference back() const;

    //从头部插入或者删除一个元素
    void push_front(const T& x);
    void pop_front();

    //从尾部插入或者删除一个元素
    void push_back(const T& x);
    void pop_back();

    //清空列表并复制从新集合中从开始到结束复制元素到列表
    void assign(const_iterator first, const_iterator last);
    //清空列表复制n个元素T到列表中
    void assign(size_type n, const T& x = T());

    //在it位置插入元素T或者序列，
    iterator insert(iterator it, const T& x = T());
    void insert(iterator it, size_type n, const T& x);
    void insert(iterator it,
        const_iterator first, const_iterator last);
    void insert(iterator it,
        const T *first, const T *last);

    //删除元素
    iterator erase(iterator it);
    iterator erase(iterator first, iterator last);

    //清空列表
    void clear();

    //交换列表元素
    void swap(list x);

    //对链表进行结合结合后源链表为空
    void splice(iterator it, list& x);
    void splice(iterator it, list& x, iterator first);
    void splice(iterator it, list& x, iterator first, iterator last);

    //删除链表中与X匹配的元素
    void remove(const T& x);
    //删除满足条件的元素
    void remove_if(binder2nd<not_equal_to<T> > pr);

    //删除相邻重复元素
    void unique();
    //删除重复满足条件的元素
    void unique(not_equal_to<T> pr);
    //合并两个有序列表
    void merge(list& x);
    //根据指定谓词合并有序表
    void merge(list& x, greater<T> pr);

    //对链表进行排序
    void sort();
    template<class Pred>
    void sort(greater<T> pr);

    //反转链表
    void reverse();
protected:
    A allocator;
};