(C++ STL)list的实现

#include <iostream>
using namespace std;
//採用迭代器和空间配置器所实现的双向链表的基本功能
template<class _Ty,class _A = allocator<_Ty> >
//定义模板类
class list
//list类
{
public:
    typedef size_t size_type;
    //类型重定义
protected:
    struct _Node;
    //结构体_Node
    friend struct _Node;
    //友元
    typedef _Node* _Nodeptr;
    //类型重定义
    struct _Node
    //结构体定义
    {
        _Nodeptr _Next,_Prev;
        _Ty _Value;
    };
protected:
    _A allocator;
    _Nodeptr _Head;
    size_type _Size;
public:
    typedef list<_Ty,_A> _Myt;
    typedef _A allocator_type;
    //该类型是模板參数A的同义词
    typedef size_t size_type;
    //正整数类型
    typedef ptrdiff_t difference_type;
    //整数类型
    typedef _Ty* pointer;
    //指向_Ty的指针
    typedef const _Ty* const_pointer;
    //指向_Ty的常量指针
    typedef _Ty& reference;
    //_Ty的引用
    typedef const _Ty& const_reference;
    //_Ty的常量引用
    typedef _Ty value_type;
    //对象类型_Ty
    class iterator;
    //訪问list的迭代器
    class const_iterator;
    //訪问list的常量迭代器
    friend class const_iterator;
    //友元
    class const_iterator : public _Bidit<_Ty, difference_type>
    //继承
    {
    public:
        //共同拥有成员
        _Nodeptr _Mynode() const
        //指向当前结点
        {
            return (_Ptr);
        }
        const_iterator()
        //默认构造函数
        {}
        const_iterator(_Nodeptr _P):_Ptr(_P)
        //參数为指针的构造函数
        {}
        const_iterator(const iterator& _X):_Ptr(_X._Ptr)
        //參数为訪问list的常量迭代器的构造函数
        {}
        const_reference operator*() const
        //获取当前_Ty的常量的值
        {
            return _Ptr->_Value;
        }
        const_pointer operator->() const
        //?
        {
            return (&**this);
        }
        const_iterator& operator++()
        //前置++的引用
        {
            _Ptr = _Ptr->_Next;
            return (*this);
        }
        const_iterator operator++(int)
        //后置++的引用
        {
            const_iterator _Tmp = *this;
            ++*this;
            return (_Tmp);
        }
        const_iterator& operator--()
        //前置--的引用
        {
            _Ptr = _Ptr->_Prev;
            return (*this);
        }
        const_iterator operator--(int)
        //后置--的引用
        {
            const_iterator _Tmp = *this;
            --*this;
            return (_Tmp);
        }
        bool operator==(const const_iterator& _X) const
        //推断是否相等
        {
            return (_Ptr == _X._Ptr);
        }
        bool operator!=(const const_iterator& _X) const
        //推断是否不等
        {
            return (!(*this == _X));
        }
    protected:
        //保护成员
        _Nodeptr _Ptr;
    };
    friend class iterator;
    //友元
    class iterator : public const_iterator
    //继承
    {
    public:
        iterator()
        //默认构造函数
        {}
        iterator(_Nodeptr _P): const_iterator(_P)
        //參数为指针的构造函数
        {}
        reference operator*() const
        //获取当前_Ty的值
        {
            return _Ptr->_Value;
        }
        _Ty* operator->() const
        //?
        {
            return (&**this);
        }
        iterator& operator++()
        //前置++的引用
        {
            _Ptr = _Ptr->_Next;
            return (*this);
        }
        iterator operator++(int)
        //后置++的引用
        {
            iterator _Tmp = *this;
            ++*this;
            return (_Tmp);
        }
        iterator& operator--()
        //前置--的引用
        {
            _Ptr = _Ptr->_Prev;
            return (*this);
        }
        iterator operator--(int)
        //后置--的引用
        {
            iterator _Tmp = *this;
            --*this;
            return (_Tmp);
        }
        bool operator==(const iterator& _X) const
        //推断是否相等
        {
            return (_Ptr == _X._Ptr);
        }
        bool operator!=(const iterator& _X) const
        //推断是否不等
        {
            return (!(*this == _X));
        }
    };
public:
    _Nodeptr _Buynode(_Nodeptr _Narg = 0, _Nodeptr _Parg = 0)
    //购买结点
    {
        _Nodeptr _S = (_Nodeptr)allocator._Charalloc(   //开辟空间
            1 * sizeof (_Node));
        _S->_Next = _Narg != 0 ? _Narg : _S;;
        _S->_Prev = _Parg != 0 ? _Parg : _S;
        return (_S);
    }
    void _Freenode(_Nodeptr _S)
    //释放空间
    {
        allocator.deallocate(_S, 1);
    }
    void _Splice(iterator _P, _Myt& _X, iterator _F, iterator _L)
    //拼接
    {
        if (allocator == _X.allocator)                 //将两个拼接到一起，_X清空
        {
            (_L._Mynode())->_Prev->_Next = _P._Mynode();
            (_F._Mynode())->_Prev->_Next = _L._Mynode();
            (_P._Mynode())->_Prev->_Next = _F._Mynode();
            _Nodeptr _S = (_P._Mynode())->_Prev;
            (_P._Mynode())->_Prev =(_L._Mynode())->_Prev;
            (_L._Mynode())->_Prev =(_F._Mynode())->_Prev;
            (_F._Mynode())->_Prev = _S;
        }
        else                                          //将_X中的链表数值加入到_P中，_X清空
        {
            insert(_P, _F, _L);
            _X.erase(_F, _L);
        }
    }
    void _Xran() const
    //抛出异常
    {
        _THROW(out_of_range, "invalid list<T> subscript");
    }
public:
    size_type size() const
    //长度
    {
        return (_Size);
    }
    bool empty() const
    //判空
    {
        return (size() == 0);
    }
    _A get_allocator() const
    //返回空间配置器
    {
        return (allocator);
    }
    void resize(size_type _N, _Ty _X = _Ty())
    //又一次定义链表长度
    {
        if (size() < _N)
        {
            insert(end(), _N - size(), _X);
        }
        else
        {
            while (_N < size())
            {
                pop_back();
            }
        }
    }
    size_type max_size() const
    //返回链表最大可能长度
    {
        return (allocator.max_size());
    }
    reference front()
    //返回第一个元素的引用
    {
        return (*begin());
    }
    const_reference front() const
    //返回第一个元素的常量引用
    {
        return (*begin());
    }
    reference back()
    //返回最后一元素的引用
    {
        return (*(--end()));
    }
    const_reference back() const
    //返回最后一元素的常量引用
    {
        return (*(--end()));
    }
    _Myt& operator=(const _Myt& _X)
    //运算符构造函数
    {
        if (this != &_X)
        {
            iterator _F1 = begin();
            iterator _L1 = end();
            const_iterator _F2 = _X.begin();
            const_iterator _L2 = _X.end();
            for (; _F1 != _L1 && _F2 != _L2; ++_F1, ++_F2)
            {
                *_F1 = *_F2;
            }
            erase(_F1, _L1);
            insert(_L1, _F2, _L2);
        }
        return (*this);
    }
public:
    explicit list():_Head(_Buynode()), _Size(0)
    //空链表
    {}
    explicit list(const _Ty& _V):_Head(_Buynode()), _Size(0)
    //建一个含_V个默认值是0的元素的链表
    {
        insert(begin(),_V,0);
    }
    explicit list(size_type _N, const _Ty& _V):_Head(_Buynode()), _Size(0)
    //建一个含_V个元素的链表。值都是_N
    {
        insert(begin(),_N, _V);
    }
    list(const _Myt& _X): _Head(_Buynode()), _Size(0)
    //建一个_X的copy链表
    {
        insert(begin(), _X.begin(), _X.end());
    }
    list(const _Ty *_F, const _Ty *_L): _Head(_Buynode()), _Size(0)
    //一个区域的元素[_First, _Last)。
    {
        insert(begin(), _F, _L);
    }
    typedef const_iterator _It;
    list(_It _F, _It _L):_Head(_Buynode()), _Size(0)
    //常量迭代器
    {
        insert(begin(), _F, _L);
    }
    iterator begin()
    //迭代器第一个节点
    {
        return iterator(_Head->_Next);
    }
    const_iterator begin() const
    //常量迭代器第一个节点
    {
        return (const_iterator(_Head->_Next));
    }
    iterator end()
    //返回最后一个元素的下一位置的指针
    {
        return iterator(_Head);
    }
    const_iterator end() const
    //返回最后一个元素的下一位置的指针
    {
        return (const_iterator(_Head));
    }
    iterator insert(iterator _P,const _Ty& _X)
    //在_P之前插入结点
    {
        _Nodeptr _S = _P._Mynode();
        _S->_Prev = _Buynode(_S,_S->_Prev);
        _S = _S->_Prev;
        _S->_Prev->_Next = _S;
        _S->_Value = _X;
        ++_Size;
        return (iterator(_S));
    }
    void insert(iterator _P,size_type _M, const _Ty& _X)
    //在_P之前插入_M个_X结点
    {
        for(;0 < _M;--_M)
        {
            insert(_P,_X);
        }
    }
    void insert(iterator _P, const _Ty *_F, const _Ty *_L)
    //在_P之前插入_F到_L的结点
    {
        for (; _F != _L; ++_F)
        {
            insert(_P, *_F);
        }
    }
    typedef const_iterator _It;
    void insert(iterator _P, _It _F, _It _L)
    //在_P之前插入迭代器_F到_L的结点
    {
        for (; _F != _L; ++_F)
        {
            insert(_P, *_F);
        }
    }
    void push_front(const _Ty& _X)
    //添加一元素到链表头
    {
        insert(begin(), _X);
    }
    void pop_front()
    //删除链表头的一元素
    {
        erase(begin());
    }
    void push_back(const _Ty& _X)
    //添加一元素到链表尾
    {
        insert(end(), _X);
    }
    void pop_back()
    //删除链表尾的一个元素
    {
        erase(--end());
    }
    void assign(size_type _N, const _Ty& _X)
    //分配值
    {
        erase(begin(),end());
        insert(begin(),_N, _X);
    }
    iterator erase(iterator _P)
    //删除_P元素
    {
        _Nodeptr _S = (_P++)._Mynode();
        _S->_Prev->_Next = _S->_Next;
        _S->_Next->_Prev = _S->_Prev;
        _Freenode(_S);
        --_Size;
        return (_P);
    }
    iterator erase(iterator _F, iterator _L)
    //删除_F到_L区域的元素
    {
        while (_F != _L)
        {
            erase(_F++);
        }
        return (_F);
    }
    void clear()
    //删除全部元素
    {
        erase(begin(),end());
    }
    void show()
    //STL源代码中不存在的函数，自己加的，为了使得測试更方便
    {
        _Nodeptr _P = _Head->_Next;
        while(_P != _Head)
        {
            cout<<_P->_Value<<"-->";
            _P = _P->_Next;
        }
        cout<<"Over"<<endl;
    }
    ~list()
    //析构函数
    {
        erase(begin(),end());
        _Freenode(_Head);
        _Head = 0, _Size = 0;
    }
public:
    void swap(_Myt& _X)
    //交换两个链表
    {
        if (allocator == _X.allocator)
        //若空间配置器同样，则仅仅需交换头结点和大小
        {
            std::swap(_Head, _X._Head);
            std::swap(_Size, _X._Size);
        }
        else
        //否则将链表分别拼接到对方空间中
        {
            iterator _P = begin();
            splice(_P, _X);
            _X.splice(_X.begin(), *this, _P, end());
        }
    }
    friend void swap(_Myt& _X, _Myt& _Y)
    //交换两个链表
    {
        _X.swap(_Y);
    }
    void splice(iterator _P, _Myt& _X)
    //对两个链表进行拼接
    {
        if (!_X.empty())
        {
            _Splice(_P, _X, _X.begin(), _X.end());
            _Size += _X._Size;
            _X._Size = 0;
        }
    }
    void splice(iterator _P, _Myt& _X, iterator _F)
    //对两个链表进行拼接
    {
        iterator _L = _F;
        if (_P != _F && _P != ++_L)
        {
            _Splice(_P, _X, _F, _L);
            ++_Size;
            --_X._Size;
        }
    }
    void splice(iterator _P, _Myt& _X, iterator _F, iterator _L)
    //对两个链表进行拼接
    {
        if (_F != _L)
        {
            if (&_X != this)
            {
                difference_type _N = 0;
                _Distance(_F, _L, _N);
                _Size += _N;
                _X._Size -= _N;
            }
            _Splice(_P, _X, _F, _L);
        }
    }
    void remove(const _Ty& _V)
    //从链表中删除全部值为_V的元素
    {
        iterator _L = end();
        for (iterator _F = begin(); _F != _L; )
        {
            if (*_F == _V)
            {
                erase(_F++);
            }
            else
            {
                ++_F;
            }
        }
    }
    void unique()
    //删除全部反复的元素，以建立一个具有唯一元素值的链表，
    //即链表中不会有反复元素
    {
        iterator _F = begin(), _L = end();
        if (_F != _L)
        {
            for (iterator _M = _F; ++_M != _L; _M = _F)
            {
                if (*_F == *_M)
                {
                    erase(_M);
                }
                else
                {
                    _F = _M;
                }
            }
        }
    }
    void merge(_Myt& _X)
    //把当前链表*this和x合并，合并后x为空。
    //把x中的元素插入到当前链表中。不同意两个链表同样
    {
        if (&_X != this)
        {
            iterator _F1 = begin(), _L1 = end();
            iterator _F2 = _X.begin(), _L2 = _X.end();
            while (_F1 != _L1 && _F2 != _L2)
            {
                if (*_F2 < *_F1)
                {
                    iterator _Mid2 = _F2;
                    _Splice(_F1, _X, _F2, ++_Mid2);
                    _F2 = _Mid2;
                }
                else
                {
                    ++_F1;
                }
            }
            if (_F2 != _L2)
            {
                _Splice(_L1, _X, _F2, _L2);
            }
            _Size += _X._Size;
            _X._Size = 0;
        }
    }
    void reverse()
    //反转链表中的元素排序
    {
        if (2 <= size())
        {
            iterator _L = end();
            for (iterator _F = ++begin(); _F != _L; )
            {
                iterator _M = _F;
                _Splice(begin(), *this, _M, ++_F);
            }
        }
    }
    void sort()
    //依据默认条件对链表进行排序？
    {
        if (2 <= size())
        {
            const size_t _MAXN = 15;
            _Myt _X, _A[_MAXN + 1];
            size_t _N = 0;
            while (!empty())
            {
                _X.splice(_X.begin(), *this, begin());
                size_t _I;
                for (_I = 0; _I < _N && !_A[_I].empty(); ++_I)
                {
                    _A[_I].merge(_X);
                    _A[_I].swap(_X);
                }
                if (_I == _MAXN)
                {
                    _A[_I].merge(_X);
                }
                else
                {
                    _A[_I].swap(_X);
                    if (_I == _N)
                    {
                        ++_N;
                    }
                }
            }
            while (0 < _N)
            {
                merge(_A[--_N]);
            }
        }
    }
};
template<class _Ty, class _A> inline
//模板类推断是否相等
bool operator==(const list<_Ty, _A>& _X,
                const list<_Ty, _A>& _Y)
{
    return (_X.size() == _Y.size()
         && equal(_X.begin(), _X.end(), _Y.begin()));
}
template<class _Ty, class _A> inline
//模板类推断是否不等
bool operator!=(const list<_Ty, _A>& _X,
                const list<_Ty, _A>& _Y)
{
    return (!(_X == _Y));
}
template<class _Ty, class _A> inline
//模板类比較链表的大小
bool operator<(const list<_Ty, _A>& _X,
               const list<_Ty, _A>& _Y)
{
    return (lexicographical_compare(_X.begin(), _X.end(),
         _Y.begin(), _Y.end()));
}
template<class _Ty, class _A> inline
//模板类比較链表的大小_Y < _X
bool operator>(const list<_Ty, _A>& _X,
               const list<_Ty, _A>& _Y)
{
    return (_Y < _X);
}
template<class _Ty, class _A> inline
//模板类比較链表的大小!(_Y < _X)
bool operator<=(const list<_Ty, _A>& _X,
                const list<_Ty, _A>& _Y)
{
    return (!(_Y < _X));
}
template<class _Ty, class _A> inline
//模板类比較链表的大小!(_X < _Y)
bool operator>=(const list<_Ty, _A>& _X,
                const list<_Ty, _A>& _Y)
{
    return (!(_X < _Y));
}  

void main()
{
    list<int> c0;                         //空链表
    list<int> c1(3);                      //建一个含三个默认值是0的元素的链表
    list<int> c2(c1);                     //建一个c1的copy链表
    list<int> c3(c1.begin(),c1.end());    //含c1一个区域的元素[_First, _Last)。
    int ar[5] = {2,3,4,5,6};
    list<int> itlist(ar,ar+5);            //用数组赋值
    list<int> mylist(3,2);                //建一个含三个元素的链表，值都是2
    mylist.show();  

    list<int> youlist(3,3);
    youlist.show();  

    swap(mylist, youlist);                //交换两个链表
    mylist.show();
    youlist.show();  

    mylist.swap(youlist);
    mylist.show();
    youlist.show();  

    list<int>::iterator i1 = itlist.begin();
    itlist.splice(i1,mylist);              //对两个链表进行结合
    itlist.show();  

    itlist.remove(3);
    itlist.show();  

    itlist.unique();
    itlist.show();  

    itlist.merge(mylist);
    itlist.show();
    mylist.show();  

    itlist.reverse();
    itlist.show();  

    itlist.sort();
    itlist.show();  

    cout<<operator<(itlist,mylist)<<endl;
    cout<<operator>(itlist,mylist)<<endl;
}