经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
C++之list容器模拟实现方式
来源：jb51　　时间：2023/2/8 8:56:38　　对本文有异议

总述

list模拟实现主要包括四个类：节点类、迭代器类、反向迭代器类、list类。

list底层结构：

因为list的底层空间不连续，所以迭代器不能使用原生态的指针，将节点类型的指针封装成类，重载解引用及自增等常用操作。list可以保存多种数据类型，所以这些类都写成类模板

一、节点类

list底层是带头结点的双向循环链表，先实现节点类，给成类模板的形式，便于插入不同类型的数据。

  1. template<class T>
  2. struct ListNode
  3. {
  4. 	ListNode<T>* prev;
  5. 	ListNode<T>* next;
  6. 	T data;//要在链表中保存的数据类型
  7.  
  8. 	ListNode(const T& value = T())
  9. 		:prev(nullptr)
  10. 		, next(nullptr)
  11. 		, data(value)
  12. 	{ }
  13. };

定义新节点的方法：

  1. ListNode<变量类型>*变量名=new ListNode(value)；

二、迭代器类

迭代器类模板有三个参数

  • T：迭代器指向的元素类型
  • Ref：返回的引用类型
  • Ptr：返回的指针类型

Ref和Ptr一般不写成T&和T*。

成员变量

迭代器类的成员变量就是节点类型的指针

  1. Node* _pNode;//成员变量，节点类型指针

构造函数

编译器默认的构造函数是无参的，构造函数需要给出

  1. ListIterator(Node* pNode = nullptr)
  2. 	:_pNode(pNode)
  3. {}

*重载

返回节点中保存的数据

  1. Ref operator*()
  2. {
  3. 	return _pNode->data;
  4. }

->重载

返回节点中保存的数据的地址

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

->的重载只对内置类型有意义：

“++”

前置++

返回值是迭代器自身类型的引用，前面已经将ListIterator<T, Ref, Ptr>重命名位Self，表示迭代器自身的类型。

  1. Self& operator++()
  2. {
  3. 	_pNode = _pNode->next;
  4. 	return *this;
  5. }

后置++

定义临时变量，返回自增前的值

  1. Self operator++(int)
  2. {
  3. 	Self temp(*this);
  4. 	_pNode = _pNode->next;
  5. 	return temp;
  6. }

“–”

与++原理相同

  1. Self& operator--()
  2. {
  3. 	_pNode = _pNode->prev;
  4. 	return (*this);
  5. }
  6. Self operator--(int)
  7. {
  8. 	Self temp(*this);
  9. 	_pNode = _pNode->prev;
  10. 	return temp;
  11. }

“==“和”!=”

比较两个迭代器中封装的指针

  1. bool operator!=(const Self& it)
  2. {
  3. 	return _pNode != it._pNode;
  4. }
  5. bool operator==(const Self& it)
  6. {
  7. 	return _pNode == it._pNode;
  8. }

三、反向迭代器类

反向迭代器可以对迭代器类进行复用

因为类外访问静态成员变量时也会使用类名::变量名的方式，所以对迭代器类中的Reference和Pointer进行重命名时要加上typename,明确告诉编译器要重命名的是一个数据类型。否则编译器会报错：

成员变量

反向迭代器对迭代器类进行复用

  1. private:
  2. 	Iterator _it;//正向迭代器

*重载

反向迭代器的解引用要做特殊处理，返回的是对迭代器–的值

  1. Reference operator*()
  2. {
  3. 	//*做特殊处理，先--,再解引用返回
  4. 	auto temp = _it;
  5. 	--temp;
  6. 	return *temp;
  7. }

->重载

复用*的重载，返回value的地址

  1. Pointer operator->()
  2. {
  3. 	return &(operator*());
  4. }

“++”

反向迭代器的++即为正向迭代器的–

  1. Self operator++()
  2. {
  3. 	--_it;
  4. 	return *this;
  5. }
  6. Self operator++(int)
  7. {
  8. 	Self temp(*this);
  9. 	--_it;
  10. 	return *this;
  11. }

“- -”

反向迭代器的–用正向迭代器的++替代

  1. Self operator--()
  2. {
  3. 	++_it;
  4. 	return *this;
  5. }
  6. Self operator--(int)
  7. {
  8. 	Self temp(*this);
  9. 	++_it;
  10. 	return temp;
  11. }

" == " 和"!="

比较反向迭代器类中保存的正向迭代器，复用正向迭代器中的比较方法

  1. bool operator==(const Self& rit)
  2. {
  3. 	return _it == rit;
  4. }
  5. bool operator!=(const Self& rit)
  6. {
  7. 	return _it == rit._it;
  8. }

四、list类

成员变量

list的成员变量只有一个head指针，指向链表的第一个节点

  1. private:
  2. 	Node* head;

构造相关

空对象

  1. list()
  2. {
  3. 	CreatHead();
  4. }

创造头节点的方法：

  1. //提供一个创造头结点的方法
  2. void CreatHead()
  3. {
  4. 	//调用节点类的构造方法
  5. 	head = new Node();
  6. 	head->next = head;
  7. 	head->prev = head;
  8. }
  1. 0000000

new申请空间，令head指向这段空间，head的next和prev都指向自己。

n个T类型元素

调用push_back方法，创造头节点后，不断进行尾插直到元素个数等于n

  1. list(int n, const T& value = T())
  2. {
  3. 	CreatHead();
  4. 	for (int i = 0; i < n; ++i)
  5. 	{
  6. 		push_back(value);
  7. 	}
  8. }

拷贝构造

复用push_back

  1. list(const list<T>& l)
  2. {
  3. 	CreatHead();
  4. 	auto it = l.cbegin();
  5. 	while (it != l.cend())
  6. 	{
  7. 		push_back(*it);
  8. 		it++;
  9. 	}
  10. }

迭代器构造

将迭代器构造方法写成函数模板，可以传入不同类型的迭代器来构造list对象

  1. template<class InputIterator>
  2. list(InputIterator first, InputIterator last)
  3. {
  4. 	CreatHead();
  5. 	while (first != last)
  6. 	{
  7. 		push_back(*first);
  8. 		first++;
  9. 	}
  10. }

赋值运算符重载

与拷贝构造写法相同

  1. list<T>& operator=(const list<T>& l)
  2. {
  3. 	if (this != &l)
  4. 	{
  5. 		clear();//先清空当前对象中的节点
  6. 		auto it = l.cbegin();
  7. 		while (it != l.cend())
  8. 		{
  9. 			push_back(*it);
  10. 			it++;
  11. 		}
  12. 	}
  13. 	return *this;
  14. }

析构

清空当前对象，释放头节点空间，将头节点置空

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

迭代器

正向迭代器

begin

此处的iterator是对ListIterator<T, T&, T*>的重命名，这里会返回一个ListIterator<T, T&, T*>类对象

  1. iterator begin()
  2. {
  3. 	//iterator it(head->next);
  4. 	//return it;
  5. 	//head->next是传递给迭代器类对象构造函数的参数,调用iterator的构造函数
  6. 	return iterator(head->next);//构造匿名对象返回
  7. }

end

  1. iterator end()
  2. {
  3. 	return iterator(head);
  4. }

const类型迭代器

iterator和const_iterator 是两个不同的类：

两者使用的是相同的类模板，但是传递的参数不同，最终实例化的也是不同的类。 

cbegin&cend

  1. const_iterator cbegin()const
  2. {
  3. 	return const_iterator(head->next);
  4. }
  5. const_iterator cend()const
  6. {
  7. 	return const_iterator(head);
  8. }

反向迭代器

rbegin&rend

返回正向迭代器的end和begin

  1. reverse_iterator rbegin()
  2. {
  3. ?? ?return reverse_iterator(end());
  4. }
  5. reverse_iterator rend()
  6. {
  7. ?? ?return reverse_iterator(begin());
  8. }

crbegin&crend

复用正向迭代器的cend和cbegin

  1. const_reverse_iteraotr crbegin()const
  2. {
  3. ?? ?return const_reverse_iteraotr(cend());
  4. }
  5. const_reverse_iteraotr crend()const
  6. {
  7. ?? ?return const_reverse_iteraotr(cbegin());
  8. }

容量操作

size

遍历链表，统计节点个数

  1. size_t size()
  2. {
  3. ?? ?auto it = cbegin();
  4. ?? ?size_t count = 0;
  5. ?? ?while (it != cend())
  6. ?? ?{
  7. ?? ??? ?++count;
  8. ?? ??? ?++it;
  9. ?? ?}
  10. ?? ?return count;
  11. }

empty

如果head->next是head本身则表明链表为空

  1. bool empty()
  2. {
  3. ?? ?return head->next == head;
  4. }

 

resize

改变节点个数，若新的节点个数大于旧的，则调用push_back填充元素；若新的节点个数小于原来的调用pop_back尾删

元素访问

front

复用迭代器解引用的方法，返回begin()位置元素

  1. T& front()
  2. {
  3. 	return *begin();
  4. }
  5. const T& front()const
  6. {
  7. 	return *cbegin();
  8. }

back

back表示最后一个元素，但是end()指向的是最后一个元素的下一个位置，需要定义临时变量，不能直接对end()进行- -。

  1. T& back()
  2. {
  3. 	auto it = end();
  4. 	//return --end()//错误写法
  5. 	it--;
  6. 	return *it;
  7. }
  8. const T& back()const
  9. {
  10. 	auto it = end();
  11. 	it--;
  12. 	return *it;
  13. }

打印链表

定义一个打印链表的函数模板，检验方法。通过迭代器遍历链表，打印每一个节点的数据。

  1. template<class T>
  2. void PrintList(const list<T>& l)
  3. {
  4. 	auto it = l.cbegin();
  5. 	while (it != l.cend())
  6. 	{
  7. 		cout << *it << " ";
  8. 		++it;
  9. 	}
  10. 	cout << endl;
  11. }

元素修改

尾插与尾删

push_back

复用insert方法在end位置插入

  1. void  push_back(const T& value)
  2. {
  3. 	insert(end(), value);
  4. }

pop_back

先判断链表是否为空，复用erase方法在end的前一个位置进行插入

  1. void pop_back()
  2. {
  3. 	if (empty())
  4. 	{
  5. 		return;
  6. 	}
  7. 	auto it = end();
  8. 	it--;
  9. 	erase(it);
  10. }

头插与头删

复用insert与erase方法，在begin()位置进行插入或删除

  1. void push_front(const T& value = T())
  2. {
  3. 	insert(begin(), value);
  4. }
  5. void pop_front()
  6. {
  7. 	erase(begin());
  8. }

?insert

任意位置的插入：申请新节点，连接新节点与链表，断开旧的连接。

这里传入的参数是一个迭代器类对象，不能直接进行操作，要对对象中封装的_pNode指针进行操作。

返回值是新插入的节点的迭代器，所以要用申请的新节点的指针newnode构造一个迭代器类对象返回，不能直接返回newnode

  1. iterator insert(iterator Insertpos, const T& value)
  2. {
  3. 	Node* newnode = new Node(value);
  4. 	Node* pos = Insertpos._pNode;//_pNode是节点类型的指针
  5. 	newnode->next = pos;
  6. 	newnode->prev = pos->prev;
  7. 	newnode->prev->next = newnode;
  8. 	pos->prev = newnode;
  9. 	//return newnode;
  10. 	//?迭代器是封装的Node*指针，此时不能再返回newnode
  11. 	return iterator(newnode);//构造匿名对象返回
  12. }

?erase

任意位置的删除：分别改变前后两个节点的next和prev指针的指向即可

  1. iterator erase(iterator Erasepos)
  2. {
  3. 	Node* pos = Erasepos._pNode;
  4. 	Node* ret = pos->next;
  5. 	pos->prev->next = pos->next;
  6. 	pos->next->prev = pos->prev;
  7. 	delete pos;
  8. 	return iterator(ret);
  9. }

区间删除：复用单个节点删除的方法，遍历要删除的区间。

要用接收erase的返回值，防止迭代器失效

  1. iterator erase(iterator first, iterator last)
  2. {
  3. 	auto it = first;
  4. 	while (it != last)
  5. 	{
  6. 		//it=erase(it);
  7. 		//后置++会构造临时对象返回，不会导致迭代器失效
  8. 		erase(it++);
  9. 	}
  10. 	return it;
  11. }

clear&swap

  • clear复用erase区间删除的方法，从begin删除到end位置；
  • swap方法调用标准库中的swap，交换两个链表的头节点。
  1. void clear()
  2. {
  3. 	erase(begin(), end());
  4. }
  5. void swap(list<T>& l)
  6. {
  7.  
  8. 	std::swap(head, l.head);
  9. }

附：完整list类，含测试用例

  1. #include<iostream>
  2. #include<vector>
  3. using namespace std;
  4.  
  5. namespace ZH
  6. {
  7. 	/
  8. 	//节点类模板, 
  9. 	template<class T>
  10. 	struct ListNode
  11. 	{
  12. 		ListNode<T>* prev;
  13. 		ListNode<T>* next;
  14. 		T data;
  15.  
  16. 		ListNode(const T& value = T())
  17. 			:prev(nullptr)
  18. 			, next(nullptr)
  19. 			, data(value)
  20. 		{ }
  21. 	};
  22. 	
  23. 	/
  24. 	//迭代器类模板
  25. 	//list的迭代器不能使用原生态的指针，要进行封装
  26. 	//T：迭代器指向的元素类型
  27. 	//Ref：给operator*使用，返回引用类型，不要写成T&
  28. 	//Ptr：返回值使用，不要写成T*
  29. 	template<class T,class Ref,class Ptr>
  30. 	class ListIterator
  31. 	{
  32. 	public:
  33. 		typedef ListNode<T> Node;//化简节点类的名字
  34. 		typedef Ref Reference;//在反向迭代器类中使用
  35. 		typedef Ptr Pointer;
  36.  
  37. 		typedef ListIterator<T, Ref, Ptr> Self;//简化迭代器类的名字
  38.  
  39. 		//构造函数
  40. 		ListIterator(Node* pNode=nullptr)
  41. 			:_pNode(pNode)
  42. 		{}
  43.  
  44. 		//重载部分需要使用的运算符即可：*、->、++、--、==
  45. 		Ref operator*()
  46. 		{
  47. 			return _pNode->data;
  48. 		}
  49. 		//T为自定义类型时有意义,
  50. 		Ptr operator->()
  51. 		{
  52. 			return &_pNode->data;
  53. 		}
  54. 		//前置++，返回值是迭代器自身类型的引用
  55. 		Self& operator++()
  56. 		{
  57. 			_pNode = _pNode->next;
  58. 			return *this;
  59. 		}
  60. 		//后置
  61. 		Self operator++(int)
  62. 		{
  63. 			Self temp(*this);
  64. 			_pNode = _pNode->next;
  65. 			return temp;
  66. 		}
  67. 		Self& operator--()
  68. 		{
  69. 			_pNode = _pNode->prev;
  70. 			return (*this);
  71. 		}
  72. 		Self operator--(int)
  73. 		{
  74. 			Self temp(*this);
  75. 			_pNode = _pNode ->prev;
  76. 			return temp;
  77. 		}
  78. 		//迭代器能进行比较
  79. 		bool operator!=(const Self& it)
  80. 		{
  81. 			return _pNode != it._pNode;
  82. 		}
  83. 		bool operator==(const Self& it)
  84. 		{
  85. 			return _pNode == it._pNode;
  86. 		}
  87.  
  88. 		Node* _pNode;//成员变量，节点类型指针
  89. 	};
  90.  
  91. 	
  92. 	//反向迭代器类模板，对迭代器进行复用
  93. 	template<class Iterator>
  94. 	class ListReverseIterator
  95. 	{
  96. 	public:
  97. 		//typedef Iterator::Reference Reference;
  98. 		//typedef Iterator::Pointer Pointer;
  99. 		typedef typename Iterator::Reference Reference;//typename指定Reference是Iterator中的数据类型
  100. 		typedef typename Iterator::Pointer Pointer;
  101. 		typedef ListReverseIterator<Iterator> Self;
  102.  
  103. 		ListReverseIterator(Iterator it)
  104. 			: _it(it)
  105. 		{ }
  106.  
  107. 		Reference operator*()
  108. 		{
  109. 			//*做特殊处理，先--,再解引用返回
  110. 			auto temp = _it;
  111. 			--temp;
  112. 			return *temp;
  113. 		}
  114. 		Pointer operator->()
  115. 		{
  116. 			return &(operator*());
  117. 		}
  118. 		Self operator++()
  119. 		{
  120. 			--_it;
  121. 			return *this;
  122. 		}
  123. 		Self operator++(int)
  124. 		{
  125. 			Self temp(*this);
  126. 			--_it;
  127. 			return *this;
  128. 		}
  129. 		Self operator--()
  130. 		{
  131. 			++_it;
  132. 			return *this;
  133. 		}
  134. 		Self operator--(int)
  135. 		{
  136. 			Self temp(*this);
  137. 			++_it;
  138. 			return temp;
  139. 		}
  140. 		bool operator==(const Self& rit)
  141. 		{
  142. 			return _it == rit;
  143. 		}
  144. 		bool operator!=(const Self& rit)
  145. 		{
  146. 			return _it == rit._it;
  147. 		}
  148.  
  149. 	private:
  150. 		Iterator _it;//正向迭代器
  151. 	};
  152.  
  153. 	template<class T>
  154. 	class list
  155. 	{
  156. 		typedef ListNode<T> Node;
  157. 		//typedef Node* iterator;//不能使用Node*作迭代器
  158. 		//迭代器
  159. 		typedef ListIterator<T, T&, T*> iterator;
  160. 		typedef ListIterator< T, const T&, const T*> const_iterator;
  161. 		
  162. 		typedef ListReverseIterator<iterator> reverse_iterator;
  163. 		typedef ListReverseIterator<const_iterator> const_reverse_iteraotr;
  164.  
  165. 	public:
  166. 		///
  167. 		//构造
  168. 		list()
  169. 		{
  170. 			CreatHead();
  171. 		}
  172. 		list(int n, const T& value=T())
  173. 		{
  174. 			CreatHead();
  175. 			for (int i = 0; i < n; ++i)
  176. 			{
  177. 				push_back(value);
  178. 			}
  179. 		}
  180. 		list(const list<T>& l)
  181. 		{
  182. 			CreatHead();
  183. 			auto it = l.cbegin();
  184. 			while (it != l.cend())
  185. 			{
  186. 				push_back(*it);
  187. 				it++;
  188. 			}
  189. 		}
  190. 		//迭代器区间构造
  191. 		template<class InputIterator>
  192. 		list(InputIterator first, InputIterator last)
  193. 		{
  194. 			CreatHead();
  195. 			while (first != last)
  196. 			{
  197. 				push_back(*first);
  198. 				first++;
  199. 			}
  200. 		}
  201. 		//赋值运算符重载
  202. 		list<T>& operator=(const list<T>& l)
  203. 		{
  204. 			if (this != &l)
  205. 			{
  206. 				clear();//先清空当前对象中的节点
  207. 				auto it = l.cbegin();
  208. 				while (it != l.cend())
  209. 				{
  210. 					push_back(*it);
  211. 					it++;	
  212. 				}
  213. 			}
  214. 			return *this;
  215. 		}
  216. 		~list()
  217. 		{
  218. 			clear();
  219. 			delete head;
  220. 			head = nullptr;
  221. 		}
  222. 	public:
  223. 		//迭代器
  224. 		iterator begin()
  225. 		{
  226. 			//iterator it(head->next);
  227. 			//return it;
  228. 			//iterator是对ListIterator<T, T&, T*>的重命名
  229. 			//这里会返回一个ListIterator<T, T&, T*>类对象
  230. 			//head->next是传递给迭代器类对象构造函数的参数,调用iterator的构造函数
  231. 			return iterator(head->next);//构造匿名对象返回
  232. 		}
  233. 		iterator end()
  234. 		{
  235. 			return iterator(head);
  236. 		}
  237. 		//const类型迭代器
  238. 		const_iterator cbegin()const
  239. 		{
  240. 			return const_iterator(head->next);
  241. 		}
  242. 		const_iterator cend()const
  243. 		{
  244. 			return const_iterator(head);
  245. 		}
  246.  
  247. 		//反向迭代器
  248. 		//反向迭代器的成员变量是一个迭代器类对象
  249. 		//end()即为传递给反向迭代器类构造函数的参数
  250. 		reverse_iterator rbegin()
  251. 		{
  252. 			return reverse_iterator(end());
  253. 		}
  254. 		reverse_iterator rend()
  255. 		{
  256. 			return reverse_iterator(begin());
  257. 		}
  258. 		//反向const类型迭代器
  259. 		const_reverse_iteraotr crbegin()const
  260. 		{
  261. 			return const_reverse_iteraotr(cend());
  262. 		}
  263. 		const_reverse_iteraotr crend()const
  264. 		{
  265. 			return const_reverse_iteraotr(cbegin());
  266. 		}
  267.  
  268. 		/
  269. 		//容量
  270. 		size_t size()
  271. 		{
  272. 			auto it = cbegin();
  273. 			size_t count = 0;
  274. 			while (it != cend())
  275. 			{
  276. 				++count;
  277. 				++it;
  278. 			}
  279. 			return count;
  280. 		}
  281. 		bool empty()
  282. 		{
  283. 			return head->next == head;
  284. 		}
  285. 		void resize(int newsize,const T& value=T())
  286. 		{
  287. 			size_t oldsize = size();
  288. 			if (newsize > oldsize)
  289. 			{
  290. 				while (oldsize++<newsize)
  291. 				{
  292. 					push_back(value);
  293. 				}
  294. 			}
  295. 			if (newsize < oldsize)
  296. 			{
  297. 				while (oldsize-- < newsize)
  298. 				{
  299. 					pop_back();
  300. 				}
  301. 			}
  302. 		}
  303.  
  304. 		///
  305. 		//元素访问
  306. 		T& front()
  307. 		{
  308. 			return *begin();
  309. 		}
  310. 		const T& front()const
  311. 		{
  312. 			return *cbegin();
  313. 		}
  314. 		T& back()
  315. 		{
  316. 			auto it = end();
  317. 			it--;
  318. 			return *it;
  319. 		}
  320. 		const T& back()const
  321. 		{
  322. 			auto it = end();
  323. 			it--;
  324. 			return *it;
  325. 		}
  326.  
  327.  
  328. 		/
  329. 		//元素修改
  330. 		void  push_back(const T& value)
  331. 		{
  332. 			insert(end(), value);
  333. 		}
  334.  
  335. 		void pop_back()
  336. 		{
  337. 			if (empty())
  338. 			{
  339. 				return;
  340. 			}
  341. 			auto it = end();
  342. 			it--;
  343. 			erase(it);
  344. 		}
  345. 		void push_front(const T& value = T())
  346. 		{
  347. 			//Node* pos = head->next;
  348. 			/*Node* newnode = new Node(value);
  349. 			newnode->next = head->next;
  350. 			newnode->prev = head;
  351. 			head->next->prev = newnode;
  352. 			head->next = newnode;*/
  353. 		    //复用insert
  354. 			insert(begin(), value);
  355. 		}
  356. 		void pop_front()
  357. 		{
  358. 			erase(begin());
  359. 		}
  360.  
  361. 		//?insert
  362. 		// iterator是ListIterator<T, T&, T*>
  363. 		iterator insert(iterator Insertpos, const T& value)
  364. 		{
  365. 			Node* newnode = new Node(value);
  366. 			Node* pos = Insertpos._pNode;//_pNode是节点类型的指针
  367. 			newnode->next = pos;
  368. 			newnode->prev = pos->prev;
  369. 			newnode->prev->next = newnode;
  370. 			pos->prev = newnode;
  371. 			//return newnode;
  372. 			//?迭代器是封装的Node*指针，此时不能再返回newnode
  373. 			return iterator(newnode);//构造匿名对象返回
  374. 		}
  375. 		//?erase
  376. 		iterator erase(iterator Erasepos)
  377. 		{
  378. 			Node* pos = Erasepos._pNode;
  379. 			Node* ret = pos->next;
  380. 			pos->prev->next = pos->next;
  381. 			pos->next->prev = pos->prev;
  382. 			delete pos;
  383. 			return iterator(ret);
  384. 		}
  385. 		iterator erase(iterator first, iterator last)
  386. 		{
  387. 			auto it = first;
  388. 			while (it != last)
  389. 			{
  390. 				//it=erase(it);
  391. 				erase(it++);
  392. 			}
  393. 			return it;
  394. 		}
  395.  
  396. 		void clear()
  397. 		{
  398. 			erase(begin(), end());
  399. 		}
  400. 		void swap(list<T>& l)
  401. 		{
  402. 			std::swap(head, l.head);
  403. 		}
  404.  
  405. 	private:
  406. 		//提供一个创造头结点的方法
  407. 		void CreatHead()
  408. 		{
  409. 			//调用节点类的构造方法
  410. 			head = new Node();
  411. 			head->next = head;
  412. 			head->prev = head;
  413. 		}
  414. 	private:
  415. 		Node* head;
  416.  
  417. 	};
  418.  
  419. 	template<class T>
  420. 	void PrintList(const list<T>& l)
  421. 	{
  422. 		auto it = l.cbegin();
  423. 		while (it != l.cend())
  424. 		{
  425. 			cout << *it << " ";
  426. 			++it;
  427. 		}
  428. 		cout << endl;
  429. 	}
  430. }
  431.  
  432. void Test1()
  433. {
  434. 	ZH::list<int> l1;
  435. 	ZH::list<int> l2(3, 1);
  436. 	PrintList(l2);
  437. 	ZH::list<int> l3(l2.begin(), l2.end());
  438. 	PrintList(l3);
  439. 	vector<int> v{ 0,1,2,3,4 };
  440. 	ZH::list<int> l4(v.begin(), v.end());
  441. 	PrintList(l4);
  442. }
  443.  
  444. void Test2()
  445. {
  446. 	vector<int> v{ 1,2,3,4 };
  447. 	ZH::list<int> L1(v.begin(), v.end());
  448. 	L1.push_back(5);
  449. 	L1.push_back(6);
  450. 	L1.push_front(0);
  451. 	PrintList(L1);
  452. 	L1.pop_back();
  453. 	L1.pop_front();
  454. 	PrintList(L1);
  455. 	L1.erase(--L1.end());
  456. 	PrintList(L1);
  457. }
  458.  
  459. void Test3()
  460. {
  461. 	ZH::list<int> L1;
  462. 	L1.push_back(1);
  463. 	L1.push_back(2);
  464. 	L1.push_back(3);
  465. 	L1.push_front(0);
  466. 	PrintList(L1);
  467. 	L1.resize(6, 5);
  468. 	PrintList(L1);
  469. }
  470.  
  471. struct A
  472. {
  473. 	int a;
  474. 	int b;
  475. 	int c;
  476. };
  477.  
  478. void Test4()
  479. {
  480. 	A aa{ 1,2,3 };
  481. 	A bb{ 4,5,6 };
  482. 	A cc{ 7,8,9 };
  483. 	ZH::list<A> L;
  484. 	L.push_back(aa);
  485. 	L.push_back(bb);
  486. 	L.push_back(cc);
  487. 	auto it = L.begin();
  488. 	while (it != L.end())
  489. 	{
  490. 		//?it->得到的是节点的地址
  491. 		//本应是it->->a，编译器做了特殊处理
  492. 		cout << it->a << " ";
  493. 		it++;
  494. 	}
  495. 	cout << endl;
  496. }
  497.  
  498. void Test5()
  499. {
  500. 	ZH::list<int> L1;
  501. 	L1.push_back(0);
  502. 	L1.push_back(1);
  503. 	L1.push_back(2);
  504. 	L1.push_back(3);
  505. 	PrintList(L1);
  506. 	cout << L1.back() << endl;
  507. 	cout << L1.front() << endl;
  508. 	cout << L1.size() << endl;
  509. 	L1.clear();
  510. 	cout << L1.size() << endl;
  511. }
  512.  void Test6()
  513.  {
  514. 	 ZH::list<int> L1;
  515. 	 L1.push_back(0);
  516. 	 L1.push_back(1);
  517. 	 L1.push_back(2);
  518. 	 L1.push_back(3);
  519. 	 PrintList(L1);
  520. 	 //区间删除
  521. 	 /*L1.erase(L1.begin(), L1.end());
  522. 	 PrintList(L1);*/
  523.  
  524. 	 ZH::list<int> L2;
  525. 	 L2.push_back(1);
  526. 	 L2.push_back(2);
  527. 	 L2.push_back(3);
  528. 	 L2.push_back(4);
  529. 	 L2.push_back(5);
  530. 	 PrintList(L2);
  531. 	 L1.swap(L2);
  532. 	 PrintList(L1);
  533. 	 PrintList(L2);
  534.  }
  535.  
  536. int main()
  537. {
  538. 	Test6();
  539. 	system("pause");
  540. 	return 0;
  541. }

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持w3xue。

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号