• 【万字总结】C++——list的基本使用和模拟实现(建议收藏)

    目录

    一、list基本介绍

    二、list的使用

    1、list的初始化方式

    2、list的增删查改

    push_front和pop_front与push_back和pop_back

    insert

    erase

    3、list迭代器的使用

    正向迭代器

    反向迭代器

    4、list获取头尾元素

    5、list容量操作

    6、list的其他操作

    sort

    splice

    remove

    unique

    merge

    reverse

    assign

    swap

    7、结点的构造函数

    三、模拟迭代器类

    迭代器类的模板参数

    1、构造函数

    2、运算符重载

    ++

    ==

    !=

    *

    ->

    四、list的模拟实现

    1、构造函数

    2、拷贝构造函数

    3、赋值运算符重载函数

    4、析构函数

    5、迭代器相关函数

    begin和end

    insert

    erase

    push_back和pop_back与push_front和pop_front

    clear

    五、反向迭代器的模拟实现

    六、完整代码 

    reverse_iterator.h

    list.h

    七、vector与list优劣

    一、list基本介绍

    1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

    2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。

    3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高 效。

    4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率 更好。

    5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list 的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间 开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这 可能是一个重要的因素)。

    二、list的使用

    1、list的初始化方式

    1.     list<int> lt1;//构造空容器
    2. 	list<int> lt2(20, 2);//构造有20个2的int型容器
    3. 	list<int> lt3(lt2);//拷贝构造
    4.  
    5. 	string str("hello world");
    6. 	//使用迭代器
    7. 	list<char> lt4(str.begin(), str.end());//使用区间给容器赋值
    8.     int myints[] = {16,2,77,29};
    9.     std::list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );//使用数组进行初始化

    2、list的增删查改

    push_front和pop_front与push_back和pop_back

    1. void test_list2()
    2. {
    3. 	list<int> lt;
    4. 	//尾插
    5. 	lt.push_back(1);
    6. 	lt.push_back(2);
    7. 	lt.push_back(3);
    8. 	lt.push_back(4);
    9. 	//1  2  3  4
    10.  
    11. 	//尾删
    12. 	lt.pop_back();
    13. 	//1  2  3  
    14. 	
    15. 	//头插
    16. 	lt.push_front(0);
    17. 	//0  1  2  3
    18.  
    19. 	//头删
    20. 	lt.pop_front();
    21. 	//1  2  3 
    22.  
    23. 	//打印
    24. 	for (auto e : lt)
    25. 	{
    26. 		cout << e << " ";
    27. 	}
    28. 	cout << endl;
    29. 	//1  2  3 
    30. }

    insert

    查阅文档我们可以发现list有三种插入方式：

    1、在指定迭代器位置插入一个数。

    2、在指定迭代器位置插入n个值为val的数。

    3、在指定迭代器位置插入一段迭代器区间。 

    1. 	list<int> lt;
    2. 	//尾插
    3. 	lt.push_back(1);
    4. 	lt.push_back(2);
    5. 	lt.push_back(3);
    6. 	lt.push_back(4);
    7. 	// 1  2  3  4
    8. 	
    9.  
    10.  
    11.     //方式一
    12. 	//先确定2的位置
    13. 	list<int>::iterator pos = find(lt.begin(), lt.end(), 2);
    14. 	//在2的前面插入一个0
    15. 	lt.insert(pos, 0);
    16. 	// 1  0  2  3  4 
    17.  
    18. 	//方式二
    19. 	//在2的前面插入两个0
    20. 	lt.insert(pos, 2, 0);
    21. 	//1  0  0  0  2  3  4
    22.  
    23. 	//方式三
    24. 	vector<int> v(3, 0);
    25. 	lt.insert(pos, v.begin(), v.end());
    26. 	//在2的前面插入三个0
    27. 	//1  0  0  0  0  0  0  2  3  4

    erase

     文档中记载有两种删除方式：

    1. 删除指定迭代器位置的元素。
    2. 删除指定迭代器区间（左闭右开）的所有元素。
    1.     list<int> lt;
    2. 	//尾插
    3. 	lt.push_back(1);
    4. 	lt.push_back(2);
    5. 	lt.push_back(3);
    6. 	lt.push_back(4);
    7. 	// 1  2  3  4
    8. 	// 
    9. 	
    10. 	//找到2的位置用迭代器指向它获得
    11. 	list<int>::iterator pos1 = find(lt.begin(), lt.end(),2);
    12. 	lt.erase(pos1);
    13. 	// 1  3  4  
    14.  
    15. 	list<int>::iterator pos2 = find(lt.begin(), lt.end(), 3);
    16. 	lt.erase(pos2, lt.end());
    17. 	// 1

    3、list迭代器的使用

    正向迭代器

    1.  
    2. 	list<int> lt(3, 7);
    3. 	list<int>::iterator it = lt.begin();
    4.  
    5. 	while (it != lt.end())
    6. 	{
    7. 		cout << *it << " ";
    8. 		it++;
    9. 	}
    10. 	//输出3个7

    反向迭代器

    1.     list<int> lt;
    2. 	//尾插
    3. 	lt.push_back(1);
    4. 	lt.push_back(2);
    5. 	lt.push_back(3);
    6. 	lt.push_back(4);
    7. 	list<int>::reverse_iterator rit = lt.rbegin();
    8. 	while (rit != lt.rend())
    9. 	{
    10. 		cout << *rit << " ";
    11. 		rit++;
    12. 	}
    13. 	//4  3  2  1

    4、list获取头尾元素

    1.     list<int> lt;
    2. 	//尾插
    3. 	lt.push_back(1);
    4. 	lt.push_back(2);
    5. 	lt.push_back(3);
    6. 	lt.push_back(4);
    7.  
    8. 	//输出最后一个元素的值
    9. 	cout << lt.back() << endl;
    10.  
    11. 	//输出第一个元素的值
    12. 	cout << lt.front() << endl;

    5、list容量操作

    1.  
    2. 	list<int> lt;
    3. 	//尾插
    4. 	lt.push_back(1);
    5. 	lt.push_back(2);
    6. 	lt.push_back(3);
    7. 	lt.push_back(4);
    8.  
    9. 	//输出数据个数
    10. 	cout << lt.size() << endl;
    11.  
    12. 	//当所给值大于当前的size时，将size扩大到该值，扩大的数据为第二个所给值
    13. 	//若未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
    14. 	//当所给值小于当前的size时，将size缩小到该值。
    15. 	//容量增加到5
    16. 	lt.resize(5);
    17. 	
    18. 	//判断容器内是否为空
    19. 	if (lt.empty())
    20. 	{
    21. 		cout << "容器为空" << endl;
    22. 	}
    23. 	else
    24. 	{
    25. 		cout << "容器不为空" << endl;
    26. 	}
    27.  
    28. 	//清空容器的数据，不改变容量大小
    29. 	lt.clear();
    30. 	cout << lt.size() << endl;
    31.

    6、list的其他操作

    sort

    将容器中的数据默认按照升序排列。

    1. list<int> lt;
    2. 	//尾插
    3. 	lt.push_back(3);
    4. 	lt.push_back(4);
    5. 	lt.push_back(1);
    6. 	lt.push_back(2);
    7.  
    8. 	lt.sort();
    9. 	for (auto e : lt)
    10. 	{
    11. 		cout << e << " ";
    12. 	}
    13. 	cout << endl;
    14. 	//输出 1  2  3  4

    splice

    作用是拼接两个list容器。

    由文档可知有三种方式： 

    1、将一个容器拼接到另一个容器迭代器指向的位置。

    2、将容器中的某一个数据拼接到另一个容器迭代器指向的位置。

    3、将要容器中迭代器指向的区间的数据拼接到另一个容器迭代器指向的位置。

    1.  
    2. 	//方式一
    3. 	list<int> lt1;
    4. 	//尾插
    5. 	lt1.push_back(1);
    6. 	lt1.push_back(2);
    7. 	lt1.push_back(3);
    8. 	lt1.push_back(4);
    9.  
    10. 	list<int> lt2(3, 5);
    11.  
    12. 	list<int>::iterator pos1 = find(lt1.begin(), lt1.end(), 2);
    13. 	lt1.splice(pos1, lt2);
    14.  
    15. 	for (auto e : lt1)
    16. 	{
    17. 		cout << e << " ";
    18. 	}
    19. 	cout << endl;
    20. 	//1 5 5 5 2 3 4
    21.  
    22.  
    23.  
    24. 	//方式二
    25. 	list<int> lt1;
    26. 	//尾插
    27. 	lt1.push_back(1);
    28. 	lt1.push_back(2);
    29. 	lt1.push_back(3);
    30. 	lt1.push_back(4);
    31.  
    32. 	list<int> lt2(3, 5);
    33.  
    34. 	list<int>::iterator pos1 = find(lt1.begin(), lt1.end(), 2);
    35. 	lt1.splice(pos1, lt2, lt2.begin());
    36. 	//1  5  2  3  4
    37.  
    38.  
    39.  
    40. 	
    41. 	//方式三
    42. 	list<int> lt1;
    43. 	//尾插
    44. 	lt1.push_back(1);
    45. 	lt1.push_back(2);
    46. 	lt1.push_back(3);
    47. 	lt1.push_back(4);
    48.  
    49. 	list<int> lt2(3, 5);
    50.  
    51. 	list<int>::iterator pos1 = find(lt1.begin(), lt1.end(), 2);
    52. 	list<int>::iterator it2 = lt2.begin();
    53. 	lt1.splice(pos1, lt2, lt2.begin(), lt2.end());
    54. 	//1 5 5 5 2 3 4

    remove

    删除容器中的某个值

    1.  
    2. 	list<int> lt1;
    3. 	//尾插
    4. 	lt1.push_back(1);
    5. 	lt1.push_back(2);
    6. 	lt1.push_back(3);
    7. 	lt1.push_back(3);
    8. 	lt1.push_back(3);
    9. 	lt1.push_back(3);
    10. 	lt1.push_back(4);
    11.  
    12. 	lt1.remove(3);
    13. 	
    14. 	for (auto e : lt1)
    15. 	{
    16. 		cout << e << " ";
    17. 	}
    18. 	//1  2  4

    unique

    去除容器容器中连续重复的元素。

    1.  
    2. 	list<int> lt;
    3. 	lt.push_back(1);
    4. 	lt.push_back(1);
    5. 	lt.push_back(1);
    6. 	lt.push_back(2);
    7. 	lt.push_back(2);
    8. 	lt.push_back(2);
    9. 	lt.push_back(3);
    10. 	lt.push_back(4);
    11. 	lt.push_back(4);
    12. 	lt.push_back(4);
    13. 	lt.push_back(4);
    14. 	lt.push_back(4);
    15.  
    16. 	lt.unique();
    17. 	for (auto e : lt)
    18. 	{
    19. 		cout << e << " ";
    20. 	}
    21. 	//1  2  3  4

    merge

    类似归并排序，将一个有序容器归并到另一个有序容器中，使其还是有序的。

    1. list<int> lt1;
    2. 	lt1.push_back(1);
    3. 	lt1.push_back(3);
    4. 	lt1.push_back(5);
    5. 	lt1.push_back(7);
    6. 	list<int> lt2;
    7. 	lt2.push_back(2);
    8. 	lt2.push_back(4);
    9. 	lt2.push_back(6);
    10. 	lt2.push_back(8);
    11.  
    12. 	lt1.merge(lt2);
    13.  
    14. 	for (auto e : lt1)
    15. 	{
    16. 		cout << e << " ";
    17. 	}
    18. 	//1  2  3  4  5  6  7  8

    reverse

    将容器中的元素进行逆置。

    1. list<int> lt1;
    2. 	lt1.push_back(1);
    3. 	lt1.push_back(3);
    4. 	lt1.push_back(5);
    5. 	lt1.push_back(7);
    6. 	list<int> lt2;
    7. 	lt2.push_back(2);
    8. 	lt2.push_back(4);
    9. 	lt2.push_back(6);
    10. 	lt2.push_back(8);
    11.  
    12. 	lt1.merge(lt2);
    13.  
    14. 	//1  2  3  4  5  6  7  8
    15.  
    16. 	lt1.reverse();
    17.  
    18. 	for (auto e : lt1)
    19. 	{
    20. 		cout << e << " ";
    21. 	}
    22. 	//8  7  6  5  4  3  2  1

    assign

    将新内容分配给容器，并且会覆盖原容器中的值。

    由文档可知有两种方式：

    1、将n个val值分配给容器

    2、将迭代器区间中的内容分配给容器

    1.  
    2. 	//方式一
    3. 	list<int> lt1;
    4. 	lt1.push_back(1);
    5. 	lt1.push_back(3);
    6. 	lt1.push_back(5);
    7. 	lt1.push_back(7);
    8.  
    9. 	lt1.assign(3, 3);
    10.  
    11. 	for (auto e : lt1)
    12. 	{
    13. 		cout << e << " ";
    14. 	}
    15. 	// 3  3  3
    16.  
    17.  
    18. 	//方式二
    19. 	list<int> lt1;
    20. 	lt1.push_back(1);
    21. 	lt1.push_back(3);
    22. 	lt1.push_back(5);
    23. 	lt1.push_back(7);
    24. 	list<int> lt2;
    25. 	lt2.push_back(2);
    26. 	lt2.push_back(4);
    27. 	lt2.push_back(6);
    28. 	lt2.push_back(8);
    29.  
    30. 	lt1.assign(lt2.begin(), lt2.end());
    31. 	for (auto e : lt1)
    32. 	{
    33. 		cout << e << " ";
    34. 	}
    35. 	//2  4  6  8 
    36.

    swap

    交换两个容器的内容

    1. list<int> lt1;
    2. 	lt1.push_back(1);
    3. 	lt1.push_back(3);
    4. 	lt1.push_back(5);
    5. 	lt1.push_back(7);
    6. 	list<int> lt2;
    7. 	lt2.push_back(2);
    8. 	lt2.push_back(4);
    9. 	lt2.push_back(6);
    10. 	lt2.push_back(8);
    11.  
    12. 	lt1.swap(lt2);
    13. 	for (auto e : lt1)
    14. 	{
    15. 		cout << e << " ";
    16. 	}
    17. 	//2  4  6  8

    7、结点的构造函数

    构造一个结点，并且给结点的数据域he指针域初始化。

    1. template<class T>//类模板
    2. 	struct ListNode
    3. 	{
    4. 		ListNode* _next;
    5. 		ListNode* _prev;
    6. 		T _data;
    7. ListNode(const T& data = T())
    8. 			:_next(nullptr)
    9. 			, _prev(nullptr)
    10. 			, _data(data)
    11. 		{}

    三、模拟迭代器类

    为什么在vector和string中不用实现一个迭代器类呢？

    因为vector和string中的数据都是存储在一块连续的地址空间，我们直接使迭代器像原生指针那样解引用、自增、自减。就可以得到我们所要得到的效果。

    可是list却不是如此，我们知道list的本质是一个双向带头循环链表。地址空间并不连续，我们就不能单纯的像原生指针那样进行操作了。

    而迭代器的意义就是，让使用者可以不必关心容器的底层实现，可以用简单统一的方式对容器内的数据进行访问。

    迭代器类的模板参数

    1. //迭代器
    2. 	template<class T, class Ref, class Ptr>//类模板

    由以上代码我们可以看出来，迭代器类的模板参数列表有三个模板参数。

    这也与list模拟实现中的两个迭代器相对应。

    1. typedef _list_iterator iterator;
    2. typedef _list_iteratorconst T&, const T*> const_iterator;

    其具体作用其实就是为了让我们使用普通迭代器的时候，编译器实例化出一个普通迭代器对象。当我们使用const迭代器的时候就会实例化一个const迭代器对象。

    1、构造函数

    本质就是根据结点指针构造一个迭代器对象。

    1. //构造函数
    2. __list_iterator(Node* x)
    3. 	:_node(x)
    4. {}

    2、运算符重载

     注意：

    self是当前迭代器对象的类型

    		typedef __list_iterator self;

    ++

    本质是使结点指针指向后一个结点，并且返回下一个结点指针。

    1.         //++it
    2. 		self& operator++()
    3. 		{
    4. 			_node = _node->_next;
    5. 			return *this;
    6. 		}
    7.  
    8.         
    9. 		//it++
    10.         //切记后置++不能传引用
    11.         //因为tmp是个临时对象，除了作用域会销毁的因此只能拷贝不能传引用
    12. 		self operator++(int)
    13. 		{
    14. 			self tmp(*this);
    15. 			//保存++之前的值以便于返回
    16. 			_node = _node->_next;
    17. 			return tmp;
    18. 		}

    注意： 切记后置不能传引用，因为tmp是个临时对象，出了作用域会销毁的因此只能拷贝不能传引用

    --

    本质是使结点值真指向前一个结点，并且返回上一个结点指针。

    1.  
    2. 		//--it
    3. 		self& operator--()
    4. 		{
    5. 			_node = _node->_prev;
    6. 			return *this;
    7. 		}
    8. 		//it--
    9. 		self operator--(int)
    10. 		{
    11. 			self tmp(*this);
    12. 			//保存--之前的值以便于返回
    13. 			_node = _node->_prev;
    14. 			return tmp;
    15. 		}

    注意： 切记后置不能传引用，因为tmp是个临时对象，出了作用域会销毁的因此只能拷贝不能传引用 

    ==

    本质就是比较此时两个迭代器当中的结点指针是否指向同一个位置

    1. bool operator==(const self& it) const
    2. 		{
    3. 			return _node == it._node;
    4. 		}

    !=

    1. bool operator!=(const self& it) const
    2. 		{
    3. 			return _node != it._node;
    4. 		}

    *

    由于list是一个链表结构，*解引用实质就是返回此结点指针所指向的数据。

    1. //需要T&传T& 需要const T& 就传 const T&
    2. 		Ref operator*()//由于用的引用，所以可读可写
    3. 		{
    4. 			return _node->_data;
    5. 		}

    ->

    如果list容器中结点中存放的不是内置类型，而是自定义类型，那么我们就要用到->。

    比如下面的日期类：

    1.  
    2. 	struct Date
    3. 	{
    4. 		int _year;
    5. 		int _month;
    6. 		int _day;
    7.  
    8. 		Date(int year = 1, int month = 1, int day = 1)
    9. 			:_year(year)
    10. 			, _month(month)
    11. 			, _day(day)
    12. 		{}
    13. 	};
    14.  
    15. 	void test_list2()
    16. 	{
    17. 		list lt;
    18. 		lt.push_back(Date(2022, 3, 12));
    19. 		lt.push_back(Date(2022, 3, 13));
    20. 		lt.push_back(Date(2022, 3, 14));
    21. 		//普通指针用解引用访问，结构体指针用箭头
    22. 		list::iterator it = lt.begin();
    23. 		while (it != lt.end())
    24. 		{
    25. 			//(*it)代表结点的数据也就是日期类的对象
    26. 			/*cout << (*it)._year << " ";
    27. 			cout << (*it)._month << " ";
    28. 			cout << (*it)._day << " ";
    29. 			cout << endl;*/
    30. 			cout << it->_year << " ";
    31. 			cout << it->_month << " ";
    32. 			cout << it->_day << " ";
    33. 			cout << endl;
    34. 			it++;
    35. 		}
    36. 		cout << endl;
    37. 	}
    38.

    那么该如何重载呢？

    在这里我们先写出重载的函数，再加以解释。

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

    如果你认真去推理你会发现这个重载函数是有问题的，it->找到的是自定义类型Date*，只有再->才是对应的Date的成员变量呀。所以按理说这里应该是it->->，才行呀。

    因此，我们可以得出，如果两个->的话，程序的可读性太差了，所以这里编译器做了特殊的处理，所以省略了一个->。

    四、list的模拟实现

    1、构造函数

    1. list()//构造函数
    2. 		{
    3. 			_head = new Node();//申请头结点
    4. 			_head->_next = _head;//头结点的后一个结点指向自己
    5. 			_head->_prev = _head;//头结点的前一个结点指向自己
    6. 		}

    2、拷贝构造函数

    传统写法：

    首先申请一个头结点，使头结点前驱指针和后继指针都指向自己。然后将容器中的数据通过遍历的方式尾插到新容器后面。

    现代写法：

    首先申请一个头结点，使头结点前驱指针和后继指针都指向自己。然后创建一个名叫tmp的list容器并且使lt1容器通过迭代器区间的方式初始化tmp，随后交换tmp的头结点和lt2。

    1. 传统写法
    2. 		//lt2(lt1)
    3. 		list(const list& lt)
    4. 		{
    5. 			_head = new Node();
    6. 			_head->_next = _head;
    7. 			_head->_prev = _head;
    8. 			for (auto e : lt)
    9. 			{
    10. 				push_back(e);  
    11. 			}
    12. 		}
    13. //现代写法
    14. 		//lt2(lt1)
    15. 		list(const list<int>& lt)
    16. 		{
    17. 			_head = new Node();
    18. 			_head->_next = _head;
    19. 			_head->_prev = _head;
    20. 			list tmp(lt.begin(), lt.end());
    21. 			std::swap(_head, tmp._head);
    22. 		}

    3、赋值运算符重载函数

    传统写法：

    直接将lt中的值一个个遍历尾插到lt1中。

    现代写法：

    直接交换两个容器。

    首先利用编译器机制，故意不使用引用接收参数，通过编译器自动调用list的拷贝构造函数构造出来一个list对象，然后调用swap函数将原容器与该list对象进行交换即可。

    这样做相当于将应该用clear清理的数据，通过交换函数交给了容器lt，而当该赋值运算符重载函数调用结束时，容器lt会自动销毁，并调用其析构函数进行清理。

    1. //传统写法
    2. //lt2=lt1
    3. 		list& operator=(const list& lt)
    4. 		{
    5. 			if (this != <)
    6. 			{
    7. 				clear();
    8. 				for (auto e : lt)
    9. 				{
    10. 					push_back(e);
    11. 				}
    12. 			}
    13. 			return *this;
    14. 		}
    15. //现代写法
    16. list<int>& operator=(list lt)
    17. 		{
    18. 			std::swap(_head, lt._head);
    19.  
    20. 			return *this;
    21. 		}

    4、析构函数

    先用clear清理数据，然后释放头结点，再把头结点置空。

    1. ~list()
    2. 		{
    3. 			clear();
    4.  
    5. 			delete _head;
    6. 			_head = nullptr;
    7.  
    8. 		}

    5、迭代器相关函数

    begin和end

    1. iterator begin()
    2. 		{
    3. 			return iterator(_head->_next);
    4. 		}
    5. 		iterator end()
    6. 		{
    7. 			return iterator(_head);
    8. 		}
    9. 		const_iterator begin() const
    10. 		{
    11. 			return const_iterator(_head->_next);
    12. 		}
    13. 		const_iterator end() const
    14. 		{
    15. 			return const_iterator(_head);
    16. 		}

    insert

    先根据所给迭代器得到该位置处的结点指针cur，然后通过cur指针找到前一个位置的结点指针prev，接着根据所给数据x构造一个待插入结点，之后再建立新结点与cur之间的双向关系，最后建立新结点与prev之间的双向关系即可。

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

    erase

    首先使用断言assert来使所删除位置不能是头结点。先根据所给迭代器得到该位置处的结点指针cur，然后通过cur指针找到前一个位置的结点指针prev，以及后一个位置的结点指针next，紧接着释放cur结点，最后建立prev和next之间的双向关系即可。

    1.  
    2. 		iterator erase(iterator pos)
    3. 		{
    4. 			assert(pos != end());
    5.  
    6. 			Node* prev = pos._node->_prev;
    7. 			Node* next = pos._node->_next;
    8.  
    9. 			delete pos._node;
    10. 			prev->_next = next;
    11. 			next->_prev = prev;
    12. 			return iterator(next);
    13. 		}

    push_back和pop_back与push_front和pop_front

    可以复用insert和erase进行处理。

    1.         void push_back(const T& x)
    2. 		{
    3. 			//Node* tail = _head->_prev;//记录最后的尾结点
    4. 			//Node* newnode = new Node(x);//创建新结点
    5. 			空节点也适用
    6. 			链接各个节点之间的关系
    7. 			//tail->_next = newnode;
    8. 			//newnode->_prev = tail;
    9. 			//newnode->_next = _head;
    10. 			//_head->_prev = newnode;
    11.  
    12. 			insert(end(), x);
    13. 		}
    14. 		void push_front(const T& x)
    15. 		{
    16. 			insert(begin(), x);
    17. 		}
    18.  
    19. 		void pop_back()
    20. 		{
    21. 			erase(--end());
    22. 		}
    23. 		void pop_front()
    24. 		{
    25. 			erase(begin());
    26. 		}

    clear

    复用 erase，只保留头结点。

    1.  
    2. 		void clear()
    3. 		{/*
    4. 			iterator it = begin();
    5. 			while (it != end())
    6. 			{
    7. 				iterator del = it++;
    8. 				delete del._node;
    9. 			}
    10. 			_head->_next = _head;
    11. 			_head->_prev = _head;*/
    12. 			iterator it = begin();
    13. 			while (it != end())
    14. 			{
    15. 				iterator del = it++;
    16. 				erase(del);
    17. 			}
    18. 		}

    五、反向迭代器的模拟实现

    反向迭代器有一点非常重要，就是rbegin和rend的位置。

    我们所知道的begin就是指向数据的第一个元素，然而end是指向最后一个元素的后一个位置。

    那么反向迭代器呢，rbegin是指向数据的最后一个数据，rend是指向数据的第一个数据的前一个。

    也就是如图所示的情况：

     可是，list的反向迭代器的源代码却不是这样实现的，而是如图所示：

     可是为什么这么做呢？,难道只是为了强迫症吗？

    其实不然，我们可以发现list这样做的话begin与rend和end和rbegin有很好的的对称性，也印证了为什么我们在vector和string的时候不对反向迭代器进行模拟实现，因为当我们模拟实现了list这个反向迭代器之后，我们的vector和string可以直接使用，就是因为这个很好的对称性！

    那么现在有一个问题，我们既然把rend和rbegin这样都向后移动了一位，那我们解引用的时候，也就是通过rend和rbegin拿到他们对应的值不就乱套了，所以我们此时对 *  运算符进行重载的时候很好的避免了这一点，这也就是为什么下边代码中 * 运算符重载返回的是 return *--prev;

    1.  
    2. namespace mwb
    3. {
    4. 	//Iterator是哪个容器的迭代器，reverse_iterator就可以
    5. 	//适配出哪个容器的反向迭代器。复用的体现
    6. 	template <class Iterator, class Ref, class Ptr>
    7. 	class reverse_iterator
    8. 	{
    9. 		typedef reverse_iterator self;
    10. 	public:
    11. 		reverse_iterator(Iterator it)
    12. 			:_it(it)
    13. 		{}
    14. 		
    15. 		Ref operator*()
    16. 		{
    17. 			//return *_it;
    18. 			Iterator prev = _it;
    19. 			return *--prev;
    20. 		}
    21.  
    22. 		Ptr operator->()
    23. 		{
    24. 			return &operator*();
    25. 		}
    26. 		self& operator++()
    27. 		{
    28. 			_it--;
    29. 			return *this;
    30. 		}
    31. 		self& operator--()
    32. 		{
    33. 			_it--;
    34. 			return *this;
    35. 		}
    36. 		bool operator!= (const self& rit) const
    37. 		{
    38. 			return _it != rit._it;
    39. 		}
    40. 		
    41. 	private:
    42. 		Iterator _it;
    43. 	};
    44.  
    45. }

    六、完整代码 

    reverse_iterator.h

    1. #pragma once
    2.  
    3. namespace mwb
    4. {
    5. 	//Iterator是哪个容器的迭代器，reverse_iterator就可以
    6. 	//适配出哪个容器的反向迭代器。复用的体现
    7. 	template <class Iterator, class Ref, class Ptr>
    8. 	class reverse_iterator
    9. 	{
    10. 		typedef reverse_iterator self;
    11. 	public:
    12. 		reverse_iterator(Iterator it)
    13. 			:_it(it)
    14. 		{}
    15. 		
    16. 		Ref operator*()
    17. 		{
    18. 			//return *_it;
    19. 			Iterator prev = _it;
    20. 			return *--prev;
    21. 		}
    22.  
    23. 		Ptr operator->()
    24. 		{
    25. 			return &operator*();
    26. 		}
    27. 		self& operator++()
    28. 		{
    29. 			_it--;
    30. 			return *this;
    31. 		}
    32. 		self& operator--()
    33. 		{
    34. 			_it--;
    35. 			return *this;
    36. 		}
    37. 		bool operator!= (const self& rit) const
    38. 		{
    39. 			return _it != rit._it;
    40. 		}
    41. 		
    42. 	private:
    43. 		Iterator _it;
    44. 	};
    45.  
    46. }

    list.h

    1. #pragma once
    2. #include"reverse_iterator.h"
    3. namespace mwb
    4. {
    5.  
    6. 	template<class T>//类模板
    7. 	struct ListNode
    8. 	{
    9. 		ListNode* _next;
    10. 		ListNode* _prev;
    11. 		T _data;
    12.  
    13. 		ListNode(const T& data = T())
    14. 			:_next(nullptr)
    15. 			, _prev(nullptr)
    16. 			, _data(data)
    17. 		{}
    18. 	};
    19.  
    20.  
    21.  
    22.  
    23.  
    24. 	//迭代器
    25. 	template<class T, class Ref, class Ptr>//类模板
    26.  
    27. 	struct __list_iterator//自定义类型
    28. 	{
    29. 		typedef ListNode Node;
    30. 		typedef __list_iterator self;
    31. 		//typedef __list_iterator
    32. 		Node* _node;
    33.  
    34. 		//构造函数
    35. 		__list_iterator(Node* x)
    36. 			:_node(x)
    37. 		{}
    38.  
    39. 		//it2=it1 浅拷贝
    40. 		//拷贝构造和赋值重载是否需要我们自己实现
    41. 		//析构呢？
    42. 		// 迭代器是借助节点的指针访问修改链表
    43. 		//节点属于链表，不属于迭代器，所以他不管释放
    44. 		//都不需要自己实现，默认生成的即可
    45.  
    46. 		//需要T&传T& 需要const T& 就传 const T&
    47. 		Ref operator*()//由于用的引用，所以可读可写
    48. 		{
    49. 			return _node->_data;
    50. 		}
    51.  
    52. 		Ptr operator->()
    53. 		{
    54. 			return &_node->_data;
    55. 		}
    56. 		//++it
    57. 		self& operator++()
    58. 		{
    59. 			_node = _node->_next;
    60. 			return *this;
    61. 		}
    62. 		//it++
    63. 		self operator++(int)
    64. 		{
    65. 			self tmp(*this);
    66. 			//保存++之前的值以便于返回
    67. 			_node = _node->_next;
    68. 			return tmp;
    69. 		}
    70.  
    71. 		//--it
    72. 		self& operator--()
    73. 		{
    74. 			_node = _node->_prev;
    75. 			return *this;
    76. 		}
    77. 		//it--
    78. 		self operator--(int)
    79. 		{
    80. 			self tmp(*this);
    81. 			//保存--之前的值以便于返回
    82. 			_node = _node->_prev;
    83. 			return tmp;
    84. 		}
    85. 		bool operator!=(const self& it) const
    86. 		{
    87. 			return _node != it._node;
    88. 		}
    89. 		bool operator==(const self& it) const
    90. 		{
    91. 			return _node == it._node;
    92. 		}
    93. 	};
    94.  
    95.  
    96.  
    97. 	template<class T>//类模板
    98. 	class list
    99. 	{
    100. 		typedef ListNode Node;
    101. 	public:
    102. 		typedef __list_iterator iterator;
    103. 		typedef __list_iteratorconst T&, const T*> const_iterator;
    104.  
    105. 		typedef reverse_iteratorconst T&, const T*> const_reverse_iterator;
    106. 		typedef reverse_iterator reverse_iterator;
    107.  
    108. 		reverse_iterator rbegin()
    109. 		{
    110. 			return reverse_iterator(end());
    111. 		}
    112. 		reverse_iterator rend()
    113. 		{
    114. 			return reverse_iterator(begin());
    115. 		}
    116. 		iterator begin()
    117. 		{
    118. 			return iterator(_head->_next);
    119. 		}
    120. 		iterator end()
    121. 		{
    122. 			return iterator(_head);
    123. 		}
    124. 		const_iterator begin() const
    125. 		{
    126. 			return const_iterator(_head->_next);
    127. 		}
    128. 		const_iterator end() const
    129. 		{
    130. 			return const_iterator(_head);
    131. 		}
    132. 		//
    133. 		list()
    134. 		{
    135. 			_head = new Node();
    136. 			_head->_next = _head;
    137. 			_head->_prev = _head;
    138. 		}
    139.  
    140. 		list(size_t n, const T& val = T())
    141. 		{
    142. 			_head = new Node();
    143. 			_head->_next = _head;
    144. 			_head->_prev = _head;
    145. 			for (size_t i = 0; i < n; i++)
    146. 			{
    147. 				push_back(val);
    148. 			}
    149. 		}
    150. 		list(int n, const T& val = T())
    151. 		{
    152. 			_head = new Node();
    153. 			_head->_next = _head;
    154. 			_head->_prev = _head;
    155. 			for (int i = 0; i < n; i++)
    156. 			{
    157. 				push_back(val);
    158. 			}
    159. 		}
    160.  
    161. 		template<class InputIterator>
    162. 		list(InputIterator first, InputIterator last)
    163. 		{
    164. 			_head = new Node();
    165. 			_head->_next = _head;
    166. 			_head->_prev = _head;
    167. 			while (first != last)
    168. 			{
    169. 				push_back(*first);
    170. 				first++;
    171. 			}
    172. 		}
    173.  
    174. 		//现代写法
    175. 		//lt2(lt1)
    176. 		list(const list<int>& lt)
    177. 		{
    178. 			_head = new Node();
    179. 			_head->_next = _head;
    180. 			_head->_prev = _head;
    181. 			list tmp(lt.begin(), lt.end());
    182. 			std::swap(_head, tmp._head);
    183. 		}
    184. 		list<int>& operator=(list lt)
    185. 		{
    186. 			std::swap(_head, lt._head);
    187.  
    188. 			return *this;
    189. 		}
    190. 		//传统写法
    191. 		lt2(lt1)
    192. 		//list(const list& lt)
    193. 		//{
    194. 		//	_head = new Node();
    195. 		//	_head->_next = _head;
    196. 		//	_head->_prev = _head;
    197. 		//	for (auto e : lt)
    198. 		//	{
    199. 		//		push_back(e);  
    200. 		//	}
    201. 		//}
    202.  
    203. 		lt2=lt1
    204. 		//list& operator=(const list& lt)
    205. 		//{
    206. 		//	if (this != <)
    207. 		//	{
    208. 		//		clear();
    209. 		//		for (auto e : lt)
    210. 		//		{
    211. 		//			push_back(e);
    212. 		//		}
    213. 		//	}
    214. 		//	return *this;
    215. 		//}
    216.  
    217. 		~list()
    218. 		{
    219. 			clear();
    220.  
    221. 			delete _head;
    222. 			_head = nullptr;
    223.  
    224. 		}
    225. 		void clear()
    226. 		{/*
    227. 			iterator it = begin();
    228. 			while (it != end())
    229. 			{
    230. 				iterator del = it++;
    231. 				delete del._node;
    232. 			}
    233. 			_head->_next = _head;
    234. 			_head->_prev = _head;*/
    235. 			iterator it = begin();
    236. 			while (it != end())
    237. 			{
    238. 				iterator del = it++;
    239. 				erase(del);
    240. 			}
    241. 		}
    242. 		void push_back(const T& x)
    243. 		{
    244. 			//Node* tail = _head->_prev;//记录最后的尾结点
    245. 			//Node* newnode = new Node(x);//创建新结点
    246. 			空节点也适用
    247. 			链接各个节点之间的关系
    248. 			//tail->_next = newnode;
    249. 			//newnode->_prev = tail;
    250. 			//newnode->_next = _head;
    251. 			//_head->_prev = newnode;
    252.  
    253. 			insert(end(), x);
    254. 		}
    255. 		void push_front(const T& x)
    256. 		{
    257. 			insert(begin(), x);
    258. 		}
    259. 		iterator insert(iterator pos, const T& x)
    260. 		{
    261. 			Node* cur = pos._node;
    262. 			Node* prev = cur->_prev;
    263.  
    264. 			Node* newnode = new Node(x);
    265.  
    266. 			prev->_next = newnode;
    267. 			newnode->_prev = prev;
    268. 			newnode->_next = cur;
    269. 			cur->_prev = newnode;
    270. 			return iterator(newnode);
    271. 		}
    272. 		void pop_back()
    273. 		{
    274. 			erase(--end());
    275. 		}
    276. 		void pop_front()
    277. 		{
    278. 			erase(begin());
    279. 		}
    280. 		iterator erase(iterator pos)
    281. 		{
    282. 			assert(pos != end());
    283.  
    284. 			Node* prev = pos._node->_prev;
    285. 			Node* next = pos._node->_next;
    286.  
    287. 			delete pos._node;
    288. 			prev->_next = next;
    289. 			next->_prev = prev;
    290. 			return iterator(next);
    291. 		}
    292. 	private:
    293. 		Node* _head;
    294. 	};
    295. 	//void print_list(const list& lt)
    296. 	//{
    297. 	//	list::iterator it = lt.begin();
    298. 	//	while (it != lt.end())
    299. 	//	{
    300. 	//		cout << *it << " ";
    301. 	//		it++;
    302. 	//	}
    303. 	//	cout << endl;
    304.  
    305. 	//}
    306. 	void test_list1()
    307. 	{
    308. 		list<int> lt;
    309. 		lt.push_back(1);
    310. 		lt.push_back(2);
    311. 		lt.push_back(3);
    312. 		lt.push_back(4);
    313.  
    314. 		list<int>::iterator it = lt.begin();
    315. 		while (it != lt.end())
    316. 		{
    317. 			*it *= 2;
    318. 			cout << *it << " ";
    319. 			it++;
    320. 		}
    321. 		cout << endl;
    322. 	}
    323. 	struct Date
    324. 	{
    325. 		int _year;
    326. 		int _month;
    327. 		int _day;
    328.  
    329. 		Date(int year = 1, int month = 1, int day = 1)
    330. 			:_year(year)
    331. 			, _month(month)
    332. 			, _day(day)
    333. 		{}
    334. 	};
    335. 	void test_list2()
    336. 	{
    337. 		list lt;
    338. 		lt.push_back(Date(2022, 3, 12));
    339. 		lt.push_back(Date(2022, 3, 13));
    340. 		lt.push_back(Date(2022, 3, 14));
    341. 		//普通指针用解引用访问，结构体指针用箭头
    342. 		list::iterator it = lt.begin();
    343. 		while (it != lt.end())
    344. 		{
    345. 			//(*it)代表结点的数据也就是日期类的对象
    346. 			/*cout << (*it)._year << " ";
    347. 			cout << (*it)._month << " ";
    348. 			cout << (*it)._day << " ";
    349. 			cout << endl;*/
    350. 			cout << it->_year << " ";
    351. 			cout << it->_month << " ";
    352. 			cout << it->_day << " ";
    353. 			cout << endl;
    354. 			it++;
    355. 		}
    356. 		cout << endl;
    357. 	}
    358. 	void test_list3()
    359. 	{
    360. 		list<int> lt1;
    361. 		lt1.push_back(1);
    362. 		lt1.push_back(2);
    363. 		lt1.push_back(3);
    364.  
    365. 		list<int> lt2(lt1);
    366. 		for (auto e : lt2)
    367. 		{
    368. 			cout << e << " ";
    369. 		}
    370. 		cout << endl;
    371.  
    372.  
    373. 		list<int> lt3;
    374. 		lt3.push_back(10);
    375. 		lt3.push_back(10);
    376. 		lt3.push_back(10);
    377. 		lt3.push_back(10);
    378.  
    379. 		lt1 = lt3;
    380. 		for (auto e : lt1)
    381. 		{
    382. 			cout << e << " ";
    383. 		}
    384. 		cout << endl;
    385. 	}
    386. 	void test_list4()
    387. 	{
    388. 		list lt1(5, Date(2022, 3, 15));
    389. 		for (auto e : lt1)
    390. 		{
    391. 			cout << e._year << "/" << e._month << "/" << e._day << endl;
    392. 		}
    393. 		cout << endl;
    394.  
    395. 		list<int> lt2(5, 1);
    396. 		for (auto e : lt2)
    397. 		{
    398. 			cout << e << " ";
    399. 		}
    400. 		cout << endl;
    401. 	}
    402. 	void test_list5()
    403. 	{
    404. 		list<int> lt1;
    405. 		lt1.push_back(1);
    406. 		lt1.push_back(2);
    407. 		lt1.push_back(3);
    408. 		lt1.push_back(4);
    409.  
    410. 		list<int>::iterator it = lt1.begin();
    411. 		while (it != lt1.end())
    412. 		{
    413. 			//*it *= 2; // 修改
    414. 			cout << *it << " ";
    415. 			++it;
    416. 		}
    417. 		cout << endl;
    418.  
    419. 		list<int>::reverse_iterator rit = lt1.rbegin();
    420. 		while (rit != lt1.rend())
    421. 		{
    422. 			cout << *rit << " ";
    423. 			++rit;
    424. 		}
    425. 		cout << endl;
    426. 	}
    427. }

    七、vector与list优劣

    vector缺陷：

    连续的物理空间，是优势也是劣势。

    劣势：

    1、空间不够要增容，增容代价比较大。

    2、可能存在一定空间浪费。按需申请，会导致频繁增容，所以一般都会2倍左右扩容。

    3、头部或者中部插入删除需要挪动数据，效率低下。

    list优势：

    1、按需申请释放空间

    2、list任意位置支持O(1)插入删除。

    综上所述：

    本质vector和list是互补的两个数据结构。

  • 相关阅读:
    人工智能、深度学习、机器学习常见面试题321~324
    C++入门学习笔记
    零基础学韩语-看韩剧追欧巴
    SpringBoot整合Mybatis-Plus
    6.判断是不是闰年
    基于PLC控制的门禁系统设计【附源码】
    JavaScript使用Ajax
    Azkaban使用
    TMP451
    HTTP缓存小结
  • 原文地址：https://blog.csdn.net/m0_57249790/article/details/127637591