仿双向链表实现(部分功能)

///////////////////////////////
//标准C++库
#include <iostream>
#include <CString>
////////////////////////////////
//双向链表模板类
template <typename T>
class MyList
{
public:
    //链表节点
    class Node
    {
    //构造，析构
    public:
        Node(T data, Node* next, Node* prev):m_data(data),m_next(next),m_prev(prev){}
        ~Node(){}
    public:
    //属性
    public:
        T m_data;
        Node* m_next;
        Node* m_prev;
    };
    ///////////////////////////////////
    //迭代器
    class Iterator
    {
    public:
        //构造，析构
        Iterator(Node* head=NULL,Node* tail=NULL,Node* node=NULL):m_head(head),m_tail(tail),m_node(node){}
        ~Iterator(){}
        //操作符重载
        //前++
        Iterator& operator++()
        {
            if(m_node->m_next)
            {
                m_node = m_node->m_next;    
            }
            else
                m_node = m_tail;
            return *this;
        }
        //后++
        const Iterator& operator++(int)
        {
            Iterator* old = this;
            if(m_node)
                m_node = m_node->m_next;
            else
                m_node = m_head;
            return *old;
        }
        //前--
        Iterator& operator--()
        {
            if(m_node->m_prev)
            {
                m_node = m_node->m_prev;
            }
            else 
                m_node = m_head;
            return *this;
        }
        //后--
        const Iterator& operator--(int)
        {
            Iterator *old = this;
            --(*this);
            return *old;
        }
        //赋值=
        Iterator& operator=(const Iterator& it)
        {
            if(this!=&it)
            {
                m_node=it.m_node;
            }
            return *this;
        }
        //判等=
        bool operator==(const Iterator& it)const
        {
            return m_node == it.m_node;
        }
        bool operator!=(const Iterator& it)const
        {
            return !(*this==it);
        }
        T& operator *()
        {
            return m_node->m_data;
        }

    
    private:
        Node *m_head;
        Node *m_tail;
        Node *m_node;
        friend class MyList;
    };
    ////////////////////////////////////
    //链表实现
    //构造，析构，拷贝构造，拷贝赋值
public:
    MyList():m_head(NULL),m_tail(NULL)
    {

    }
    ~MyList()
    {
        while(m_head)
        {
            Node * node = m_head;
            m_head = m_head->m_next;
            delete node;
        }
    }
    MyList(const MyList& myList):m_head(NULL),m_tail(NULL)
    {
        for(Node *node = myList.m_head;node;node = node->m_next)
        {
            push_back(node->m_data);
        }
    }
    MyList& operator=(const MyList& myList)
    {
        if(this!=&myList)
        {
            if(!empty())
                clear();
            for(Node* node = myList.m_head;node;node = node->m_next)
            {
                push_back(node->m_data);
            }
        }
        return *this;
    }
    //清空
    void clear()
    {
        for(Node* next; m_head;m_head=next )
        {
            next = m_head->m_next;
            delete m_head;
        }
        m_head=NULL;
        m_tail=NULL;
    }
    //判空
    bool empty()
    {
        if(m_head)
            return true;
        return false;
    }
    //获取首元素
    T& front()
    {
        if(m_head)
            return m_head->m_data;
                        
    }
    //尾端压入
    void push_back(T data)
    {
        m_tail = new Node(data,NULL,m_tail);
        if(m_head==NULL)
        {
            m_head = m_tail;
        }
        else
        {
            m_tail->m_prev->m_next=m_tail;
        }
    }
    //尾端弹出
    void pop_back()
    {
        if(m_head==NULL)
        {
            printf("链表下溢\n");
            return;
        }
        Node * tail = m_tail;
        m_tail = m_tail->m_prev;
        if(m_tail)
            m_tail->m_next = NULL;
        else
            m_head = NULL;
        delete tail;
    }
    //首尾迭代器
    Iterator begin (void) {
        return Iterator (m_head, m_tail, m_head);
    }
    Iterator end (void) {
            return Iterator (m_head, m_tail);
    }


private:
    Node *m_head;
    Node *m_tail;
};
//打印
template <typename T,typename STL>
void Print(T &it,STL& stl)
{
    it = stl.begin();
    for(;it!=stl.end();it++)
    {
        std::cout << *it << ' ';
    }
    std::cout << std::endl;
}
//测试用例
int main(int argc, char* argv[])
{
    MyList<int> list;
    list.push_back(5);
    MyList<int>::Iterator it;
    Print(it,list);
    list.push_back(6);
    list.push_back(7);
    list.push_back(8);
    list.push_back(9);
    Print(it,list);
    list.clear();
    Print(it,list);
    MyList<int> list2;
    list2.push_back(10);
    list2.push_back(11);
    list = list2;
    Print(it,list);
    list.pop_back();
    Print(it,list);
    return 0;
}