模板链表 内有迭代器（代码）

#pragma once

#include "stdafx.h"
#include "MyList.h"
#include <exception>
using namespace std;


template<typename T>
class CMyList
{
private:
    //结点
    struct MyNode
    {
        MyNode(T nVal) :m_nData(nVal) {   }
        T m_nData;
        MyNode* m_pPreNode = nullptr; //前驱结点指针
        MyNode* m_pNextNode = nullptr; //后继结点指针
    };
public:
    /** 迭代器 **/
    /************************************************************************************************/
    class Iterator
    {
        friend class CMyList;
    public:
        Iterator(MyNode* pos) :m_pos(pos)
        {
        }
        Iterator& operator++() //前++
        {
            /*
            *    m_pos
                  |/
            *    2 3 4 
              ++操作,从当前节点3的位置,向后移,即移动到3的后继结点4
            *      m_pos
                    |/
            *    2 3 4
            */
            m_pos = m_pos->m_pNextNode;
            return *this;
        }
        Iterator operator++(int) //后++
        {
            m_pos = m_pos->m_pNextNode;
            return Iterator(m_pos->m_pPreNode);
        }
        Iterator& operator--()//前--
        {
            m_pos = m_pos->m_pPreNode;
            return *this;
        }
        Iterator operator--(int)
        {
            m_pos = m_pos->m_pPreNode;
            return Iterator(m_pos->m_pNextNode);
        }
        bool operator==(Iterator& itr)
        {
            return (m_pos == itr.m_pos);
        }
        bool operator!=(Iterator& itr)
        {
            return !(*this == itr);
        }
        T& operator*()
        {
            return m_pos->m_nData;
        }
        //这里有问题,int不能用
        T* operator->()
        {
            return &m_pos->m_nData;
        }
    private:
        MyNode* m_pos = nullptr; //元素位置
    };
    /**********************************************************************************************************/
public:
    Iterator begin(); //返回指向第一个元素的迭代器
    Iterator end();//返回指向最后一个元素后面位置的迭代器

public:
    CMyList();
    ~CMyList();

public:
    /*  增加  */
    void push_front(const T& nVal);  //头部插入数据
    void push_back(const T& nVal);    //尾部插入数据
    void insert(Iterator itr, const T& nVal); //指定位置插入数据


    /*  删除  */
    void pop_front(); //删除头结点
    void pop_back(); //删除尾结点
    void erase(Iterator itr); //删除指定位置的节点


    /* 访问 */
    T& front(); //访问头结点
    T& back();  //访问尾结点


    /* 其它 */
    int size(); //获取链表中元素的个数
    void clear(); //清空链表
    /*从小排序*/
    void BeforSmallsort();
    /*从大排序*/
    void BeforBigsort();

    bool Empty();

private:
    MyNode* m_pHeadNode = new MyNode(0); //头结点哨兵
    MyNode* m_pTailNode = new MyNode(0); //头结点哨兵
};

/*******************************************************************************************************/
// MyList.cpp : 定义控制台应用程序的入口点。

template<typename T>
int CMyList<T>::size()
{
    int i = 0;
    MyNode* pA = m_pHeadNode->m_pNextNode;
    while (pA != m_pTailNode)
    {
        i++;
        pA = pA->m_pNextNode;
    }
    return i;
}

    /*从小排序*/
template<typename T>
void CMyList<T>::BeforSmallsort()
{
    MyNode *PA = m_pHeadNode;

    MyNode *PB = PA->m_pNextNode;

    if (PA->m_pNextNode == m_pTailNode || PB->m_pNextNode == m_pTailNode)
    {
        return;
    }
    int size = this->size();
    for (int i = 0; i < size - 1; i++)
    {
        PA = PA->m_pNextNode;

        PB = PA->m_pNextNode;
        while (PB != m_pTailNode)
        {
            if (PA->m_nData > PB->m_nData)
            {
                int temp = 0;
                temp = PA->m_nData;
                PA->m_nData = PB->m_nData;
                PB->m_nData = temp;

            }
            PB = PB->m_pNextNode;
        }
    }

}

/*从大排序*/
template<typename T>
void CMyList<T>::BeforBigsort()
{
    MyNode *PA = m_pHeadNode;

    MyNode *PB = PA->m_pNextNode;

    if (PA->m_pNextNode == m_pTailNode || PB ->m_pNextNode == m_pTailNode)
    {
        return;
    }
    int size = this->size();
    for (int i = 0; i < size - 1; i++)
    {

        PA = PA->m_pNextNode;

        PB = PA->m_pNextNode;
        while (PB != m_pTailNode)
        {
            if (PA->m_nData < PB->m_nData)
            {
                int temp = 0;
                temp = PA->m_nData;
                PA->m_nData = PB->m_nData;
                PB->m_nData = temp;

            }
            PB = PB->m_pNextNode;
        }
    }
}




//
template<typename T>
typename CMyList<T>::Iterator CMyList<T>::begin()
{
    return Iterator(m_pHeadNode->m_pNextNode);
}
template<typename T>
typename CMyList<T>::Iterator CMyList<T>::end()
{
    return Iterator(m_pTailNode);
}

template<typename T>
CMyList<T>::CMyList()
{
    //当链表为空的时候,头部哨兵和尾部哨兵互为前驱和后继
    m_pHeadNode->m_pNextNode = m_pTailNode;
    m_pTailNode->m_pPreNode = m_pHeadNode;
}

template<typename T>
CMyList<T>::~CMyList()
{
}

template<typename T>
void CMyList<T>::push_front(const T& nVal)
{
    //创建新结点
    MyNode* pD = new MyNode(nVal);

    /*
       head (0) A  B C (0)

       head (0)[D] A B C (0)
    */ 
    MyNode* pA = m_pHeadNode->m_pNextNode;

    m_pHeadNode->m_pNextNode = pD;
    pA->m_pPreNode = pD;

    pD->m_pPreNode = m_pHeadNode;
    pD->m_pNextNode = pA;
}
template<typename T>
void CMyList<T>::push_back(const T& nVal)
{
    //创建新结点
    MyNode* pD = new MyNode(nVal);
    //遍历获得尾结点
    MyNode* pC = m_pTailNode->m_pPreNode;

    pC->m_pNextNode = pD;
    m_pTailNode->m_pPreNode = pD;

    pD->m_pPreNode = pC;
    pD->m_pNextNode = m_pTailNode;
}
template<typename T>
void CMyList<T>::insert(Iterator itr, const T& nVal)
{
    //创建新结点
    MyNode* pD = new MyNode(nVal);

    /*      D  itr
    head A      B  C
    head A  [D] B  C 
    */
    MyNode* pB = itr.m_pos;  //获取指定位置节点
    MyNode* pA = pB->m_pPreNode; //获取指定位置的前驱结点, 4

    pA->m_pNextNode = pD;

    pB->m_pPreNode = pD;

    pD->m_pPreNode = pA;
    pD->m_pNextNode = pB;
}
template<typename T>
void CMyList<T>::pop_front()
{
    /*
    链表为空,只剩下两个哨兵
    head (0)(0)
    */
    if (m_pHeadNode->m_pNextNode == m_pTailNode)
    {
        return ;
    }

    /*删除A
    head (0) A B (0)
    head (0)   B (0)
    */
    MyNode* pA = m_pHeadNode->m_pNextNode;
    MyNode* pB = pA->m_pNextNode;

    m_pHeadNode->m_pNextNode = pA->m_pNextNode;
    pB->m_pPreNode = m_pHeadNode;

    delete pA;
}
template<typename T>
void CMyList<T>::pop_back()
{
    /*
    链表为空,只剩下两个哨兵
    head (0)(0)
    */
    if (m_pHeadNode->m_pNextNode == m_pTailNode)
    {
        return;
    }

    /*删除B
    head (0) A B (0)
    head (0) A   (0)
    */
    MyNode* pB = m_pTailNode->m_pPreNode;
    MyNode* pA = pB->m_pPreNode;

    m_pTailNode->m_pPreNode = pA;
    pA->m_pNextNode = m_pTailNode;

    delete pB;
}
template<typename T>
void CMyList<T>::erase(Iterator itr)
{
    /*
    * 如果是哨兵,则不删除
    */
    if (itr.m_pos == m_pHeadNode || itr.m_pos == m_pTailNode)
    {
        throw exception("迭代器超出范围");
    }

    /*删除B
    head (0) A B C(0)
    head (0) A   C(0)
    */
    MyNode* pB = itr.m_pos;
    MyNode* pA = pB->m_pPreNode;
    MyNode* pC = pB->m_pNextNode;

    pA->m_pNextNode = pC;
    pC->m_pPreNode = pA;

    delete pB;
}

template<typename T>
T& CMyList<T>::front()
{
    if (Empty())
    {
        throw exception("链表为空");
    }

    return m_pHeadNode->m_pNextNode->m_nData;
}

template<typename T>
T& CMyList<T>::back()
{
    if (Empty())
    {
        throw exception("链表为空");
    }

    return m_pTailNode->m_pPreNode->m_nData;

}



template<typename T>
void CMyList<T>::clear()
{
    while (!Empty())
    {
        pop_front();
    }
}

template<typename T>
bool CMyList<T>::Empty()
{    
    /*
     链表为空,只剩下两个哨兵
     head (0)(0)
     */
    if (m_pHeadNode->m_pNextNode == m_pTailNode)
    {
        return true;
    }
    return false;
}