【十五】【C++】list的简单实现

list 的迭代器解引用探究

 
/*list的迭代器解引用探究*/
#if 1
#include <list>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;class Date {private:int _year;int _month;int _day;public:Date(): _year(2024), _month(1), _day(1){}void Show() {cout << _year << "-" << _month << "-" << _day << endl;}};
void TestList8() {list<Date> L1;L1.push_back(Date());L1.push_back(Date());L1.push_back(Date());L1.push_back(Date());auto it1=L1.begin();while(it1!=L1.end()){it1->Show();it1++;}list<int> L2;L2.push_back(1);L2.push_back(2);L2.push_back(3);L2.push_back(4);auto it2=L2.begin();while(it2!=L2.end()){cout<<*it2<<endl;it2++;}}int main() {TestList8();}
#endif

这段代码主要展示了如何在 C++ 中使用 std::list 容器来存储和遍历自定义类型(Date 类)的对象以及基本数据类型(int)的值。程序定义了一个 Date 类,用于表示日期,并提供了一个 Show 成员函数来打印日期。然后,它在函数 TestList8 中创建了两个 std::list 容器:一个存储 Date 对象,另一个存储 int 值。通过迭代器遍历这些列表,并展示了如何访问和操作容器中的元素。

这段代码看似平平无奇,细心的小伙伴可能会发现,在遍历L1list对象的时候,it1->Show();这一行代码似乎有一点问题。it1迭代器底层是list结点的指针,it1->得到的结果应该是Date类型对象而不能直接访问Date类型对象的成员才对。如果it1底层指针存储的是节点中Date类型的对象的地址,那么it1->Show();就没有任何问题。

实际上list类中->底层会返回*it迭代器的地址,Ptr operator->(){return &(operator*()); },但即使返回了地址,我们还需要一个->才能访问Date的对象才对。正确的做法就变成了it1->->Show();这个样子。但是这样的代码可读性太差了,为了提高代码的可读性,编译器自动给我们添加一个->,使得我们仅仅使用it1->Show();这样的代码就可以完成实现。

代码实现

 
#include<iostream>
using namespace std;
#include<algorithm>
namespace Mylist
{template<class T>struct ListNode{ListNode<T>* _next;ListNode<T>* _prev;T _value;ListNode(const T& value = T()): _next(nullptr), _prev(nullptr), _value(value){}};// 1. 封装迭代器对应的类template<class T, class Ref, class Ptr>struct ListIterator{typedef ListNode<T> Node;typedef Ref ItRef;typedef Ptr ItPtr;typedef ListIterator<T, Ref, Ptr> Self;public:ListIterator(Node* pNode = nullptr): _pNode(pNode){}//// 具有指针类似的操作Ref operator*(){return _pNode->_value;}Ptr operator->(){return &(operator*());}// 移动Self& operator++(){_pNode = _pNode->_next;return *this;}Self operator++(int){Self temp(*this);_pNode = _pNode->_next;return temp;}Self& operator--(){_pNode = _pNode->_prev;return *this;}Self operator--(int){Self temp(*this);_pNode = _pNode->_prev;return temp;}///// 比较bool operator!=(const Self& s)const{return _pNode != s._pNode;}bool operator==(const Self& s)const{return _pNode == s._pNode;}Node* _pNode;};// 反向迭代器:就是对正向迭代器的包装template<class Iterator>struct ListReverseIterator{// 静态成员变量也可以通过类名::静态成员变量名称// typedef Iterator::ItRef Ref;  编译报错// 编译器无法在编译时无法确定ItRef是静态成员变量 还是 类型// 需要显式告诉编译器ItRef就是Iterator类中的类型// typenametypedef typename Iterator::ItRef Ref;typedef typename Iterator::ItPtr Ptr;typedef ListReverseIterator<Iterator> Self;public:ListReverseIterator(Iterator it): _it(it){}Ref operator*(){Iterator temp(_it);--temp;return *temp;}Ptr operator->(){return &(operator*());}Self& operator++(){--_it;return *this;}Self operator++(int){Self temp(*this);--_it;return temp;}Self& operator--(){++_it;return *this;}Self operator--(int){Self temp(*this);++_it;return temp;}bool operator!=(const Self& rit)const{return _it != rit._it;}bool operator==(const Self& rit)const{return _it == rit._it;}Iterator _it;};template<class T>class list{typedef ListNode<T> Node;// 2. 在容器中给迭代器类型取别名---publicpublic:typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T, const T&, const T*> const_iterator;typedef ListReverseIterator<iterator> reverse_iterator;typedef ListReverseIterator<const_iterator> const_reverse_iterator;public:// 注意:list的迭代器一定不能是原生态的指针// vector之所以可以,因为vector底层是连续空间// 如果指针指向连续的空间,对指针++/--,该指针就可以移动到下一个/前一个位置// 但是list不行,因为链表中的节点是通过next和prev指针组织起来的,不一定连续// 如果将list的迭代器设置为原生态指针,++it/--it没有意义// typedef Node* iterator;  // ???public:// 构造list(){CreateHead();}list(int n, const T& value = T()){CreateHead();for (int i = 0; i < n; ++i){push_back(value);}}template<class Iterator>list(Iterator first, Iterator last){CreateHead();while (first != last){push_back(*first);++first;}}list(const list<T>& L){CreateHead();auto it = L.cbegin();while (it != L.cend()){push_back(*it);++it;}}list<T>& operator=(list<T> L){this->swap(L);return *this;}~list(){clear();delete _head;_head = nullptr;}//// 迭代器// 3. 增加begin和end的方法iterator begin(){/*iterator ret(_head->_next);return ret;*/return iterator(_head->_next);}iterator end(){return iterator(_head);}const_iterator cbegin()const{/*iterator ret(_head->_next);return ret;*/return const_iterator(_head->_next);}const_iterator cend()const{return const_iterator(_head);}reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}const_reverse_iterator crbegin()const{return const_reverse_iterator(cend());}const_reverse_iterator crend()const{return const_reverse_iterator(cbegin());}//// 容量size_t size()const{size_t count = 0;Node* cur = _head->_next;while (cur != _head){count++;cur = cur->_next;}return count;}bool empty()const{return _head == _head->_next;}void resize(size_t newsize, const T& value = T()){size_t oldsize = size();if (newsize <= oldsize){for (size_t i = newsize; i < oldsize; ++i){pop_back();}}else{for (size_t i = oldsize; i < newsize; ++i){push_back(value);}}}//// 元素访问T& front(){return *begin();}const T& front()const{//return _head->_next->_value;return *cbegin();}T& back(){return *(--end());}const T& back()const{// return _head->_prev->_value;return *(--cend());}///// 修改void push_front(const T& value){insert(begin(), value);}void pop_front(){erase(begin());}void push_back(const T& value){insert(end(), value);}void pop_back(){erase(--end());}iterator insert(iterator it, const T& value){Node* pos = it._pNode;Node* newNode = new Node(value);newNode->_next = pos;newNode->_prev = pos->_prev;newNode->_prev->_next = newNode;pos->_prev = newNode;return newNode;}iterator erase(iterator it){if (it == end())return end();Node* pos = it._pNode;Node* ret = pos->_next;pos->_prev->_next = pos->_next;pos->_next->_prev = pos->_prev;delete pos;return ret;}void clear(){auto it = begin();while (it != end()){it = erase(it);}}void swap(list<T>& L){std::swap(_head, L._head);}private:void CreateHead(){_head = new Node();_head->_next = _head;_head->_prev = _head;}private:Node* _head;};}void TestList1(){Mylist::list<int> L1;Mylist::list<int> L2(10, 5);int array[] = { 1, 2, 3, 4, 5 };Mylist::list<int> L3(array, array+sizeof(array)/sizeof(array[0]));Mylist::list<int> L4(L3);for (auto e : L3){cout << e << " ";}cout << endl;Mylist::list<int>::iterator it = L4.begin();while (it != L4.end()){cout << *it << " ";++it;}cout << endl;}void TestList2(){int array[] = { 1, 2, 3, 4, 5 };Mylist::list<int> L1(array, array + sizeof(array) / sizeof(array[0]));auto itL1 = L1.begin();*itL1 = 10;//    auto citL1 = L1.cbegin();//*citL1 = 100;cout << L1.front() << endl;cout << L1.back() << endl;cout << L1.size() << endl;const Mylist::list<int> L2(L1);
//    auto it = L2.cbegin();cout << L2.front() << endl;cout << L2.back() << endl;}void TestLst3(){Mylist::list<int> L;L.push_back(1);L.push_back(2);L.push_back(3);L.push_back(4);L.push_back(5);cout << L.size() << endl;L.push_front(0);for (auto e : L)cout << e << " ";cout << endl;L.pop_front();for (auto e : L)cout << e << " ";cout << endl;// find(L.begin(), L.end(), 4);
}void TestLst4(){Mylist::list<int> L;L.push_back(1);L.push_back(2);L.push_back(3);L.push_back(4);L.push_back(5);auto it = L.rbegin();while (it != L.rend()){cout << *it << " ";++it;}cout << endl;auto rit = L.crbegin();while (rit != L.crend()){cout << *rit << " ";++rit;}cout << endl;}
int main(){Mylist::list<int> L;L.push_back(1);L.push_back(2);L.push_back(3);L.push_back(4);L.push_back(5);auto it=L.begin();//    L.assign(10, 5);Mylist::list<int> L1(5,10);L = L1;while (it != L.end()){cout << *it << " ";++it;}}

ListNode 结构

 
    template<class T>struct ListNode{ListNode<T>* _next;ListNode<T>* _prev;T _value;ListNode(const T& value = T()): _next(nullptr), _prev(nullptr), _value(value){}};

ListNode 是一个结构体,用于表示链表中的一个节点。它包含指向下一个节点的指针 _next、指向前一个节点的指针 _prev 和存储的数据 _value。构造函数允许用一个值初始化节点,并默认设置前后节点为 nullptr

ListIterator

 
    template<class T, class Ref, class Ptr>struct ListIterator{typedef ListNode<T> Node;typedef Ref ItRef;typedef Ptr ItPtr;typedef ListIterator<T, Ref, Ptr> Self;public:ListIterator(Node* pNode = nullptr): _pNode(pNode){}//// 具有指针类似的操作Ref operator*(){return _pNode->_value;}Ptr operator->(){return &(operator*());}// 移动Self& operator++(){_pNode = _pNode->_next;return *this;}Self operator++(int){Self temp(*this);_pNode = _pNode->_next;return temp;}Self& operator--(){_pNode = _pNode->_prev;return *this;}Self operator--(int){Self temp(*this);_pNode = _pNode->_prev;return temp;}///// 比较bool operator!=(const Self& s)const{return _pNode != s._pNode;}bool operator==(const Self& s)const{return _pNode == s._pNode;}Node* _pNode;};

ListIterator 是一个迭代器类,支持对链表的正向遍历。它重载了操作符,以提供类似指针的行为。包括解引用 (operator*operator->)、迭代(operator++operator--)和比较(operator==operator!=)。ListIterator 使得用户可以通过迭代器遍历链表,访问或修改节点的值。

类模板参数:

 
    template<class T, class Ref, class Ptr>struct ListIterator{typedef ListNode<T> Node;typedef Ref ItRef;typedef Ptr ItPtr;typedef ListIterator<T, Ref, Ptr> Self;

我们在list类里面定义迭代器是这样定义的。typedef ListIterator<T, T&, T*> iterator;其中Ref用来接收T&Ptr用来接收T*

这三个模版参数的具体含义如下所示:

T: 数据类型,指定链表节点存储的数据的类型。

Ref: 引用类型,决定了解引用操作符 (operator*) 返回值的类型,可以是数据的引用,允许通过迭代器修改链表节点的值。

Ptr: 指针类型,指定通过迭代器访问成员时的指针类型,通常是数据的指针类型。

这里的三个模版参数可以理解为数据类型占位符,每一个参数都有其特定的含义以及对应的数据类型,当我们使用的时候,传入的参数会与对应模版参数意义相吻合。

类型定义:

Node: 代表链表节点的类型,使用了模板参数 T 来指定节点存储的数据类型。

ItRefItPtr: 分别代表迭代器的引用和指针类型,这些类型允许迭代器通过类似指针的方式操作数据。

Self: 代表迭代器自身的类型,用于实现链式调用和返回正确的迭代器类型。

成员变量

Node* _pNode;

_pNode: 指向当前迭代器所指向的链表节点的指针。

构造函数:

 
        ListIterator(Node* pNode = nullptr): _pNode(pNode){}

ListIterator(Node* pNode = nullptr): 允许通过给定一个链表节点的指针来构造迭代器。默认参数为 nullptr,允许创建一个不指向任何节点的迭代器。

解引用操作符重载:

 
        // 具有指针类似的操作Ref operator*(){return _pNode->_value;}Ptr operator->(){return &(operator*());}

operator*(): 解引用操作符,返回当前迭代器指向的节点中存储的数据的引用,允许读取或修改该数据。针对于内置类型。

operator->(): 成员访问操作符,提供对当前迭代器指向的节点中存储的数据成员的访问。针对于自定义类型。

->返回的是list元素中的地址,编译器自动帮我们添加了一个->使得我们可以通过list元素自定义类型的地址进行访问成员属性。

迭代器移动:

 
        // 移动Self& operator++(){_pNode = _pNode->_next;return *this;}Self operator++(int){Self temp(*this);_pNode = _pNode->_next;return temp;}Self& operator--(){_pNode = _pNode->_prev;return *this;}Self operator--(int){Self temp(*this);_pNode = _pNode->_prev;return temp;}

operator++(): 前缀递增操作符,使迭代器前进到链表的下一个节点,并返回当前迭代器的引用。

operator++(int): 后缀递增操作符,使迭代器前进到链表的下一个节点,返回迭代器递增前的副本。

operator--(): 前缀递减操作符,使迭代器后退到链表的前一个节点,并返回当前迭代器的引用。

operator--(int): 后缀递减操作符,使迭代器后退到链表的前一个节点,返回迭代器递减前的副本。

operator!=operator==: 比较操作符,分别用于判断两个迭代器是否不相等或相等,即它们是否指向同一个链表节点。

小结论:

通过测试我们发现,在list简单实现过程中,如果不显示定义operator*()operator->()重载,就没办法解引用迭代器,但在vector简单实现过程中,并不需要显示定义operator*()operator->()重载就可以完成解引用迭代器。

ListReverseIterator

 
     // 反向迭代器:就是对正向迭代器的包装template<class Iterator>struct ListReverseIterator{// 静态成员变量也可以通过类名::静态成员变量名称// typedef Iterator::ItRef Ref;  编译报错// 编译器无法在编译时无法确定ItRef是静态成员变量 还是 类型// 需要显式告诉编译器ItRef就是Iterator类中的类型// typenametypedef typename Iterator::ItRef Ref;typedef typename Iterator::ItPtr Ptr;typedef ListReverseIterator<Iterator> Self;public:ListReverseIterator(Iterator it): _it(it){}Ref operator*(){Iterator temp(_it);--temp;return *temp;}Ptr operator->(){return &(operator*());}Self& operator++(){--_it;return *this;}Self operator++(int){Self temp(*this);--_it;return temp;}Self& operator--(){++_it;return *this;}Self operator--(int){Self temp(*this);++_it;return temp;}bool operator!=(const Self& rit)const{return _it != rit._it;}bool operator==(const Self& rit)const{return _it == rit._it;}Iterator _it;};

ListReverseIterator 是一个反向迭代器类,对 ListIterator 进行了包装,使其能够以相反的顺序遍历链表。它通过改变迭代方向(即通过递减其底层正向迭代器)来实现反向遍历。反向迭代器同样重载了类似指针的操作。

模板参数Iterator

 
     // 反向迭代器:就是对正向迭代器的包装template<class Iterator>struct ListReverseIterator{// 静态成员变量也可以通过类名::静态成员变量名称// typedef Iterator::ItRef Ref;  编译报错// 编译器无法在编译时无法确定ItRef是静态成员变量 还是 类型// 需要显式告诉编译器ItRef就是Iterator类中的类型// typenametypedef typename Iterator::ItRef Ref;typedef typename Iterator::ItPtr Ptr;typedef ListReverseIterator<Iterator> Self;

ListReverseIterator是模板结构体,其模板参数Iterator代表它将要包装的正向迭代器的类型。

类型别名定义(typedef):

使用typedef typename Iterator::ItRef Ref;定义了一个类型别名Ref,它引用了正向迭代器中定义的ItRef类型。这里的typename关键字是必需的,因为Iterator::ItRef是一个依赖于模板参数的类型,编译器需要明确地被告知这是一个类型名。

类似地,PtrSelf别名分别为迭代器的指针类型和反向迭代器自身的类型。

构造函数:

 
        ListReverseIterator(Iterator it): _it(it){}

接受一个正向迭代器作为参数,并初始化内部的迭代器_it

解引用操作符重载:

 
         Ref operator*(){Iterator temp(_it);--temp;return *temp;}Ptr operator->(){return &(operator*());}

operator*:解引用操作符,返回当前迭代器前一个位置的元素的引用。这是因为反向迭代时,当前位置实际对应的是正向迭代器的前一个元素。

operator->:成员访问操作符,返回当前元素的指针。

反向迭代器是通过正向迭代器封装复用实现的,反向迭代器的rbegin对应正向迭代器的end,反向迭代器的rend对应正向迭代器的begin。反向迭代器中的operator*()解引用实际上是返回正向迭代器前一个位置的解引用。即创建一个临时的正向迭代器对象,这个正向迭代器对象进行--操作指向前一个位置,返回的是前一个位置的迭代器的解引用。因为*temp实际上返回的是list具体对象,temp出作用域消失,但是list中的具体对象不会消失。

->返回的是list元素中的地址,编译器自动帮我们添加了一个->使得我们可以通过list元素自定义类型的地址进行访问成员属性。

迭代器移动:

 
         Self& operator++(){--_it;return *this;}Self operator++(int){Self temp(*this);--_it;return temp;}Self& operator--(){++_it;return *this;}Self operator--(int){Self temp(*this);++_it;return temp;}

对于反向迭代器,递增意味着正向迭代器实际上是递减的,递减则相反。

相等与不等operator运算符重载:

 
         bool operator!=(const Self& rit)const{return _it != rit._it;}bool operator==(const Self& rit)const{return _it == rit._it;}

operator!=operator==:比较操作符,用于比较两个反向迭代器是否不相等或相等。

成员变量

Iterator _it;

内部迭代器_it:这是被包装的正向迭代器的实例,反向迭代器通过操作这个内部迭代器来实现反向遍历。

ListIterator类和ListReverseIterator类的思考

在这两类中,模版参数可以理解为对应类型的占位符,也就是明确告诉编译器这些参数对应的是什么样的数据类型,因为在后面的使用过程中,我们会对其进行封装,以至于传入模版参数的数据类型就是我们希望的数据类型。

注意ListReverseIterator类中的Ref operator*()解引用是调用正向迭代器的前一个位置的解引用。因为反向迭代器是对正向迭代器进行封装,复用,来实现反向遍历的功能。

在list类中我们使用反向迭代器时,rbegin传入的是end迭代器,也就是正向迭代器的最后一个元素的后一个位置。简单来说,反向迭代器实际上是正向迭代器的逆用,利用正向迭代器的end来封装复用实现rbegin,利用正向迭代器的begin来封装复用实现rend

正向迭代器的区间是[begin,end),为了统一反向迭代器的区间也应该是[rbegin,rend)。而rbegin是通过正向迭代器end实现的,rend是通过正向迭代器begin实现的,为了统一实现,反向迭代器的解引用operator*全部都返回当前迭代器前一个位置的元素的引用。

list

 
     template<class T>class list{typedef ListNode<T> Node;// 2. 在容器中给迭代器类型取别名---publicpublic:typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T, const T&, const T*> const_iterator;typedef ListReverseIterator<iterator> reverse_iterator;typedef ListReverseIterator<const_iterator> const_reverse_iterator;public:// 注意:list的迭代器一定不能是原生态的指针// vector之所以可以,因为vector底层是连续空间// 如果指针指向连续的空间,对指针++/--,该指针就可以移动到下一个/前一个位置// 但是list不行,因为链表中的节点是通过next和prev指针组织起来的,不一定连续// 如果将list的迭代器设置为原生态指针,++it/--it没有意义// typedef Node* iterator;  // ???public:// 构造list(){CreateHead();}list(int n, const T& value = T()){CreateHead();for (int i = 0; i < n; ++i){push_back(value);}}template<class Iterator>list(Iterator first, Iterator last){CreateHead();while (first != last){push_back(*first);++first;}}list(const list<T>& L){CreateHead();auto it = L.cbegin();while (it != L.cend()){push_back(*it);++it;}}list<T>& operator=(list<T> L){this->swap(L);return *this;}~list(){clear();delete _head;_head = nullptr;}//// 迭代器// 3. 增加begin和end的方法iterator begin(){/*iterator ret(_head->_next);return ret;*/return iterator(_head->_next);}iterator end(){return iterator(_head);}const_iterator cbegin()const{/*iterator ret(_head->_next);return ret;*/return const_iterator(_head->_next);}const_iterator cend()const{return const_iterator(_head);}reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}const_reverse_iterator crbegin()const{return const_reverse_iterator(cend());}const_reverse_iterator crend()const{return const_reverse_iterator(cbegin());}//// 容量size_t size()const{size_t count = 0;Node* cur = _head->_next;while (cur != _head){count++;cur = cur->_next;}return count;}bool empty()const{return _head == _head->_next;}void resize(size_t newsize, const T& value = T()){size_t oldsize = size();if (newsize <= oldsize){for (size_t i = newsize; i < oldsize; ++i){pop_back();}}else{for (size_t i = oldsize; i < newsize; ++i){push_back(value);}}}//// 元素访问T& front(){return *begin();}const T& front()const{//return _head->_next->_value;return *cbegin();}T& back(){return *(--end());}const T& back()const{// return _head->_prev->_value;return *(--cend());}///// 修改void push_front(const T& value){insert(begin(), value);}void pop_front(){erase(begin());}void push_back(const T& value){insert(end(), value);}void pop_back(){erase(--end());}iterator insert(iterator it, const T& value){Node* pos = it._pNode;Node* newNode = new Node(value);newNode->_next = pos;newNode->_prev = pos->_prev;newNode->_prev->_next = newNode;pos->_prev = newNode;return newNode;}iterator erase(iterator it){if (it == end())return end();Node* pos = it._pNode;Node* ret = pos->_next;pos->_prev->_next = pos->_next;pos->_next->_prev = pos->_prev;delete pos;return ret;}void clear(){auto it = begin();while (it != end()){it = erase(it);}}void swap(list<T>& L){std::swap(_head, L._head);}private:void CreateHead(){_head = new Node();_head->_next = _head;_head->_prev = _head;}private:Node* _head;};}

list类代码解析

 
     template<class T>class list{typedef ListNode<T> Node;// 2. 在容器中给迭代器类型取别名---publicpublic:typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T, const T&, const T*> const_iterator;typedef ListReverseIterator<iterator> reverse_iterator;typedef ListReverseIterator<const_iterator> const_reverse_iterator;

类模板声明:

template<class T> class list定义了一个泛型链表,T是链表中存储元素的类型。

迭代器类型别名:

定义了两种迭代器:iteratorconst_iterator,分别用于访问可修改的数据和只读数据。这些迭代器不是原生指针,而是封装过的,因为链表的元素不是连续存储的,不能直接通过指针算术操作访问。

还定义了反向迭代器reverse_iteratorconst_reverse_iterator,用于实现反向遍历。

构造函数和析构函数:

无参构造函数

 
        // 构造list(){CreateHead();}void CreateHead(){_head = new Node();_head->_next = _head;_head->_prev = _head;}

list()是无参构造函数,它只是创建了一个头节点。

指定的元素数量和值的构造函数

 
         list(int n, const T& value = T()){CreateHead();for (int i = 0; i < n; ++i){push_back(value);}}

list(int n, const T& value = T())根据指定的元素数量和值进行初始化。实际上就是不断地调用push_back操作。

范围构造函数

 
         template<class Iterator>list(Iterator first, Iterator last){CreateHead();while (first != last){push_back(*first);++first;}}

list(Iterator first, Iterator last)是范围构造函数,根据给定的迭代器范围来构造链表。

拷贝构造函数

 
         list(const list<T>& L){CreateHead();auto it = L.cbegin();while (it != L.cend()){push_back(*it);++it;}}

list(const list<T>& L)是拷贝构造函数,用另一个链表的内容来初始化新链表。

析构函数

 
         ~list(){clear();delete _head;_head = nullptr;}

~list()是析构函数,它清除链表中的所有元素,并删除头节点。

赋值操作符:

 
         list<T>& operator=(list<T> L){this->swap(L);return *this;}

使用了拷贝并交换的技巧来实现赋值操作符。

迭代器方法:

 
        // 迭代器// 3. 增加begin和end的方法iterator begin(){/*iterator ret(_head->_next);return ret;*/return iterator(_head->_next);}iterator end(){return iterator(_head);}const_iterator cbegin()const{/*iterator ret(_head->_next);return ret;*/return const_iterator(_head->_next);}const_iterator cend()const{return const_iterator(_head);}reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}const_reverse_iterator crbegin()const{return const_reverse_iterator(cend());}const_reverse_iterator crend()const{return const_reverse_iterator(cbegin());}

提供了begin, end, cbegin, cend, rbegin, rend, crbegin, crend等方法来获取迭代器,分别对应于开始、结束的正向和反向迭代器。

反向迭代器中的rbegin复用正向迭代器中的end操作,反向迭代器中的rend复用正向迭代器中的begin操作。

注意正向迭代器的end是最后一个元素后面一个位置,因为这是循环双向链表,因此end实际上指向的是head头结点。

容量和大小操作:

 
        // 容量size_t size()const{size_t count = 0;Node* cur = _head->_next;while (cur != _head){count++;cur = cur->_next;}return count;}bool empty()const{return _head == _head->_next;}void resize(size_t newsize, const T& value = T()){size_t oldsize = size();if (newsize <= oldsize){for (size_t i = newsize; i < oldsize; ++i){pop_back();}}else{for (size_t i = oldsize; i < newsize; ++i){push_back(value);}}}

size()方法计算链表的大小。注意只有随机访问迭代器才支持迭代器相减的操作。

随机访问迭代器(Random Access Iterator):支持直接相减操作,因为它们可以在常数时间内访问序列中的任何元素。vectordeque 容器提供的迭代器就是随机访问迭代器。list的迭代器并不属于随机访问迭代器,所以size操作只能通过迭代器的移动来计算个数,而不能通过迭代器的相减操作。

empty()检查链表是否为空。

resize()调整链表的大小,根据需要添加或移除元素。

元素访问:

 
        // 元素访问T& front(){return *begin();}const T& front()const{//return _head->_next->_value;return *cbegin();}T& back(){return *(--end());}const T& back()const{// return _head->_prev->_value;return *(--cend());}

front()back()方法分别用于访问链表的第一个元素和最后一个元素。

修改操作:

 
        // 修改void push_front(const T& value){insert(begin(), value);}void pop_front(){erase(begin());}void push_back(const T& value){insert(end(), value);}void pop_back(){erase(--end());}iterator insert(iterator it, const T& value){Node* pos = it._pNode;Node* newNode = new Node(value);newNode->_next = pos;newNode->_prev = pos->_prev;newNode->_prev->_next = newNode;pos->_prev = newNode;return newNode;}iterator erase(iterator it){if (it == end())return end();Node* pos = it._pNode;Node* ret = pos->_next;pos->_prev->_next = pos->_next;pos->_next->_prev = pos->_prev;delete pos;return ret;}void clear(){auto it = begin();while (it != end()){it = erase(it);}}void swap(list<T>& L){std::swap(_head, L._head);}

功能:在链表的前端插入一个新元素。

实现方式:通过调用insert方法,在begin()位置插入新元素。begin()返回指向链表第一个元素的迭代器。

pop_front()

功能:删除链表的第一个元素。

实现方式:通过调用erase方法,删除begin()位置的元素。这 effectively removes the first element of the list.

push_back(const T& value)

功能:在链表的末尾添加一个新元素。

实现方式:通过调用insert方法,在end()位置插入新元素。由于end()返回的迭代器实际上指向链表尾部的哑元节点,插入操作会在链表的最后一个元素之后插入新元素。

pop_back()

功能:删除链表的最后一个元素。

实现方式:通过调用erase方法,删除--end()位置的元素。--end()操作返回指向链表最后一个元素的迭代器。

insert(iterator it, const T& value)

功能:在指定位置it前插入一个新元素。

实现方式:首先获取it指向的节点pos,然后创建一个新节点newNode,并将其插入到pos前面。更新相邻节点的指针以维持链表的连贯性。最后,返回指向新插入节点的迭代器。

erase(iterator it)

功能:删除指定位置it的元素。

实现方式:首先检查it是否为end(),如果是,则不进行任何操作并返回end()。否则,获取it指向的节点pos,调整前后节点的指针跳过pos,然后删除pos节点,最后返回指向被删除节点下一个节点的迭代器。

clear()

功能:清空链表,删除所有元素。

实现方式:从链表的开始遍历,使用erase方法逐个删除元素,直到整个链表被清空。

swap(list<T>& L)

功能:与另一个链表L交换内容。

实现方式:简单地交换两个链表的头节点指针_head。这是通过std::swap实现的,是一个非常高效的操作,因为它仅仅交换了指针,而不需要移动或复制链表中的元素。

私有成员和方法:

 
    private:void CreateHead(){_head = new Node();_head->_next = _head;_head->_prev = _head;}private:Node* _head;};

_head是指向链表头节点的指针。

CreateHead()是一个辅助方法,用于初始化链表,创建一个哨兵节点作为头节点。

结尾

最后,感谢您阅读我的文章,希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点,请随时在评论区留言。

同时,不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中,我将继续探讨这个话题的不同方面,为您呈现更多深度和见解。

谢谢您的支持,期待与您在下一篇文章中再次相遇!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/679185.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【CC++】内存管理2:new + delete

前言 今天继续来学new和delete operator new 与operator delete函数 new和delete是用户进行动态内存申请和释放的操作符&#xff0c;operator new 和operator delete是系统提供的全局函数&#xff0c;new在底层调用operator new全局函数来申请空间&#xff0c;delete在底层通…

【开源】基于JAVA+Vue+SpringBoot的二手车交易系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 数据中心模块2.2 二手车档案管理模块2.3 车辆预约管理模块2.4 车辆预定管理模块2.5 车辆留言板管理模块2.6 车辆资讯管理模块 三、系统设计3.1 E-R图设计3.2 可行性分析3.2.1 技术可行性分析3.2.2 操作可行性3.2.3 经济…

Java核心设计模式:代理设计模式

一、生活中常见的代理案例 房地产中介&#xff1a;客户手里没有房源信息&#xff0c;找一个中介帮忙商品代购&#xff1a;代理者一般有好的资源渠道&#xff0c;降低购物成本&#xff08;如海外代购&#xff0c;自己不用为了买东西出国&#xff09; 二、为什么要使用代理 对…

AI修复历史人物 图像转真人 绝密档案

修复李白 开启control 不要点爆炸小按钮 权重建议&#xff1a;0.7-1.2 采样&#xff1a;DPM SDE Karras 如果人眼不好&#xff0c;开启高清修复&#xff0c;进行2次尝试 高难度 修复张居正 softhed 1 lineart_真实 1 适当调整lineart进入值。 如果效果不好&#xff…

CentOS安装MySQL

下载安装MySQL 官网下载MySQL ① 下载&#xff1a;访问链接&#xff1a;MySQL下载 ② 安装&#xff1a;将安装包上传并解压&#xff0c;解压&#xff1a; tar -zxvf mysql-x.x.xx-xxx.tar.gzyum安装MySQL ① 更新yum&#xff1a;sudo yum update ② 下载MySQL的rpm包&#…

【大厂AI课学习笔记】【1.6 人工智能基础知识】(2)机器学习

目录 必须理解的知识点&#xff1a; 举一个草莓的例子&#xff1a; 机器学习的三个类别&#xff1a; 监督学习&#xff1a; 无监督学习&#xff1a; 强化学习&#xff1a; 更多知识背景&#xff1a; 机器学习的诞生需求 监督学习的关键技术与实现步骤 无监督学习的关…

ubuntu篇---ubuntu安装python3.9

ubuntu篇—ubuntu安装python3.9 在ubuntu上安装Python有两种方法:在线安装和源码编译安装。 方法1&#xff1a;使用apt在线安装 1.更新软件包列表并安装必备组件&#xff1a; $ sudo apt update $ sudo apt install software-properties-common2.将Deadsnakes PPA添加到系统…

Keil : Error-Flash Download failed Cortex-M4错误

1.打开魔术棒 2.点击Debug设置 3.查看是否有你使用的板子型号的flash 4.如果没有的话就添加以下

【Python 千题 —— 基础篇】查找年龄

Python 千题持续更新中 …… 脑图地址 👉:⭐https://twilight-fanyi.gitee.io/mind-map/Python千题.html⭐ 题目描述 题目描述 班级中有 Tom、Alan、Bob、Candy、Sandy 五个人,他们组成字典 {Tom: 23, Alan: 24, Bob: 21, Candy: 22, Sandy: 21},字典的键是姓名,字典的…

详细讲解ES6箭头函数语法(附Demo)

目录 前言1. 传统函数2. 箭头函数3. 差异比较彩蛋 前言 讲述箭头函数之前&#xff0c;先了解传统函数的格式&#xff0c;方便做一个对比 1. 传统函数 函数声明&#xff1a; function greet() {console.log("Hello!"); } greet();函数表达式&#xff1a; const s…

Java实现教学资源共享平台 JAVA+Vue+SpringBoot+MySQL

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 数据中心模块2.2 课程档案模块2.3 课程资源模块2.4 课程作业模块2.5 课程评价模块 三、系统设计3.1 用例设计3.2 类图设计3.3 数据库设计3.3.1 课程档案表3.3.2 课程资源表3.3.3 课程作业表3.3.4 课程评价表 四、系统展…

【通讯录案例-偏好设置 Objective-C语言】

一、刚才,我们plist存储,讲完了,这个plist,我直接,右键,打开 打开 不用xcode,我就用文本文档打开,打开方式:其他 选择:文本编辑 打开 好,这个里边儿啊,就是我们刚才存的一个Key:Value 它本质上,是一个xml 这是一种文件的格式, 等你们讲到网络的时候,实际上,…

掌握Pandas数据筛选方法与高级应用全解析【第70篇—python:数据筛选】

文章目录 掌握Pandas&#xff1a;数据筛选方法与高级应用全解析1. between方法2. isin方法3. loc方法4. iloc方法5. 查询复杂条件的结合应用6. 避免inplace参数7. 利用Lambda函数进行自定义筛选8. 处理缺失值9. 多条件排序10. 数据统计与分组 总结&#xff1a; 掌握Pandas&…

【UE 游戏编程基础知识】

目录 0 引言1 基础知识1.1 拓展&#xff1a;3D数学和计算机图形学的关系 &#x1f64b;‍♂️ 作者&#xff1a;海码007&#x1f4dc; 专栏&#xff1a;UE虚幻引擎专栏&#x1f4a5; 标题&#xff1a;【UE 游戏编程基础知识】❣️ 寄语&#xff1a;书到用时方恨少&#xff0c;事…

工业级加固平板丨亿道三防平板电脑丨安卓工业平板丨改善车队管理

在现代物流和运输行业中&#xff0c;车队管理是一个复杂而重要的任务。为了更好地管理车队&#xff0c;提高工作效率和减少成本&#xff0c;许多企业正在采用新技术和工具。其中&#xff0c;三防平板电脑作为一种功能强大且适应恶劣环境的设备&#xff0c;已经在车队管理中得到…

【电路】三个晶体管的声控开关电路

这种声控开关&#xff0c;可能是非常有用的&#xff0c;例如敲门声或拍手声可以激活一盏灯&#xff0c;灯光几秒钟后会自动关闭。另一种使用在防盗保护&#xff0c;如果有人想打开门或打破东西&#xff0c;灯就会亮起来&#xff0c;这表明有人在家。 该电路可以工作于任何5–1…

opencv图像像素的读写操作

void QuickDemo::pixel_visit_demo(Mat & image) {int w image.cols;//宽度int h image.rows;//高度int dims image.channels();//通道数 图像为灰度dims等于一 图像为彩色时dims等于三 for (int row 0; row < h; row) {for (int col 0; col < w; col) {if…

【2024年数据】67个“绿色金融”主题DID政策汇总(已去重)

DID”发文趋势和主题分布 数据来源&#xff1a;中国知网、各期刊官网 时间跨度&#xff1a;2017-2024年 数据范围&#xff1a;中国各省 数据指标&#xff1a; 序号 用于构建DID的政策 文献标题 1 “宽带中国” 数字技术创新与中国企业高质量发展——来自企业数字专利的证据…

板块一 Servlet编程:第二节 Servlet的实现与生命周期 来自【汤米尼克的JAVAEE全套教程专栏】

板块一 Servlet编程&#xff1a;第二节 Servlet的实现与生命周期 一、Servlet相关概念Serlvet的本质 二、中Web项目中实现Servlet规范&#xff08;1&#xff09;在普通的Java类中继承HttpServlet类&#xff08;2&#xff09;重写service方法编辑项目对外访问路径 二、Servlet工…

【电路笔记】-串联电感

串联电感 文章目录 串联电感1、概述2、电感串联示例13、互耦串联电感器4、电感串联示例25、电感串联示例36、总结 当电感器以菊花链方式连接在一起并共享公共电流时&#xff0c;它们可以串联连接在一起。 1、概述 这些电感器的互连产生了更复杂的网络&#xff0c;其总电感是各…