双链表实现一个类似STL的List类

#ifndef MyList_H
#define MyList_H
template<typename Object>
class MyList{
private:
    struct Node{
        Object data;
        Node *prev;
        Node *next;
        Node(const Object &d = Object(), Node *p = NULL, Node *n = NULL): data(d),prev(p),next(n){}
    };
    int theSize;
    Node *head;
    Node *tail;
    void Init(){
        theSize = 0;
        head = new Node;
        tail = new Node;
        head->next = tail;
        tail->prev = head;
    }
public:
    class const_iterator{
    protected:
        Node *current;
        const_iterator(Node *p):current(p){}
        Object& retrieve()const{
            return current->data;
        }
        friend class MyList<Object>;
    public:
        const_iterator():current(NULL){}
        const Object& operator*() const{
            return current->data;
        }
        const_iterator& operator++(){
            current = current->next;
            return *this;
        }
        const_iterator operator++(int){
            const_iterator p(current);
            current = current->next;
            return p;
        }
        bool operator==(const const_iterator& rhs) const{
            return current==rhs.current;
        }
        bool operator!=(const const_iterator& rhs)const{
            return current!=rhs.current;
        }
    };
    class iterator : public const_iterator{
    protected:
        friend class MyList<Object>;
        iterator(Node* p):const_iterator(p){}
    public:
        iterator(){}
        Object& operator*(){
            return current->data;
        }
        const Object& operator*()const{
            const_iterator::operator*();
        }
        iterator& operator++(){
            current = current->next;
            return current->data;
        }
        iterator& operator--(){
            current = current->prev;
            return *this;
        }
        iterator operator++(int){
            iterator p(current);
            current = current->next;
            return p;
        }
    };
public:
    MyList() {
        Init();
    }
    MyList(const MyList& rhs){
        Init();
        *this = rhs;
    }
    ~MyList(){
        clear();
        delete head;
        delete tail;
    }
    const MyList& operator=(const MyList &rhs){
        if(this != &rhs){
            theSize = rhs.theSize;
            clear();
            for(const_iterator it = rhs.begin(); it != rhs.end(); it++)
                push_back(*it);
        }
        return *this;
    }
    iterator begin(){
        return iterator(head->next);
    }
    const_iterator begin() const{
        return const_iterator(head->next);
    }
    iterator end(){
        return iterator(tail);
    }
    const_iterator end()const{
        return const_iterator(tail);
    }
    int size() const{
        return theSize;
    }
    bool empty()const{
        return theSize==0;
    }
    void clear(){
        while(!empty()){
            pop_front();
        }
    }
    Object& front(){
        return begin()->data;
    }
    const Object& front() const{
        return begin()->data;
    }
    Object& back(){
        return (--end())->data;
    }
    const Object& back()const{
        return (--end())->data;
    }
    void push_front(Object& obj){
        insert(begin(),obj);
    }
    void push_back(Object& obj){
        insert(end(),obj);
    }
    void pop_front(){
        erase(begin());
    }
    void pop_back(){
        erase(--end());
    }

    iterator insert(iterator it, const Object &obj){
        Node *node = new Node(obj);
        node->next = it.current;
        node->prev = it.current->prev;
        it.current->prev->next = node;
        it.current->prev = node;
        theSize++;
        iterator retVal(node);
        return retVal;
    }
    iterator erase(iterator it){
        Node *p = it.current;
        p->prev->next = p->next;
        p->next->prev = p->prev;
        iterator retVal(p->next);
        delete p;
        theSize--;
        return retVal;
    }
    iterator erase(iterator start,iterator end){
        while(start != end){
            start = erase(start);
        }
        return end;
    }
};
#endif

 

 测试：