• C++-list实现相关细节和问题

           前言：C++中的最后一个容器就是list，list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。下面我们就来模仿官方库中的list，自行实现一个list，并从中总结实现细节和经验。

    目录

    1.基本节点类和链表类的框架

    数据节点类

    list节点类

    尾插函数

    2.迭代器类的实现

    迭代器的分类及实现

    为什么不用析构函数和深拷贝？

    为什么能使用前置++就不用后置++？

    怪异的" -> "?地址解引用重载

    如何在list类中使用迭代器

    3.插入删除函数

    4.const迭代器和拷贝赋值函数

    const iterator和const_iterator？......有区别吗？

    实现const_iterator

    模板参数列表泛式编程

    迭代器类终极版

    拷贝构造和赋值函数

    5.必须采用typename格式的场景

    6.源码看这里

    list.h

    test.cpp

     

    1.基本节点类和链表类的框架

    数据节点类

            list的实现不同于其他的容器，比如vector等，list的底层是一个双向链表结构，每一个节点都由三部分组成，分别是数据，上一个节点和下一个节点，所以，对于list所存储的数据成员，我们需要单独开一个结构体来表示链表中的每一个数据成员，

    1. template<class T>
    2. 	struct list_node //链表的数据成员结构
    3. 	{
    4. 		T _data;
    5. 		list_node* _next;
    6. 		list_node* _prev;
    7.  
    8. 		list_node(const T& x = T())//给一个匿名对象
    9. 			:_data(x)
    10. 			, _next(nullptr)
    11. 			, _prev(nullptr)
    12. 		{}
    13. 	};

    list节点类

    接着就是list类的创建，我们知道，双线链表大致的结构如下所示，我们list的设计也基本遵循这个框架，

    1. template<class T>
    2. 	class list {
    3. 		typedef list_node Node;
    4. 	public:
    5.           void empty_init()//空list初始化
    6. 		{
    7. 			_head = new Node;
    8. 			_head->_next = _head;
    9. 			_head->_prev = _head;
    10. 			_size = 0;
    11. 		}
    12. 		list()
    13. 		{
    14. 			empty_init();
    15. 		}
    16.         size_t size()
    17. 		{
    18. 			return _size;
    19. 		}
    20. 	private:
    21. 		Node* _head;//虚拟的头结点，实际上第一个节点在该节点的下一个位置上，而尾结点end就是头结点的位置，这样，方便我们构成双向链表
    22. 		size_t _size;//链表长度，因为遍历一遍链表需要花费大量的时间，所以建议当做数据成员存储
    23. 	};

    尾插函数

    在上面功能的基础上，我们就可以实现简易的push_back函数了，这里就不再赘述，

    1. void push_back(const T& x)
    2. 		{
    3. 			//此时我们的最后一个元素是头结点的上一个元素，因为我们是一个双向循环链表,现在head和end都指向哨兵节点
    4. 			Node* tail = _head->_prev;
    5. 			Node* newnode = new Node(x);
    6. 			tail->_next = newnode;
    7. 			newnode->_prev = tail;
    8. 			newnode->_next = _head;
    9. 			_head->_prev = newnode;
    10. 			
    11. 		}

    2.迭代器类的实现

    迭代器的分类及实现

    list官方库中对迭代器的要求：

           对于我们的list中的迭代器来说，我们常见的迭代器的使用需要满足，比如取数据，修改数据等，但是我们的list存储的实际上是一个个结构体，对结构体解引用编译器不认识，并且我们的链表存储并不是顺序表的顺序结构，而是随机存储结构，简单的对于迭代器地址增加并不能找到下一个数据，而且还涉及多种迭代器类型的使用，比如反向迭代器等，所以，list的迭代器需要具备取数据，++或者--自动到目标节点等等的功能，涉及重载函数等功能，因此，为了方便我们的使用，我们便让迭代器自成一个类，采用封装加重载的方式，这样我们就可以创建迭代器对象来更加方便地访问数据成员和其他操作。

    为什么不用析构函数和深拷贝？

             迭代器本身作为一个链表的访问工具，但是如果写析构函数，在迭代器对象析构时，因为迭代器本身是指向链表节点的一个指针，释放指针必然会导致节点被影响，这是我们不允许的，所以不能写析构函数，采用默认的空操作的析构函数即可。

           而对于迭代器的深浅拷贝问题，迭代器本质上是节点的指针，但是并不是迭代器所指向的资源就归迭代器管理，我们只是把迭代器作为遍历和修改的工具，本质上就是让迭代器移动遍历，因此只需要浅拷贝链表节点即可。

    为什么能使用前置++就不用后置++？

            我们看见上面的前置和后置++的区别在于一个返回本对象，另一个则返回本对象的拷贝，返回对象的拷贝的后置++在返回时返回的是临时对象tmp的拷贝，也就需要再次调用我们自定义的拷贝构造函数，在时间上不如前置++效率高。

    怪异的" -> "?地址解引用重载

    我们在上面的函数中有这样一个函数重载：

         当数据存在自定义对象时，比如我们的数据成员就是一个结构体，我们链表的节点保存的是结构体指针，那么我们如何取获得结构体中的数据成员的值呢，我们需要对迭代器进行解引用操作才能获取具体的元素的值，除了直接用（*it).xx来访问，我们还经常采用一种方式，就是it->xx的方式，上面这个函数就是我们需要采用该解引用方法时所需要重载的->运算符，重载完后即可正常使用地址解引用操作。

     

    如何在list类中使用迭代器

             现在我们的迭代器自成一个类，但是我们需要在list类中使用它，我们就可以将迭代器定义在我们的类域内即可调用：

     

    3.插入删除函数

          在官方库的inert和erase函数中，更加推荐使用迭代器作为返回值，在容器中，我们选择元素一般都会以迭代器的位置为基准，对于insert函数，因为不会涉及扩容问题，也就不存在迭代器失效问题，所以，我们可以返回插入元素位置的迭代器，方便对迭代器的再使用，同时对于erase函数，删除迭代器位置上的元素，节点删除必然会导致节点空间的释放，将必然导致迭代器失效，所以我们根据官方的文档中的解决方法，索性直接返回被删除元素的下一个位置的迭代器即可。

    1. iterator insert(iterator pos,const T&x)//我们和官方文档的函数保持一致，返回新插入元素的迭代器(在pos位置之前插入)
    2. 		{
    3. 			Node* newnode = new Node(x);//因为不存在扩容，所以不存在迭代器失效问题
    4. 			Node* prev = (pos._node)->_prev;
    5. 			prev->_next = newnode;
    6. 			newnode->_prev = prev;
    7.  
    8. 			newnode->_next = pos._node;
    9. 			(pos._node)->_prev = newnode;
    10. 			++_size;
    11. 			return iterator(newnode);//类型转换
    12. 		}
    13. 		iterator erase(iterator pos)//返回删除元素的下一个位置
    14. 		{
    15. 			Node* cur = pos._node;
    16. 			Node* prev = cur->_prev;
    17. 			Node* next = cur->_next;
    18.  
    19. 			delete cur;
    20. 			//释放掉后迭代器失效
    21. 			prev->_next = next;
    22. 			next->_prev = prev;
    23. 			--_size;
    24. 			return iterator(next);
    25. 		}

    因为迭代器的使用，我们就可以顺势写出一下的常用函数接口：

    1. ~list()
    2. {
    3. 	clear();//不释放头结点
    4.  
    5.     delete _head;
    6. 	_head = nullptr;
    7. }
    8.  
    9. void clear()
    10. {
    11. 	iterator it = begin();
    12. 	while (it != end())
    13. 	{
    14. 		it = erase(it);
    15. 	}
    16. }
    17. void push_back(const T& x)
    18. {
    19. 	insert(end(), x);//优化
    20. }
    21.  
    22. void push_front(const T& x)
    23. {
    24. 	insert(begin(), x);
    25. }
    26.  
    27. void pop_front()
    28. {
    29. 	erase(begin());
    30. }
    31.  
    32. void pop_back()
    33. {
    34. 	erase(--end());
    35. }

    4.const迭代器和拷贝赋值函数

    const iterator和const_iterator？......有区别吗？

          首先，我们要知道，const迭代器是修饰迭代器所指向的元素本身不能被改变而不是修饰迭代器本身的指向不能被改变，const迭代器的类型相当于const T*而不是T*const，而const iterator相当于直接修饰了迭代器，相当于定死了迭代器就是指向某一个元素，这违背了我们使用迭代器作为遍历工具的原则，const迭代器产生就是为了遍历只读元素使用，而const_iterator就是这样一种特定的迭代器类型，这一点要做好区分。

    实现const_iterator

         要实现const迭代器，我们就要知道，在原迭代器类中，哪些函数时能够影响到修改数据成员的，显然，只有对迭代器进行解引用才会影响数据修改，所以，我们只需要在原来的迭代器类的基础上，限定重载的解引用运算符即可，

    当然，我们需要在list类中引入const迭代器类到类域中去：

    模板参数列表泛式编程

         上面的const迭代器虽然实现了，但是我们要写两个迭代器类，而且两个迭代器类只有重载解引用操作时才会有不同的行为，而我们为了这个要多些一个类，实在是太麻烦了，我们就来看一看C++祖师爷是如何解决的吧，

            

           这也太香了，相当于模板参数列表里增加了两个模板参数，返回值根据参数来影响重载运算符的返回值类型，不愧是祖师爷，这也是泛式编程的思想，封装屏蔽了底层的实现细节，提供统一的访问方式。

    不多说了，拿来吧你~~

    迭代器类终极版
    1. template<class T,class Ref,class Ptr>
    2. 	struct __list_iterator  //我们尽量与官方文档的保持一致
    3. 	{
    4. 		typedef list_node Node;
    5. 		typedef __list_iterator self;//迭代器对象起别名
    6.  
    7. 		Node* _node;
    8.  
    9. 		__list_iterator(Node* node)//节点的指针可以隐式类型转换成迭代器
    10. 			:_node(node)
    11. 		{}
    12. 		//对迭代器需要进行++和解引用操作，注意，迭代器的解引用应该是得到数据本身，所以我们的解引用也需要重载
    13. 		self operator++()//前置++
    14. 		{
    15. 			_node = _node->_next;
    16. 			return *this;
    17. 		}
    18. 		self& operator--()//前置--
    19. 		{
    20. 			_node = _node->_prev;
    21. 			return *this;
    22. 		}
    23. 		self& operator++(int)//后置++
    24. 		{
    25. 			self temp(*this);
    26. 			_node = _node->_next;
    27. 			return temp;
    28. 		}
    29. 		self& operator--(int)//后置++
    30. 		{
    31. 			self temp(*this);
    32. 			_node = _node->_prev;
    33. 			return temp;
    34. 		}
    35. 		//对于影响const迭代器调用的功能的函数传不同的返回值类型时使用
    36. 		Ref operator*()
    37. 		{
    38. 			return _node->_data;
    39. 		}
    40. 		Ptr operator->()
    41. 		{
    42. 			return &(_node->_data);
    43. 		}
    44. 		bool operator!=(const self& s)//迭代器比较结束条件判断
    45. 		{
    46. 			return _node != s._node;
    47. 		}
    48. 		bool operator==(const self& s)
    49. 		{
    50. 			return _node == s._node;
    51. 		}
    52. 	};

    拷贝构造和赋值函数

           之所以把这一个知识放在迭代器实现完全之后再将，是因为我们在拷贝和赋值时经常需要传递const对象，而我们前面的迭代器是非const版本，无法对const对象进行解引用操作，也就导致了无法拷贝const对象，所以放在这里进行讲解，但是此时这两个函数用我们自己提供的接口完全可以实现，这里也不涉及深浅拷贝的问题，就直接给出了，

    1. //拷贝构造
    2. 		list(const list& lt)
    3. 		{
    4. 			empty_init();
    5. 			for (auto e : lt)//迭代器重载后取得是数据元素，故可以使用
    6. 				push_back(e);
    7. 		}
    8.  
    9. //赋值操作
    10. 		list& operator=(const list& lt)//返回值也可以写list类型，类内均正确,但是为规范不建议
    11. 		{
    12. 			if (this != <)
    13. 			{
    14. 				clear();//先清空原来的链表,但头结点还在
    15. 				for (auto e : lt)
    16. 					push_back(e);
    17. 			}
    18. 			return *this;
    19. 		}

    5.必须采用typename格式的场景

    基于以上的代码，我们来运行下面的测试样例：

    1. template<class T>
    2. 	void print_list(const list& lt)
    3. 	{
    4. 	    list::const_iterator it = lt.begin();
    5. 		while (it != lt.end())
    6. 		{
    7. 			cout << *it << " ";
    8. 			it++;
    9. 		}
    10. 		cout << endl;
    11. 	}
    12. 	void test_list4()
    13. 	{
    14. 		list<int> lt;
    15. 		lt.push_back(1);
    16. 		lt.push_back(2);
    17. 		lt.push_back(3);
    18. 		lt.push_back(4);
    19. 		lt.push_back(5);
    20. 		print_list(lt);
    21.  
    22. 		list lt2;
    23. 		lt2.push_back("1111111111111");
    24. 		lt2.push_back("1111111111111");
    25. 		lt2.push_back("1111111111111");
    26. 		lt2.push_back("1111111111111");
    27. 		lt2.push_back("1111111111111");
    28. 		print_list(lt2);
    29. 	}

    看上去没什么问题吧，我们也用了类模板，应该是能跑起来的，但是实际上，

    这上面说，让我们在迭代器类型前面加一个typename，这是为什么呢？

         在编译阶段，编译器只能看到我们的list是list类型的，模板还没有被实例化，导致编译器无法在对应的类中找到类域下的成员，向上面的const_iterator，编译器因为list是未实例化的模板，所以也无法在确定的类域内找到const_iterator相应的实现和功能，所以编译器不认识这个变量是什么，也就导致了出错，前面加一个typename是告诉编译器，这里是一个类型，等list实例化再去类里面去取。

    1. void test_list4()
    2. 	{
    3. 		list<int> lt;
    4. 		lt.push_back(1);
    5. 		lt.push_back(2);
    6. 		lt.push_back(3);
    7. 		lt.push_back(4);
    8. 		lt.push_back(5);
    9. 		print_container(lt);
    10.  
    11. 		list lt2;
    12. 		lt2.push_back("1111111111111");
    13. 		lt2.push_back("1111111111111");
    14. 		lt2.push_back("1111111111111");
    15. 		lt2.push_back("1111111111111");
    16. 		lt2.push_back("1111111111111");
    17. 		print_container(lt2);
    18.  
    19. 		vector v;
    20. 		v.push_back("222222222222");
    21. 		v.push_back("222222222222");
    22. 		v.push_back("222222222222");
    23. 		v.push_back("222222222222");
    24. 		v.push_back("222222222222");
    25. 		print_container(v);
    26.  
    27. 	}

    6.源码看这里

    list.h

    1. #pragma once
    2. #include 
    3. namespace my_std
    4. {
    5. 	template<class T>
    6. 	struct list_node //链表的数据成员结构
    7. 	{
    8. 		T _data;
    9. 		list_node* _next;
    10. 		list_node* _prev;
    11.  
    12. 		list_node(const T& x = T())//给一个匿名对象
    13. 			:_data(x)
    14. 			, _next(nullptr)
    15. 			, _prev(nullptr)
    16. 		{} 
    17. 	};
    18.  
    19. 	
    20. 	template<class T,class Ref,class Ptr>
    21. 	struct __list_iterator  //我们尽量与官方文档的保持一致
    22. 	{
    23. 		typedef list_node Node;
    24. 		typedef __list_iterator self;//迭代器对象起别名
    25.  
    26. 		Node* _node;
    27.  
    28. 		__list_iterator(Node* node)//节点的指针可以隐式类型转换成迭代器
    29. 			:_node(node)
    30. 		{}
    31. 		//对迭代器需要进行++和解引用操作，注意，迭代器的解引用应该是得到数据本身，所以我们的解引用也需要重载
    32. 		self operator++()//前置++
    33. 		{
    34. 			_node = _node->_next;
    35. 			return *this;
    36. 		}
    37. 		self& operator--()//前置--
    38. 		{
    39. 			_node = _node->_prev;
    40. 			return *this;
    41. 		}
    42. 		self& operator++(int)//后置++
    43. 		{
    44. 			self temp(*this);
    45. 			_node = _node->_next;
    46. 			return temp;
    47. 		}
    48. 		self& operator--(int)//后置++
    49. 		{
    50. 			self temp(*this);
    51. 			_node = _node->_prev;
    52. 			return temp;
    53. 		}
    54. 		//对于影响const迭代器调用的功能的函数传不同的返回值类型时使用
    55. 		Ref operator*()
    56. 		{
    57. 			return _node->_data;
    58. 		}
    59. 		Ptr operator->()
    60. 		{
    61. 			return &(_node->_data);
    62. 		}
    63. 		bool operator!=(const self& s)//迭代器比较结束条件判断
    64. 		{
    65. 			return _node != s._node;
    66. 		}
    67. 		bool operator==(const self& s)
    68. 		{
    69. 			return _node == s._node;
    70. 		}
    71. 	};
    72. 	template<class T>
    73. 	class list {
    74. 	public:
    75. 		typedef list_node Node;
    76. 		typedef __list_iterator iterator;
    77. 		typedef __list_iteratorconst T&,const T*> const_iterator;
    78.  
    79. 		iterator begin()
    80. 		{
    81. 			return _head->_next;
    82. 		}
    83. 		iterator end()
    84. 		{
    85. 			return _head;
    86. 		}
    87. 		const_iterator begin()const 
    88. 		{
    89. 			return const_iterator(_head->_next);//含隐式类型转换，自己写转不转换都行
    90. 		}
    91. 		const_iterator end()const
    92. 		{
    93. 			return _head;
    94. 		}
    95. 		void empty_init()//空list初始化
    96. 		{
    97. 			_head = new Node;
    98. 			_head->_next = _head;
    99. 			_head->_prev = _head;
    100. 			_size = 0;
    101. 		}
    102. 		list()
    103. 		{
    104. 			empty_init();
    105. 		}
    106. 		//拷贝构造
    107. 		list(const list& lt)
    108. 		{
    109. 			empty_init();
    110. 			for (auto e : lt)//迭代器取得是数据元素，故可以使用
    111. 				push_back(e);
    112. 		}
    113.  
    114. 		//赋值操作
    115. 		list& operator=(const list& lt)//返回值也可以写list类型，类内均正确,但是为规范不建议
    116. 		{
    117. 			if (this != <)
    118. 			{
    119. 				clear();//先清空原来的链表,但头结点还在
    120. 				for (auto e : lt)
    121. 					push_back(e);
    122. 			}
    123. 			return *this;
    124. 		}
    125. 		~list()
    126. 		{
    127. 			clear();//不释放头结点
    128.  
    129. 			delete _head;
    130. 			_head = nullptr;
    131. 		}
    132.  
    133. 		void clear()
    134. 		{
    135. 			iterator it = begin();
    136. 			while (it != end())
    137. 			{
    138. 				it = erase(it);
    139. 			}
    140. 		}
    141. 		void push_back(const T& x)
    142. 		{
    143. 			//此时我们的最后一个元素是头结点的上一个元素，因为我们是一个双向循环链表,现在head和end都指向哨兵节点
    144. 			/*Node* tail = _head->_prev;
    145. 			Node* newnode = new Node(x);
    146. 			tail->_next = newnode;
    147. 			newnode->_prev = tail;
    148. 			newnode->_next = _head;
    149. 			_head->_prev = newnode;*/
    150. 			insert(end(), x);
    151. 		}
    152. 		void push_front(const T& x)
    153. 		{
    154. 			insert(begin(), x);
    155. 		}
    156.  
    157. 		void pop_front()
    158. 		{
    159. 			erase(begin());
    160. 		}
    161.  
    162. 		void pop_back()
    163. 		{
    164. 			erase(--end());
    165. 		}
    166. 		iterator insert(iterator pos,const T&x)//我们和官方文档的函数保持一致，返回新插入元素的迭代器(在pos位置之前插入)
    167. 		{
    168. 			Node* newnode = new Node(x);//因为不存在扩容，所以不存在迭代器失效问题
    169. 			Node* prev = (pos._node)->_prev;
    170. 			prev->_next = newnode;
    171. 			newnode->_prev = prev;
    172.  
    173. 			newnode->_next = pos._node;
    174. 			(pos._node)->_prev = newnode;
    175. 			++_size;
    176. 			return iterator(newnode);//类型转换
    177. 		}
    178. 		iterator erase(iterator pos)//返回删除元素的下一个位置
    179. 		{
    180. 			Node* cur = pos._node;
    181. 			Node* prev = cur->_prev;
    182. 			Node* next = cur->_next;
    183.  
    184. 			delete cur;
    185. 			//释放掉后迭代器失效
    186. 			prev->_next = next;
    187. 			next->_prev = prev;
    188. 			--_size;
    189. 			return iterator(next);
    190. 		}
    191. 		size_t size()
    192. 		{
    193. 			return _size;
    194. 		}
    195. 	private:
    196. 		Node* _head;//虚拟的头结点，实际上第一个节点在该节点的下一个位置上，而尾结点end就是头结点的位置，这样，方便我们构成双向循环链表
    197. 		size_t _size;//链表长度，因为遍历一遍链表需要花费大量的时间，所以建议当做数据成员存储
    198. 	};
    199. 	void test_list1()
    200. 	{
    201. 		list<int> lt;
    202. 		lt.push_back(1);
    203. 		lt.push_back(2);
    204. 		lt.push_back(3);
    205. 		lt.push_back(4);
    206. 		lt.push_back(5);
    207.  
    208. 		// 封装屏蔽底层差异和实现细节
    209. 		// 提供统一的访问修改遍历方式
    210. 		list<int>::iterator it = lt.begin();//迭代器需要单独编写迭代器类，以供应需求，说清楚为什么需要编写(迭代器的种类)，重载哪些运算符等
    211. 		while (it != lt.end())
    212. 		{
    213. 			*it += 20;
    214.  
    215. 			cout << *it << " ";
    216. 			it++;
    217. 		}
    218. 		cout << endl;
    219.  
    220. 		for (auto e : lt)
    221. 		{
    222. 			cout << e << " ";
    223. 		}
    224. 		cout << endl;
    225. 	}
    226. 	void test_list2()
    227. 	{
    228. 		list<int> lt;
    229. 		lt.push_back(1);
    230. 		lt.push_back(2);
    231. 		lt.push_back(3);
    232. 		lt.push_back(4);
    233. 		lt.push_back(5);
    234.  
    235. 		list<int> lt1(lt);
    236.  
    237. 		for (auto e : lt)
    238. 		{
    239. 			cout << e << " ";
    240. 		}
    241. 		cout << endl;
    242.  
    243. 		for (auto e : lt1)
    244. 		{
    245. 			cout << e << " ";
    246. 		}
    247. 		cout << endl;
    248.  
    249. 		list<int> lt2;
    250. 		lt2.push_back(10);
    251. 		lt2.push_back(20);
    252. 		lt2.push_back(30);
    253. 		lt2.push_back(40);
    254. 		lt2.push_back(50);
    255.  
    256. 		lt1 = lt2;
    257. 		for (auto e : lt1)
    258. 		{
    259. 			cout << e << " ";
    260. 		}
    261. 		cout << endl;
    262.  
    263. 		for (auto e : lt2)
    264. 		{
    265. 			cout << e << " ";
    266. 		}
    267. 		cout << endl;
    268. 	}
    269.  
    270. 	struct AA
    271. 	{
    272. 		AA(int a1 = 0, int a2 = 0)
    273. 			:_a1(a1)
    274. 			, _a2(a2)
    275. 		{}
    276.  
    277. 		int _a1;
    278. 		int _a2;
    279. 	};
    280. 	void test_list3()
    281. 	{
    282. 		list lt;
    283. 		lt.push_back(AA(1, 1));
    284. 		lt.push_back(AA(2, 2));
    285. 		lt.push_back(AA(3, 3));
    286.  
    287. 		list::iterator it = lt.begin();
    288. 		while (it != lt.end())
    289. 		{
    290. 			//cout << (*it)._a1<<" "<<(*it)._a2 << endl;
    291. 			cout << it->_a1 << " " << it->_a2 << endl;//本来应该是it->->_a1,编译器特殊处理，省略了一个->
    292. 			cout << it.operator->()->_a1 << " " << it.operator->()->_a1 << endl;//显式调用运算符重载函数
    293.  
    294.  
    295. 			++it;
    296. 		}
    297. 		cout << endl;
    298. 	}
    299.  
    300. 	//typename场景
    301. 	template<class T>
    302. 	void print_list(const list& lt)
    303. 	{
    304. 	    typename list::const_iterator it = lt.begin();
    305. 		while (it != lt.end())
    306. 		{
    307. 			cout << *it << " ";
    308. 			it++;
    309. 		}
    310. 		cout << endl;
    311. 	}
    312. 	//再抽象，我们可以将类型再抽象为容器，这样就可以打印list之外的容器的元素
    313. 	template<typename Container>
    314. 	void print_container(const Container& lt)
    315. 	{
    316. 		typename Container::const_iterator it = lt.begin();
    317. 		while (it != lt.end())
    318. 		{
    319. 			cout << *it << " ";
    320. 			it++;
    321. 		}
    322. 		cout << endl;
    323. 	}
    324. 	void test_list4()
    325. 	{
    326. 		list<int> lt;
    327. 		lt.push_back(1);
    328. 		lt.push_back(2);
    329. 		lt.push_back(3);
    330. 		lt.push_back(4);
    331. 		lt.push_back(5);
    332. 		print_container(lt);
    333.  
    334. 		list lt2;
    335. 		lt2.push_back("1111111111111");
    336. 		lt2.push_back("1111111111111");
    337. 		lt2.push_back("1111111111111");
    338. 		lt2.push_back("1111111111111");
    339. 		lt2.push_back("1111111111111");
    340. 		print_container(lt2);
    341.  
    342. 		vector v;
    343. 		v.push_back("222222222222");
    344. 		v.push_back("222222222222");
    345. 		v.push_back("222222222222");
    346. 		v.push_back("222222222222");
    347. 		v.push_back("222222222222");
    348. 		print_container(v);
    349.  
    350. 	}
    351. }

    test.cpp

    1. #include
    2. using namespace std;
    3. #include"list.h"
    4.  
    5. int main()
    6. {
    7.  
    8. 	my_std::test_list4();
    9. 	return 0;
    10. }

            当你越来越专注，越来越自律，顺其自然得社交，随时随地地启程，开始爱惜自己，不在意他人的议论揣测，拿得起放得下，你就成为了很棒的自己。 

  • 相关阅读:
    SpringBoot基本的配置
    C/C++多态/虚函数的原理（实现过程）
    EasyExcel实现动态表头功能
    野火霸天虎 STM32F407 学习笔记_5 按键输入；位带操作介绍
    多级缓存之实现多级缓存
    2022-Q3
    大一学生Web课程设计 美食主题网页制作(HTML+CSS+JavaScript)-咖啡 6页
    408 | 大纲知识点考点冲刺 复习整理 ——【计组】第一二三章
    无人机的视频图传技术
    ES6中flat()，flatMap()使用方法
  • 原文地址：https://blog.csdn.net/m0_64707620/article/details/132599019