自定义实现 C++ list

c++的list为双向环形链表，优势在于可以快速插入删除任意节点，不能像vector通过下标快速访问元素。

#ifndef TLIST_H
#define TLIST_H
#include <stdlib.h>
#include <iterator>

using namespace std;

template <class T>
class TList
{
private:
    struct node
    {
        T date;
        node* prev;
        node* next;
    };
public:
    TList():root(nullptr),length(0)
    {
        empty_initialize();
    }

    ~TList(){}

    class iterator
    {
    public:
        node *i;

        inline iterator(): i(nullptr) {}
        inline iterator(node*n) : i(n) {}
        inline iterator(const iterator &o): i(o.i){}

        inline T &operator*() const { return i->date; }
        inline T *operator->() const { return &i->date; }
        inline bool operator==(const iterator &o) const  { return i == o.i; }
        inline bool operator!=(const iterator &o) const  { return i != o.i; }
        inline bool operator<(const iterator& other) const  { return i < other.i; }
        inline bool operator<=(const iterator& other) const  { return i <= other.i; }
        inline bool operator>(const iterator& other) const  { return i > other.i; }
        inline bool operator>=(const iterator& other) const  { return i >= other.i; }
        //++i
        inline iterator &operator++() { i = i->next; return *this; }
        //i++
        inline iterator operator++(int) {
            //node *n = i; ++i; return n;
                                          iterator tmp = *this;++(*this);return tmp;}
        //--i
        inline iterator &operator--() { i = i->prev; return *this;  }
        //i--
        inline iterator operator--(int) { iterator tmp = *this;--(*this);return tmp; }

    };

    typedef std::reverse_iterator<iterator> reverse_iterator;

    iterator begin()
    {
        return root->next;
    }
    iterator end()
    {
        return root;

    }
//    iterator rbegin()
//    {
//        return iterator(--end());
//    }
//    iterator rend()
//    {
//        return iterator(begin());

//    }

    //Test whether container is empty
    bool empty()
    {
        return (length == 0);
    }
    unsigned int size()
    {
        return length;
    }
    //Resizes the container to contain sz elements.
    void resize(unsigned int nSize,T c = T());
    //Access first element
    T& front()
    {
        return *begin();
    }
    //Access last element
    T& back()
    {
        return *(--end());
    }
    //Insert element at beginning
    void push_front ( const T& x )
    {
        insert(begin(), x);
    }

    //Delete first element
    void pop_front ()
    {
        erase(begin());
    }
    //Insert element at ending

    void push_back(const T& x )
    {
        insert(end(), x);

    }
    //Delete last element
    void pop_back ()
    {
        erase(--end());

    }
    //Insert elements
    iterator insert(iterator position, const T& x )
    {
            length++;
            node* pNode = createNode();
            pNode->date = x;
            pNode->next = position.i;
            pNode->prev = position.i->prev;
            position.i->prev->next = pNode;
            position.i->prev = pNode;
            return pNode;
    }
    //Erase elements
    iterator erase( iterator position )
    {
        if(length == 0)
            return NULL;
        length--;
        position.i->prev->next = position.i->next;
        position.i->next->prev = position.i->prev;
        iterator ret = position.i->next;
        delete position.i;
        return ret;

    }
    //Clear content
    void clear()
    {
        iterator currNode = begin();
        while ( currNode != end())
        {
            length--;
            node* temp = currNode.i;
            currNode++;
            delete temp;

        }
        root->next = root;
        root->prev = root;

    }



private:
    int length;
    node* root;

private:
    node* createNode()
    {
        node* pNode = new node();
        return pNode;

    }
    void empty_initialize()
    {
        root = createNode();
        root->next = root;
        root->prev = root;

    }

};


#endif // TLIST_H