cpp--实战项目，list的模拟实现，注释超详细！

list的模拟实现

相信大家看完我的这篇有关list使用的博客cpp–list的介绍及使用，一看就会！之后对于list类的基本使用有了一定的了解，如果大家想对于list的底层有所了解，就可以看看我这篇list的模拟实现！
在这之前我建议大家先掌握以下内容
cpp–vector的介绍及其使用，超详细，一看就会！
C++中的string类使用,看我这一篇就够了!
如果已经对上述使用有所了解，可以看看一下的模拟实现，以便对底层有所了解
cpp–vector的模拟实现,注释超详细！
cpp实战项目—string类的模拟实现

list.h

// 防止头文件被重复包含
#pragma once

// 定义命名空间 lis
namespace lis
{
   
    // 定义双向链表节点的结构体模板
    template<class T>
    struct list_node
    {
   
        T _data;  // 节点存储的数据
        list_node<T>* _next;  // 指向下一个节点的指针
        list_node<T>* _prev;  // 指向前一个节点的指针

        // 节点的构造函数，使用默认参数初始化数据，前后指针初始化为空
        list_node(const T& x = T())
            :_data(x)
            , _next(nullptr)
            , _prev(nullptr)
        {
   

        }
    };

    // 定义双向链表迭代器的结构体模板
    template<class T, class Ref, class Ptr>
    struct __list_iterator
    {
   
        typedef list_node<T> Node;  // 重命名节点类型，方便后续使用
        typedef __list_iterator<T, Ref, Ptr> self;  // 重命名迭代器类型，方便后续使用

        Node* _node;  // 迭代器内部指向的节点指针

        // 迭代器的构造函数，用节点指针初始化
        __list_iterator(Node* node)
            :_node(node)
        {
   

        }

        // 前置自增运算符重载，将迭代器指向下一个节点，并返回自身引用
        self& operator++()
        {
   
            _node = _node->_next;
            return *this;
        }

        // 前置自减运算符重载，将迭代器指向前一个节点，并返回自身引用
        self& operator--()
        {
   
            _node = _node->_prev;
            return *this;
        }

        // 后置自增运算符重载，先保存当前迭代器状态，再将迭代器指向下一个节点，最后返回保存的状态
        self operator++(int)
        {
   
            self temp(*this);
            _node = _node->_next;
            return temp;
        }

        // 后置自减运算符重载，先保存当前迭代器状态，再将迭代器指向前一个节点，最后返回保存的状态
        self operator--(int)
        {
   
            self temp(*this);
            _node = _node->_prev;
            return temp;
        }

        // 解引用运算符重载，返回当前节点存储的数据的引用
        Ref operator*()
        {
   
            return _node->_data;
        }

        // 箭头运算符重载，返回当前节点存储的数据的指针
        Ptr operator->()
        {
   
            return &_node->_data;
        }

        // 不等于运算符重载，判断两个迭代器是否指向不同的节点
        bool operator!=(const self& s)
        {
   
            return _node != s._node;
        }

        // 等于运算符重载，判断两个迭代器是否指向相同的节点
        bool operator==(const self& s)
        {
   
            return _node == s._node;
        }
    };

    // 定义双向链表类模板
    template<class T>
    class list
    {
   
        typedef list_node<T> Node;  // 重命名节点类型，方便后续使用
    public:
        typedef __list_iterator<T, T