• list的模拟实现

    全部代码

    1. #pragma once
    2. namespace HQJ
    3. {
    4.  template<class T>
    5.  struct __list_node//节点类
    6.  {
    7.   T __data;
    8.   __list_node<T>* __prev;
    9.   __list_node<T>* __next;
    10.  
    11.   __list_node(const T& x = T())//由于不知道要存储的数据类型，使用匿名对象进行初始化
    12.    :__data(x)
    13.    , __prev(nullptr)
    14.    , __next(nullptr)
    15.   {}
    16.  };
    17.  
    18.  template<class T, class REF, class PTR>
    19.  //const迭代器和普通迭代器只是在*和->运算符重载的返回值不同
    20.  //我们添加REF作为T&和const T&，PTR作为T*和const T*
    21.  struct __iterator//迭代器类，核心是节点指针
    22.  {
    23.   typedef __list_node<T> Node;
    24.   typedef __iterator<T,REF,PTR> self;
    25.  
    26.   Node* _node;
    27.  
    28.   __iterator(Node* node)//指向头结点
    29.    :_node(node)
    30.   {}
    31.  
    32.   self& operator++()
    33.   {
    34.    _node = _node->__next;
    35.    return *this;//不是返回_node
    36.   }
    37.  
    38.   self& operator++(int)
    39.   {
    40.    self tmp(_node);
    41.    _node = _node->__next;
    42.    return tmp;//不是返回_node
    43.   }
    44.  
    45.   self& operator--(int)
    46.   {
    47.    self tmp(_node);
    48.    _node = _node->__prev;
    49.    return tmp;//不是返回_node
    50.   }
    51.   self& operator--()
    52.   {
    53.    _node = _node->__prev;
    54.    return *this;
    55.   }
    56.  
    57.   PTR operator->()
    58.   {
    59.    return &_node->__data;
    60.   }
    61.  
    62.   REF operator*()
    63.   {
    64.    return _node->__data;
    65.   }
    66.  
    67.   bool operator!=(const self& s)//这里也要是迭代器参数，不能是Node*
    68.   {
    69.    return _node != s._node;
    70.   }
    71.  };
    72.  
    73.  template<class T>//这里也要是模板函数，实现的时候别忘记了
    74.  class list//list类
    75.  {
    76.  public:
    77.   typedef __list_node<T> Node;
    78.   typedef __iterator<T, T&, T*> iterator;
    79.   typedef __iterator<T, const T&, const T*> const_iterator;
    80.  
    81.   template<class T>
    82.   iterator insert(iterator pos, const T& x)
    83.   {
    84.    Node* cur = pos._node;
    85.  
    86.    Node* newnode = new Node(x);
    87.    newnode->__next = cur;
    88.    newnode->__prev = cur->__prev;
    89.  
    90.    cur->__prev->__next = newnode;
    91.    cur->__prev = newnode;
    92.  
    93.    return newnode;
    94.   }
    95.  
    96.   const_iterator begin()const
    97.   {
    98.    return const_iterator((_head->__next));//首元节点而不是头结点
    99.   }
    100.  
    101.   const_iterator end()const
    102.   {
    103.    return const_iterator(_head);//不是_head->__next，因为迭代器是左闭右开
    104.   }
    105.  
    106.   iterator begin()
    107.   {
    108.    return iterator((_head->__next));//首元节点而不是头结点
    109.   }
    110.  
    111.   iterator end()
    112.   {
    113.    return iterator(_head);//不是_head->__next，因为迭代器是左闭右开
    114.   }
    115.  
    116.   void empty_init()
    117.   {
    118.    _head = new Node;
    119.    _head->__next = _head;
    120.    _head->__prev = _head;
    121.   }
    122.  
    123.  /* template<class T>
    124.   void push_back(const T& x)
    125.   {
    126.    Node* newnode = new Node(x);
    127.  
    128.    newnode->__prev = _head->__prev;
    129.    _head->__prev->__next = newnode;
    130.  
    131.    _head->__prev = newnode;
    132.    newnode->__next = _head;
    133.   }*/
    134.  
    135.   template<class T>
    136.   void push_back(const T& x)
    137.   {
    138.    insert(end(), x);
    139.   }
    140.  
    141.   template<class T>
    142.   void push_front(const T& x)
    143.   {
    144.    insert(begin(), x);
    145.   }
    146.  
    147.   void pop_back()
    148.   {
    149.    erase(end());
    150.   }
    151.  
    152.   void clear()
    153.   {
    154.    iterator it = begin();
    155.    while (it != end())
    156.    {
    157.     it = erase(it);
    158.    }
    159.   }
    160.  
    161.   void pop_front()
    162.   {
    163.    erase(begin());
    164.   }
    165.  
    166.   bool empty()
    167.   {
    168.    return (_head->__next) == _head;
    169.   }
    170.  
    171.   void swap(list<T> lt)
    172.   {
    173.    std::swap(_head, lt._head);
    174.   }
    175.  
    176.  
    177.  
    178.   iterator erase(iterator pos)
    179.   {
    180.    assert(!empty());
    181.    Node* cur = pos._node;
    182.    Node* next = cur->__next;
    183.  
    184.    cur->__prev->__next = cur->__next;
    185.    cur->__next->__prev = cur->__prev;
    186.  
    187.    delete cur;
    188.    return next;
    189.   }
    190.  
    191.   list<T>& operator=(const list<T>& lt)
    192.   {
    193.    swap(lt);
    194.    return *this;
    195.   }
    196.  
    197.  
    198.   list()
    199.   {
    200.    empty_init();
    201.   }
    202.  
    203.   list(const list<T>& lt)
    204.   {
    205.    empty_init();
    206.    for (auto e : lt)
    207.    {
    208.     push_back(e);
    209.    }
    210.   }
    211.  
    212.  private:
    213.   Node* _head;
    214.  };
    215.  
    216.  template<typename T>//告知编译器，这是个未实例化的模板，等实例化之后再去取
    217.  void print_list(const list<T>& lt)
    218.  {
    219.   typename list<T>::const_iterator it = lt.begin();
    220.   while (it != lt.end())
    221.   {
    222.    cout << *it << endl;
    223.    it++;
    224.   }
    225.  }
    226.  
    227.  template<typename Container>//告知编译器，这是个未实例化的模板，等实例化之后再去取
    228.  void print_list(const Container& con)
    229.  {
    230.   typename Container::const_iterator it = con.begin();
    231.   while (it != con.end())
    232.   {
    233.    cout << *it << endl;
    234.    it++;
    235.   }
    236.  }
    237. } 

    节点类的模拟实现

    • 这是一个双向链表的节点类，包含了数据成员__data（存储节点的数据）、__prev（指向前一个节点的指针）和__next（指向后一个节点的指针）。节点类还定义了一个构造函数，在创建节点时可以传入数据值进行初始化，如果没有传入数据值，则使用默认构造函数创建一个匿名对象进行初始化。这样设计的好处在于可以在创建节点时灵活地指定要存储的数据类型，并且可以通过指针链接起各个节点，形成一个双向链表的结构。

    1. template<class T>
    2.  struct __list_node//节点类
    3.  {
    4.   T __data;
    5.   __list_node<T>* __prev;
    6.   __list_node<T>* __next;
    7.  
    8.   __list_node(const T& x = T())//由于不知道要存储的数据类型，使用匿名对象进行初始化
    9.    :__data(x)
    10.    , __prev(nullptr)
    11.    , __next(nullptr)
    12.   {}
    13.  };

    迭代器类的模拟实现

    1. template<class T, class REF, class PTR>
    2.  //const迭代器和普通迭代器只是在*和->运算符重载的返回值不同
    3.  //我们添加REF作为T&和const T&，PTR作为T*和const T*
    4.  struct __iterator//迭代器类，核心是节点指针
    5.  {
    6.   typedef __list_node<T> Node;
    7.   typedef __iterator<T,REF,PTR> self;
    8.  
    9.   Node* _node;
    10.  
    11.   __iterator(Node* node)//指向头结点
    12.    :_node(node)
    13.   {}
    14.  
    15.   self& operator++()
    16.   {
    17.    _node = _node->__next;
    18.    return *this;//不是返回_node
    19.   }
    20.  
    21.   self& operator++(int)
    22.   {
    23.    self tmp(_node);
    24.    _node = _node->__next;
    25.    return tmp;//不是返回_node
    26.   }
    27.  
    28.   self& operator--(int)
    29.   {
    30.    self tmp(_node);
    31.    _node = _node->__prev;
    32.    return tmp;//不是返回_node
    33.   }
    34.   self& operator--()
    35.   {
    36.    _node = _node->__prev;
    37.    return *this;
    38.   }
    39.  
    40.   PTR operator->()
    41.   {
    42.    return &_node->__data;
    43.   }
    44.  
    45.   REF operator*()
    46.   {
    47.    return _node->__data;
    48.   }
    49.  
    50.   bool operator!=(const self& s)//这里也要是迭代器参数，不能是Node*
    51.   {
    52.    return _node != s._node;
    53.   }
    54.  };

    类型重定义

    • typedef __list_node Node; 定义了一个类型别名 Node，它表示 __list_node 类型。这样做的目的是为了简化代码中使用 __list_node 的地方，可以直接使用 Node。

    • typedef __iterator self; 定义了一个类型别名 self，它表示 __iterator 类型。同样地，这样做的目的是为了简化代码中使用 __iterator 的地方，可以直接使用 self。

    • 使用 typedef 关键字可以为已有的类型或者组合类型定义一个新的名称，方便在代码中使用并增加可读性。

    1. typedef __list_node<T> Node;
    2. typedef __iterator<T,REF,PTR> self;

    构造函数

    • 在该构造函数中，_node（节点指针）可以指向链表中的任意一个节点，但是这里是将其直接指向头结点。头结点是一个不存储具体数据的虚拟节点，它的作用主要是简化链表的各种操作，比如在头部插入一个元素或者删除一个元素时，无需特判链表为空的情况，只需要处理头结点和第一个实际节点即可。

    1.   __iterator(Node* node)//指向头结点
    2.    :_node(node)
    3.   {}

    ++运算符重载

    • self& operator++() 是前置自增运算符的重载函数，它用于将迭代器指向链表中的下一个节点。在函数体内，首先将 _node 指针移动到下一个节点 _node->__next，然后返回自身的引用 *this。这样做是为了支持连续的自增操作，例如 ++i1; ++i1; 。

    • self& operator++(int) 是后置自增运算符的重载函数，它与前置自增运算符功能相同，但是通过传入一个额外的 int 参数来区分前置和后置自增运算符。为了保持后置自增运算符的语义，需要创建一个临时的迭代器 tmp 来保存当前迭代器的值，然后再将迭代器指向下一个节点 _node->__next，最后返回临时迭代器 tmp。这样做是为了实现 C++ 中后置自增运算符的规定行为，即返回自增前的值。

    • 需要注意的是，这两个重载函数并不直接返回节点指针 _node，而是返回迭代器对象本身的引用或临时对象。这是为了保持迭代器的一致性和语义，在使用迭代器进行链表操作时更加直观和方便。

    1.    self& operator++()
    2.   {
    3.    _node = _node->__next;
    4.    return *this;//不是返回_node
    5.   }
    6.  
    7.   self& operator++(int)
    8.   {
    9.    self tmp(_node);
    10.    _node = _node->__next;
    11.    return tmp;//不是返回_node
    12.   }
    13.

    --运算符重载

    • self& operator--(int) 是后置自减运算符的重载函数，用于将迭代器指向链表中的前一个节点。在函数体内，首先创建一个临时的迭代器 tmp 来保存当前迭代器的值，然后将 _node 指针移动到前一个节点 _node->__prev，最后返回临时迭代器 tmp。这样做是为了实现 C++ 中后置自减运算符的规定行为，即返回自减前的值。

    • self& operator--() 是前置自减运算符的重载函数，与后置自减函数功能相同，但是不需要返回临时对象。在函数体内，直接将 _node 指针移动到前一个节点 _node->__prev，然后返回自身的引用 *this。这样做是为了支持连续的自减操作，例如 --i1; --i1; 。

    1.   self& operator--(int)
    2.   {
    3.    self tmp(_node);
    4.    _node = _node->__prev;
    5.    return tmp;//不是返回_node
    6.   }
    7.   self& operator--()
    8.   {
    9.    _node = _node->__prev;
    10.    return *this;
    11.   }

    ->运算符重载

    • 在函数体内，首先获取 _node 指针所指向的节点中存储的数据成员的指针 _node->__data，然后将其取地址返回。由于 _node->__data 的类型为 T，因此返回的指针类型为 T*。

    • 通过重载箭头运算符，可以使得迭代器对象在使用时像指针一样简洁明了，例如 iter->data_member; 可以直接访问节点存储的数据成员 data_member。而不需要通过 (*iter).data_member; 这样的方式来访问。

    1.   PTR operator->()
    2.   {
    3.    return &_node->__data;
    4.   }

    *（解引用）运算符重载

    • 在函数体内，首先获取 _node 指针所指向的节点中存储的数据成员 _node->__data，然后直接返回其值。由于返回的是数据成员的引用，因此返回类型为 REF，可能是 T& 或者 const T&，取决于节点数据成员的类型和迭代器的常量性。

    • 通过重载解引用运算符，可以使得迭代器对象在使用时可以直接获取节点存储的数据，并且可以修改数据（若不是 const 迭代器）。例如 *iter = new_data; 可以直接将新的数据 new_data 赋值给节点。而不需要通过 iter._node->__data = new_data; 这样的方式来修改。

      1. REF operator*()
      2.    {
      3.     return _node->__data;
      4.    }

      !=运算符重载

    • 在函数体内，将当前迭代器对象 _node 和参数传入的迭代器对象 s._node 进行比较。如果它们指向的节点地址不相等，则返回 true，表示两个迭代器不相等；否则返回 false，表示两个迭代器相等。

    • 通过重载不等于运算符，我们可以直接使用 iter1 != iter2 来判断两个迭代器是否相等，而不需要显式地比较节点地址。这样可以提高代码的可读性和简洁性。

      1. bool operator!=(const self& s)//这里也要是迭代器参数，不能是Node*
      2.    {
      3.     return _node != s._node;
      4.    }

      list类的模拟实现

      1. template<class T>//这里也要是模板函数，实现的时候别忘记了
      2.   class list//list类
      3.   {
      4.   public:
      5.    typedef __list_node<T> Node;
      6.    typedef __iterator<T, T&, T*> iterator;
      7.    typedef __iterator<T, const T&, const T*> const_iterator;
      8.  
      9.    template<class T>
      10.    iterator insert(iterator pos, const T& x)
      11.    {
      12.     Node* cur = pos._node;
      13.  
      14.     Node* newnode = new Node(x);
      15.     newnode->__next = cur;
      16.     newnode->__prev = cur->__prev;
      17.  
      18.     cur->__prev->__next = newnode;
      19.     cur->__prev = newnode;
      20.  
      21.     return newnode;
      22.    }
      23.  
      24.    const_iterator begin()const
      25.    {
      26.     return const_iterator((_head->__next));//首元节点而不是头结点
      27.    }
      28.  
      29.    const_iterator end()const
      30.    {
      31.     return const_iterator(_head);//不是_head->__next，因为迭代器是左闭右开
      32.    }
      33.  
      34.    iterator begin()
      35.    {
      36.     return iterator((_head->__next));//首元节点而不是头结点
      37.    }
      38.  
      39.    iterator end()
      40.    {
      41.     return iterator(_head);//不是_head->__next，因为迭代器是左闭右开
      42.    }
      43.  
      44.    void empty_init()
      45.    {
      46.     _head = new Node;
      47.     _head->__next = _head;
      48.     _head->__prev = _head;
      49.    }
      50.  
      51.   /* template<class T>
      52.    void push_back(const T& x)
      53.    {
      54.     Node* newnode = new Node(x);
      55.  
      56.     newnode->__prev = _head->__prev;
      57.     _head->__prev->__next = newnode;
      58.  
      59.     _head->__prev = newnode;
      60.     newnode->__next = _head;
      61.    }*/
      62.  
      63.    template<class T>
      64.    void push_back(const T& x)
      65.    {
      66.     insert(end(), x);
      67.    }
      68.  
      69.    template<class T>
      70.    void push_front(const T& x)
      71.    {
      72.     insert(begin(), x);
      73.    }
      74.  
      75.    void pop_back()
      76.    {
      77.     erase(end());
      78.    }
      79.  
      80.    void clear()
      81.    {
      82.     iterator it = begin();
      83.     while (it != end())
      84.     {
      85.      it = erase(it);
      86.     }
      87.    }
      88.  
      89.    void pop_front()
      90.    {
      91.     erase(begin());
      92.    }
      93.  
      94.    bool empty()
      95.    {
      96.     return (_head->__next) == _head;
      97.    }
      98.  
      99.    void swap(list<T> lt)
      100.    {
      101.     std::swap(_head, lt._head);
      102.    }
      103.  
      104.   
      105.  
      106.    iterator erase(iterator pos)
      107.    {
      108.     assert(!empty());
      109.     Node* cur = pos._node;
      110.     Node* next = cur->__next;
      111.  
      112.     cur->__prev->__next = cur->__next;
      113.     cur->__next->__prev = cur->__prev;
      114.  
      115.     delete cur;
      116.     return next;
      117.    }
      118.  
      119.    list<T>& operator=(const list<T>& lt)
      120.    {
      121.     swap(lt);
      122.     return *this;
      123.    }
      124.  
      125.  
      126.    list()
      127.    {
      128.     empty_init();
      129.    }
      130.  
      131.    list(const list<T>& lt)
      132.    {
      133.     empty_init();
      134.     for (auto e : lt)
      135.     {
      136.      push_back(e);
      137.     }
      138.    }
      139.  
      140.   private:
      141.    Node* _head;
      142.   };

      类型重定义

    • Node 是 __list_node 类型的别名，其中 __list_node 是链表节点的实现类。通过定义 Node 别名，可以使得在模板类中定义节点指针时更加方便，例如 Node* _node;。

    • iterator 是 __iterator 类型的别名，其中 __iterator 是迭代器类的实现类，T& 是解引用后返回的数据成员类型的引用，T* 是箭头运算符返回的数据成员类型的指针。通过定义 iterator 别名，可以使得在模板类中定义迭代器变量时更加简洁，例如 iterator iter;。

    • const_iterator 是 __iterator 类型的别名，其中 const T& 是解引用后返回的数据成员类型的常量引用，const T* 是箭头运算符返回的数据成员类型的常量指针。通过定义 const_iterator 别名，可以使得在模板类中定义常量迭代器变量时更加方便，例如 const_iterator iter_c;。

      1. typedef __list_node<T> Node;
      2. typedef __iterator<T, T&, T*> iterator;
      3. typedef __iterator<T, const T&, const T*> const_iterator;

      私有成员

    • 一个指向链表头节点的指针

      1. Node* _head;

      构造函数和拷贝构造函数

    • 默认构造函数 list() 会调用 empty_init() 函数进行初始化。empty_init() 函数实际上是一个私有函数，用于初始化链表的头节点和尾指针，将头节点的前后指针都指向自身，表示链表为空。

    • 拷贝构造函数 list(const list& lt) 接受一个常量引用类型的参数 lt，表示要进行拷贝的链表。

    • 在函数内部，首先调用 empty_init() 函数初始化空链表；然后通过遍历参数链表 lt，逐一将其元素插入到新的链表中，这里使用了 push_back(e) 函数将每个元素插入到链表的尾部。具体实现时，可以使用 C++11 引入的 for-range 循环，对链表 lt 进行遍历。

      1.  list()
      2.    {
      3.     empty_init();
      4.    }
      5.  
      6.    list(const list& lt)
      7.    {
      8.     empty_init();
      9.     for (auto e : lt)
      10.     {
      11.      push_back(e);
      12.     }
      13.    }

      insert函数

    +- 首先，通过 pos._node 获取插入位置 pos 对应的链表节点。然后，使用 new 运算符创建一个值为 x 的新节点 newnode。

    • 接下来，将新节点 newnode 的指针指向当前位置 cur，即 newnode->__next = cur。

    • 然后，将新节点 newnode 的前驱指针指向当前位置的前一个节点，即 newnode->__prev = cur->__prev。

    • 随后，通过修改当前位置节点 cur 的前一个节点和后一个节点的指针，将新节点 newnode 插入到链表中。将当前位置节点的前一个节点的后继指针指向新节点 newnode，即 cur->__prev->__next = newnode，然后将当前位置节点的前驱指针指向新节点 newnode，即 cur->__prev = newnode。

    • 最后，返回插入的新节点 newnode。

      1. template<class T>
      2.    iterator insert(iterator pos, const T& x)
      3.    {
      4.     Node* cur = pos._node;
      5.  
      6.     Node* newnode = new Node(x);
      7.     newnode->__next = cur;
      8.     newnode->__prev = cur->__prev;
      9.  
      10.     cur->__prev->__next = newnode;
      11.     cur->__prev = newnode;
      12.  
      13.     return newnode;
      14.    }

      迭代器接口

    • 对于 begin() 函数，它返回一个指向链表首元节点的迭代器。由于该函数是在常量函数中定义的，因此返回的是一个 const_iterator 类型的常量迭代器。它通过 _head->__next 获取首元节点的地址，然后将其传递给 const_iterator 类的构造函数，返回一个指向首元节点的常量迭代器。

    • 对于 end() 函数，它返回一个指向链表尾后位置的迭代器。同样地，由于该函数是在常量函数中定义的，因此返回的是一个 const_iterator 类型的常量迭代器。它通过 _head 获取头结点的地址，并将其传递给 const_iterator 类的构造函数，返回一个指向尾后位置的常量迭代器。

    • 对于非常量版本的 begin() 和 end() 函数，它们的实现方法与常量版本相似，只不过返回的是一个 iterator 类型的迭代器，用于修改链表元素的值。因此，它们的实现中也是通过 _head->__next 和 _head 获取首元节点和尾后位置的地址，并将其传递给 iterator 类的构造函数，返回一个指向首元节点和尾后位置的迭代器。

      1. const_iterator begin()const
      2.    {
      3.     return const_iterator((_head->__next));//首元节点而不是头结点
      4.    }
      5.  
      6.    const_iterator end()const
      7.    {
      8.     return const_iterator(_head);//不是_head->__next，因为迭代器是左闭右开
      9.    }
      10.  
      11.    iterator begin()
      12.    {
      13.     return iterator((_head->__next));//首元节点而不是头结点
      14.    }
      15.  
      16.    iterator end()
      17.    {
      18.     return iterator(_head);//不是_head->__next，因为迭代器是左闭右开
      19.    }

      empty_init函数

    • 首先，代码通过创建一个新的节点 _head 来作为链表的头结点。然后，将 _head 的 __next 和 __prev 指针都指向自身，即 _head->__next = _head 和 _head->__prev = _head。这样就形成了一个循环链表，头结点的 __next 和 __prev 都指向自身，表示链表为空。

    • 这样的初始化操作是为了确保在链表为空时，头结点的 __next 和 __prev 都指向自身，以方便后续对链表的插入、删除等操作进行统一处理。同时，由于链表为空，头结点既是首元节点又是尾节点，它们之间相互指向自身，构成一个闭合的循环链表结构。

      1. void empty_init()
      2.    {
      3.     _head = new Node;
      4.     _head->__next = _head;
      5.     _head->__prev = _head;
      6.    }

      push_back和push_front函数·

      • push_back() 函数通过调用 insert() 函数，在链表尾部插入元素。它接受一个常量引用 x，表示要插入的元素值。在具体实现中，通过调用 end() 函数获取指向链表尾后位置的迭代器，然后将该迭代器作为参数传递给 insert() 函数，同时传递要插入的元素值 x。这样就实现了将元素插入到链表尾部的功能。

    • push_front() 函数通过调用 insert() 函数，在链表头部插入元素。它接受一个常量引用 x，表示要插入的元素值。在具体实现中，通过调用 begin() 函数获取指向链表首元节点的迭代器，然后将该迭代器作为参数传递给 insert() 函数，同时传递要插入的元素值 x。这样就实现了将元素插入到链表头部的功能。

      1. template<class T>
      2.    void push_back(const T& x)
      3.    {
      4.     insert(end(), x);
      5.    }
      6.  
      7.    template<class T>
      8.    void push_front(const T& x)
      9.    {
      10.     insert(begin(), x);
      11.    }

      erase函数

    • 首先，代码使用断言 assert(!empty()) 来确保链表不为空，即在删除元素之前必须保证链表中至少有一个元素。

    • 接着，根据传入的参数 pos，获取要删除的节点 cur 和它的下一个节点 next。这里的 pos 是一个迭代器，指向要删除的节点。

    • 将 cur 的前一个节点的 __next 指针指向 cur 的下一个节点，将 cur 的后一个节点的 __prev 指针指向 cur 的前一个节点。这样就将 cur 从链表中断开了。

    • 使用 delete 关键字释放内存，删除节点 cur。

    • 最后，返回下一个元素的迭代器 next，作为删除操作后的迭代位置。

      1.  iterator erase(iterator pos)
      2.    {
      3.     assert(!empty());
      4.     Node* cur = pos._node;
      5.     Node* next = cur->__next;
      6.  
      7.     cur->__prev->__next = cur->__next;
      8.     cur->__next->__prev = cur->__prev;
      9.  
      10.     delete cur;
      11.     return next;
      12.    }

      pop_back和pop_front函数

    • 在具体实现中，该函数通过调用 erase() 函数来删除链表中的最后一个元素。它首先调用 end() 函数获取指向链表尾部的迭代器，然后将该迭代器作为参数传递给 erase() 函数来删除其前一个节点，从而删除链表中的最后一个元素。

    • 在具体实现中，该函数通过调用 erase() 函数来删除第一个元素。它首先调用 begin() 函数获取指向链表首部的迭代器，然后将该迭代器作为参数传递给 erase() 函数来删除链表的第一个元素。

    此时，由于 erase() 函数返回的是被删除节点的下一个节点的迭代器，因此返回值可以忽略。删除链表的第一个元素后，若链表不为空，则其首部会被新的首元节点所取代。

    1. void pop_front()
    2.    {
    3.     erase(begin());
    4.    }
    5. void pop_back()
    6.    {
    7.     erase(end());
    8.    }

    clear函数

    • 在具体实现中，该函数通过迭代调用 erase() 函数来逐个删除链表中的元素。它首先通过调用 begin() 函数获取指向链表首部的迭代器 it，并与 end() 的迭代器进行比较，如果不相等就执行循环操作。

    • 在每次循环中，它使用迭代器 it 作为参数调用 erase() 函数来删除当前节点，并将返回值赋给迭代器 it。由于 erase() 函数返回的是被删除节点的下一个节点的迭代器，所以在循环条件中不断判断 it 是否等于 end()，可以确保及时退出循环。

    • 当函数执行完毕后，链表中的所有元素都已被删除，其大小为 0。

      1.  void clear()
      2.    {
      3.     iterator it = begin();
      4.     while (it != end())
      5.     {
      6.      it = erase(it);
      7.     }
      8.    }

      empty函数

    • 首先，代码通过 _head->__next 来获取链表的头节点的下一个节点。

    • 接着，将获取到的下一个节点与链表的头节点进行比较，如果相等，即 _head->__next == _head，则表示链表为空。

    • 最后，将比较结果作为布尔值返回，以表示链表是否为空。

      1. bool empty()
      2.    {
      3.     return (_head->__next) == _head;
      4.    }
      5.

      swap函数

    • swap() 函数接受一个 list 类型的参数 lt，表示另一个要进行交换的链表。

    • 在函数内部，通过调用 std::swap() 函数来交换当前链表的 _head 与参数链表 lt 的 _head。std::swap() 是标准库中的函数，用于交换两个对象的值。

      1. void swap(list lt)
      2.    {
      3.     std::swap(_head, lt._head);
      4.    }

      =运算符重载

    • operator= 函数接受一个 const list& 类型的参数 lt，表示要进行赋值的链表。

    • 在函数内部，调用 swap() 函数将当前链表与参数链表 lt 进行交换。由于 swap() 函数是以引用方式传递参数的，因此实际上是交换了两个链表的头节点；同时，函数的返回值是当前链表的引用。

    • 最后，将当前链表的引用作为返回值返回，以支持链式赋值操作。

      1. list<T>& operator=(const list<T>& lt)
      2.    {
      3.     swap(lt);
      4.     return *this;
      5.    }
  • 相关阅读:
    【自监督Re-ID】ICCV_2023_Oral | ISR论文阅读
    windows下使用python + opencv读取含有中文路径的图片 和 把图片数据保存到含有中文的路径下
    【ubuntu-nginx安装】
    ES（二）| 安装ES、Kibana、IK分词器、拼音分词器（自动补全）
    2-8 基于matlab的ESMD（Extreme-Point Symmetric Mode Decomposition）信号分解算法
    怒刷LeetCode的第26天（Java版）
    PyCharm及python解释器详细安装教程
    CleanMyMac X2023免费清理苹果电脑Mac磁盘空间
    【LeetCode】二叉树OJ
    lombok注解介绍
  • 原文地址：https://blog.csdn.net/ZHENGZJM/article/details/133625667