双向循环链表的C++实现

使用C++实现了一个双向循环链表，来看代码:

#pragma once
#include "assert.h"

struct Node
{
	Node(int val) :m_val(val) {}
	Node() { }

	int   m_val;            //数据
	Node* m_prev = nullptr; //前驱结点的地址
	Node* m_next = nullptr; //后继结点的地址
};

class CIterator
{
public:
	CIterator(Node *pCur = nullptr) : m_pCur(pCur) {}
	CIterator(const CIterator &) = default;
	CIterator(CIterator &&) = default;
	CIterator &operator=(const CIterator &) = default;
	~CIterator() = default;

	int &operator*()
	{
		return(m_pCur->m_val);
	}
	// 前置++
	CIterator& operator++()
	{
		if (m_pCur->m_next != nullptr)
		{
			m_pCur = m_pCur->m_next;
			return(*this);
		}
		
	}
	// 后置++
	CIterator operator++(int)
	{
		assert(m_pCur->m_next != nullptr);

		m_pCur = m_pCur->m_next;

		return(CIterator(m_pCur->m_prev));
	}
	
	// 前--
	CIterator &operator--()
	{
		assert(m_pCur->m_prev->m_prev);
		
		m_pCur = m_pCur->m_prev;

		return(*this);
	}
	// 后--
	CIterator operator--(int)
	{
		assert(m_pCur->m_prev->m_prev);
		m_pCur = m_pCur->m_prev;

		return(m_pCur->m_next);
	}

	bool operator==(const CIterator &itr)
	{
		return(m_pCur != itr.m_pCur);
	}

	bool operator!=(const CIterator &itr)
	{
		return(!(m_pCur == itr.m_pCur));
	}

	Node *operator->()
	{
		return(m_pCur);
	}
private:
	Node *m_pCur;
};

class CList
{
public:
	static const size_t INVALID_IDX = -1;
public:
	// 默认构造函数
	CList();
	// 拷贝构造函数
	CList(const CList& lst);
	// 移动构造函数
	CList(CList&& lst);
	// 析构函数
	virtual ~CList();
	// 等号赋值运算符
	CList& operator=(const CList& lst);
	// 不需要移动等号运算符重载
	CList& operator=(CList&& lst) = delete;
	// 重载[]运算符
	int& operator[](size_t nIdx);
	// 新结点插入头部
	CList& InsertHead(int val);
	// 新结点插入尾部
	CList& InsertTail(int val);
	// 在指定索引插入值
	CList& Insert(int val, size_t nIdx); 
	// 遍历打印双向链表
	void TraverseList() const;
	// 删除双向链表头部
	CList& DeleteHead();
	// 删除双向链表尾部
	CList& DeleteTail();
	// 删除指定索引指向的结点
	CList& Delete(size_t nIdx);           
	// 清空链表并释放空间
	void   Clear();
	// 通过值来寻找对应结点的索引
	//int    Find(int val) const; 
	CIterator Find(int val);
	// 获取链表元素数量
	size_t Size() const;
	// 判断链表是否为空
	bool   IsEmpty() const;

	CIterator Begin();
	CIterator End();
private:
	// 通过索引获取执行结点的指针
	Node* IdxToNode(size_t nIdx);
	// 初始化双向链表
	void InitList();
private:
	Node* m_pHeadGuard = nullptr; // 头哨兵
	Node* m_pTailGuard = nullptr; // 尾哨兵
	size_t m_nSize = 0;           // 个数
};

(完)