devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++/C++11中std::list双向链表的使用_c++ std 双向链表

作者：Monodyee | 2024-05-01 01:26:00

赞

踩

c++ std 双向链表

std::list是双向链表，是一个允许在序列中任何一处位置以常量耗时插入或删除元素且可以双向迭代的顺序容器。std::list中的每个元素保存了定位前一个元素及后一个元素的信息，允许在任何一处位置以常量耗时进行插入或删除操作，但不能进行直接随机访问。

std::list和std::forward_list两个容器的设计目的是令容器任何位置的添加和删除操作都很快速。作为代价，这两个容器不支持元素的随机访问：为了访问一个元素，我们只能遍历整个容器。而且与vector、deque和array相比，这两个容器的额外内存开销也很大。

std::list与std::forward_list相比，它提供双向迭代的能力，但具有更低的空间效率。

Lists are sequence containers that allow constant time insert and erase operations anywhere within the sequence, and iteration in both directions.

List containers are implemented as doubly-linked lists; Doubly linked lists can store each of the elements they contain in different and unrelated storage locations. The ordering is kept internally by the association to each element of a link to the element preceding it and a link to the element following it.

They are very similar to forward_list: The main difference being that forward_list objects are single-linked lists, and thus they can only be iterated forwards, in exchange for being somewhat smaller and more efficient.

Compared to other base standard sequence containers (array, vector and deque), lists perform generally better in inserting, extracting and moving elements in any position within the container for which an iterator has already been obtained,and therefore also in algorithms that make intensive use of these, like sorting algorithms.

The main drawback of lists and forward_lists compared to these other sequence containers is that they lack direct access to the elements by their position.  

一个容器就是一些特定类型对象的集合。顺序容器(sequential container)为程序员提供了控制元素存储和访问顺序的能力。这种顺序不依赖于元素的值，而是与元素加入容器时的位置相对应。

        标准库中的顺序容器包括：

        (1)、vector：可变大小数组。支持快速随机访问。在尾部之外的位置插入或删除元素可能很慢。

        (2)、deque：双端队列。支持快速随机访问。在头尾位置插入/删除速度很快。

        (3)、list：双向链表。只支持双向顺序访问。在list中任何位置进行插入/删除操作速度都很快。

        (4)、forward_list：单向链表。只支持单向顺序访问。在链表任何位置进行插入/删除操作速度都很快。

        (5)、array：固定大小数组。支持快速随机访问。不能添加或删除元素。

        (6)、string：与vector相似的容器，但专门用于保存字符。随机访问快。在尾部插入/删除速度快。

        除了固定大小的array外，其它容器都提供高效、灵活的内存管理。我们可以添加和删除元素，扩张和收缩容器的大小。容器保存元素的策略对容器操作的效率有着固定的，有时是重大的影响。在某些情况下，存储策略还会影响特定容器是否支持特定操作。

        例如，string和vector将元素保存在连续的内存空间中。由于元素是连续存储的，由元素的下标来计算其地址是非常快速的。但是，在这两种容器的中间位置添加或删除元素就会非常耗时：在一次插入或删除操作后，需要移动插入/删除位置之后的所有元素，来保持连续存储。而且，添加一个元素有时可能还需要分配额外的存储空间。在这种情况下，每个元素都必须移动到新的存储空间中。

        list和forward_list两个容器的设计目的是令容器任何位置的添加和删除操作都很快速。作为代价，这两个容器不支持元素的随机访问：为了访问一个元素，我们只能遍历整个容器。而且，与vector、deque和array相比，这两个容器的额外内存开销也很大。

        deque是一个更为复杂的数据结构。与string和vector类似，deque支持快速的随机访问。与string和vector一样，在deque的中间位置添加或删除元素的代价(可能)很高。但是，在deque的两端添加或删除元素都是很快的，与list或forward_list添加删除元素的速度相当。

        forward_list和array是新C++标准增加的类型。与内置数组相比，array是一个种更安全、更容易使用的数组类型。与内置数组类似，array对象的大小是固定的。因此，array不支持添加和删除元素以及改变容器大小的操作。forward_list的设计目标是达到与最好的手写的单向链表数据结构相当的性能。因此，forward_list没有size操作，因为保存或计算其大小就会比手写链表多出额外的开销。对其他容器而言，size保证是一个快速的常量时间的操作。

        通常，使用vector是最好的选择，除法你有很好的理由选择其他容器。

        以下是一些选择容器的基本原则：

        (1)、除法你有很好的理由选择其他容器，否则应该使用vector；

        (2)、如果你的程序有很多小的元素，且空间的额外开销很重要，则不要使用list或forward_list；

        (3)、如果程序要求随机访问元素，应使用vector或deque；

(4)、如果程序要求在容器的中间插入或删除元素，应使用list或forward_list；

(5)、如果程序需要在头尾位置插入或删除元素，但不会在中间位置进行插入或删除操作，则使用deque；

(6)、如果程序只有在读取输入时才需要在容器中间位置插入元素，随后需要随机访问元素，则：首先，确定是否真的需要在容器中间位置添加元素。当处理输入数据时，通常可以很容器地向vector追加数据，然后再调用标准库的sort函数来重排容器中的元素，从而避免在中间位置添加元素。如果必须在中间位置插入元素，考虑在输入阶段使用list，一旦输入完成，将list中的内容拷贝到一个vector中。

如果你不确定应该使用哪种容器，那么可以在程序中只使用vector和list公共的操作：使用迭代器，不使用下标操作，避免随机访问。这样，在必要时选择使用vector或list都很方便。

一般来说，每个容器都定义在一个头文件中，文件名与类型名相同。即，deque定义在头文件deque中，list定义在头文件list中，以此类推。容器均定义为模板类。

顺序容器几乎可以保存任意类型的元素。特别是，我们可以定义一个容器，其元素的类型是另一个容器。这种容器的定义与任何其他容器类型完全一样：在尖括号中指定元素类型(此种情况下，是另一种容器类型)。

除了顺序容器外，标准库还定义了三个顺序容器适配器：stack、queue和priority_queue。适配器(adaptor)是标准库中的一个通用概念。容器、迭代器和函数都有适配器。本质上，一个适配器是一种机制，能使某种事物的行为看起来像另外一种事物一样。一个容器适配器接受一种已有的容器类型，使其行为看起来像一种不同的类型。

下面是从其他文章中copy的std::list测试代码，详细内容介绍可以参考对应的reference：

  1. #include "list.hpp"
  2. #include <iostream>
  3. #include <list>
  4. #include <vector>
  5. #include <string>
  6. #include <cmath>
  7.  
  8. //
  9. // reference: http://www.cplusplus.com/reference/list/list/
  10. // compare only integral part:
  11. static bool mycomparison(double first, double second)
  12. {
  13. 	return (int(first)<int(second));
  14. }
  15.  
  16. // comparison, not case sensitive.
  17. static bool compare_nocase(const std::string& first, const std::string& second)
  18. {
  19. 	unsigned int i = 0;
  20. 	while ((i<first.length()) && (i<second.length())) {
  21. 		if (tolower(first[i])<tolower(second[i])) return true;
  22. 		else if (tolower(first[i])>tolower(second[i])) return false;
  23. 		++i;
  24. 	}
  25. 	return (first.length() < second.length());
  26. }
  27.  
  28. // a predicate implemented as a function:
  29. static bool single_digit(const int& value) { return (value<10); }
  30.  
  31. // a predicate implemented as a class:
  32. struct is_odd {
  33. 	bool operator() (const int& value) { return (value % 2) == 1; }
  34. };
  35.  
  36. // a binary predicate implemented as a function:
  37. static bool same_integral_part(double first, double second)
  38. {
  39. 	return (int(first) == int(second));
  40. }
  41.  
  42. // a binary predicate implemented as a class:
  43. struct is_near {
  44. 	bool operator() (double first, double second)
  45. 	{
  46. 		return (fabs(first - second)<5.0);
  47. 	}
  48. };
  49.  
  50. int test_list_1()
  51. {
  52. { // list::list: Constructs a list container object, initializing its contents depending on the constructor version used
  53. 	std::list<int> first;                                // empty list of ints
  54. 	std::list<int> second(4, 100);                       // four ints with value 100
  55. 	std::list<int> third(second.begin(), second.end());  // iterating through second
  56. 	std::list<int> fourth(third);                       // a copy of third
  57.  
  58. 	// the iterator constructor can also be used to construct from arrays:
  59. 	int myints[] = { 16, 2, 77, 29 };
  60. 	std::list<int> fifth(myints, myints + sizeof(myints) / sizeof(int));
  61.  
  62. 	std::cout << "The contents of fifth are: ";
  63. 	for (std::list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
  64. 		std::cout << *it << ' ';
  65. 	std::cout << '\n';
  66. }
  67.  
  68. { // list::assign: Assigns new contents to the list container, replacing its current contents, and modifying its size accordingly
  69.   // list::size: Returns the number of elements in the list container.
  70. 	std::list<int> first;
  71. 	std::list<int> second;
  72.  
  73. 	first.assign(7, 100);                      // 7 ints with value 100
  74.  
  75. 	second.assign(first.begin(), first.end()); // a copy of first
  76.  
  77. 	int myints[] = { 1776, 7, 4 };
  78. 	first.assign(myints, myints + 3);            // assigning from array
  79.  
  80. 	std::cout << "Size of first: " << int(first.size()) << '\n';
  81. 	std::cout << "Size of second: " << int(second.size()) << '\n';
  82. }
  83.  
  84. { // list::back: Returns a reference to the last element in the list container
  85.   // list::front: Returns a reference to the first element in the list container.
  86. 	std::list<int> mylist;
  87.  
  88. 	mylist.push_back(10);
  89.  
  90. 	while (mylist.back() != 0) {
  91. 		mylist.push_back(mylist.back() - 1);
  92. 	}
  93.  
  94. 	std::cout << "mylist contains:";
  95. 	for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
  96. 		std::cout << ' ' << *it;
  97. 	std::cout << '\n';
  98.  
  99. 	mylist.push_back(77);
  100. 	mylist.push_back(22);
  101.  
  102. 	mylist.front() -= mylist.back();
  103. 	std::cout << "mylist.front() is now " << mylist.front() << '\n';
  104.  
  105. }
  106.  
  107. { // list::begin: Returns an iterator pointing to the first element in the list container
  108.   // list::cbegin: C++11, Returns a const_iterator pointing to the first element in the container
  109.   // list::crbegin: C++11, Returns a const_reverse_iterator pointing to the last element in the container (i.e., its reverse beginning)
  110.   // list::rbegin: Returns a reverse iterator pointing to the last element in the container (i.e., its reverse beginning).
  111.   // list::end: Returns an iterator referring to the past-the-end element in the list container
  112.   // list::cend: C++11, Returns a const_iterator pointing to the past-the-end element in the container
  113.   // list::crend: C++11, Returns a const_reverse_iterator pointing to the theoretical element
  114.   // preceding the first element in the container (which is considered its reverse end)
  115.   // list::rend: Returns a reverse iterator pointing to the theoretical element preceding the first element
  116.   // in the list container (which is considered its reverse end).
  117. 	int myints[] = { 75, 23, 65, 42, 13 };
  118. 	std::list<int> mylist(myints, myints + 5);
  119.  
  120. 	std::cout << "mylist contains:";
  121. 	for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
  122. 		std::cout << ' ' << *it;
  123. 	std::cout << '\n';
  124.  
  125. 	for (auto it = mylist.cbegin(); it != mylist.cend(); ++it)
  126. 		std::cout << ' ' << *it;
  127. 	std::cout << '\n';
  128.  
  129. 	for (auto rit = mylist.crbegin(); rit != mylist.crend(); ++rit)
  130. 		std::cout << ' ' << *rit;
  131. 	std::cout << '\n';
  132.  
  133. 	std::cout << "mylist backwards:";
  134. 	for (std::list<int>::reverse_iterator rit = mylist.rbegin(); rit != mylist.rend(); ++rit)
  135. 		std::cout << ' ' << *rit;
  136. 	std::cout << '\n';
  137. }
  138.  
  139. { // list::clear: Removes all elements from the list container (which are destroyed),
  140.   // and leaving the container with a size of 0
  141. 	std::list<int> mylist;
  142. 	std::list<int>::iterator it;
  143.  
  144. 	mylist.push_back(100);
  145. 	mylist.push_back(200);
  146. 	mylist.push_back(300);
  147.  
  148. 	std::cout << "mylist contains:";
  149. 	for (it = mylist.begin(); it != mylist.end(); ++it)
  150. 		std::cout << ' ' << *it;
  151. 	std::cout << '\n';
  152.  
  153. 	mylist.clear();
  154. 	mylist.push_back(1101);
  155. 	mylist.push_back(2202);
  156.  
  157. 	std::cout << "mylist contains:";
  158. 	for (it = mylist.begin(); it != mylist.end(); ++it)
  159. 		std::cout << ' ' << *it;
  160. 	std::cout << '\n';
  161. }
  162.  
  163. { // list::emplace: C++11, The container is extended by inserting a new element at position.
  164.   // This new element is constructed in place using args as the arguments for its construction.
  165.   // list::emplace_back: C++11, Inserts a new element at the end of the list, right after its current last element.
  166.   // This new element is constructed in place using args as the arguments for its construction.
  167.   // list::emplace_front: Inserts a new element at the beginning of the list, right before its current first element.
  168.   // This new element is constructed in place using args as the arguments for its construction.
  169. 	std::list< std::pair<int, char> > mylist;
  170.  
  171. 	mylist.emplace(mylist.begin(), 100, 'x');
  172. 	mylist.emplace(mylist.begin(), 200, 'y');
  173.  
  174. 	std::cout << "mylist contains:";
  175. 	for (auto& x : mylist)
  176. 		std::cout << " (" << x.first << "," << x.second << ")";
  177. 	std::cout << '\n';
  178.  
  179. 	mylist.emplace_back(10, 'a');
  180. 	mylist.emplace_back(20, 'b');
  181. 	mylist.emplace_back(30, 'c');
  182.  
  183. 	std::cout << "mylist contains:";
  184. 	for (auto& x : mylist)
  185. 		std::cout << " (" << x.first << "," << x.second << ")";
  186. 	std::cout << std::endl;
  187.  
  188. 	mylist.emplace_front(10, 'a');
  189. 	mylist.emplace_front(20, 'b');
  190. 	mylist.emplace_front(30, 'c');
  191.  
  192. 	std::cout << "mylist contains:";
  193. 	for (auto& x : mylist)
  194. 		std::cout << " (" << x.first << "," << x.second << ")";
  195. 	std::cout << std::endl;
  196. }
  197.  
  198. { // list::empty: Returns whether the list container is empty (i.e. whether its size is 0).
  199. 	std::list<int> mylist;
  200. 	int sum(0);
  201.  
  202. 	for (int i = 1; i <= 10; ++i) mylist.push_back(i);
  203.  
  204. 	while (!mylist.empty()) {
  205. 		sum += mylist.front();
  206. 		mylist.pop_front();
  207. 	}
  208.  
  209. 	std::cout << "total: " << sum << '\n';
  210. }
  211.  
  212. { // list::erase: Removes from the list container either a single element (position) or a range of elements ([first,last)).
  213. 	std::list<int> mylist;
  214. 	std::list<int>::iterator it1, it2;
  215.  
  216. 	// set some values:
  217. 	for (int i = 1; i<10; ++i) mylist.push_back(i * 10);
  218.  
  219. 				    // 10 20 30 40 50 60 70 80 90
  220. 	it1 = it2 = mylist.begin(); // ^^
  221. 	std::advance(it2, 6);            // ^                 ^
  222. 	++it1;                      //    ^              ^
  223.  
  224. 	it1 = mylist.erase(it1);   // 10 30 40 50 60 70 80 90
  225. 				   //    ^           ^
  226.  
  227. 	it2 = mylist.erase(it2);   // 10 30 40 50 60 80 90
  228. 				   //    ^           ^
  229.  
  230. 	++it1;                      //       ^        ^
  231. 	--it2;                      //       ^     ^
  232.  
  233. 	mylist.erase(it1, it2);     // 10 30 60 80 90
  234. 				    //        ^
  235.  
  236. 	std::cout << "mylist contains:";
  237. 	for (it1 = mylist.begin(); it1 != mylist.end(); ++it1)
  238. 		std::cout << ' ' << *it1;
  239. 	std::cout << '\n';
  240. }
  241.  
  242. { // list::get_allocator: Returns a copy of the allocator object associated with the list container
  243. 	std::list<int> mylist;
  244. 	int * p;
  245.  
  246. 	// allocate an array of 5 elements using mylist's allocator:
  247. 	p = mylist.get_allocator().allocate(5);
  248.  
  249. 	// assign some values to array
  250. 	for (int i = 0; i<5; ++i) p[i] = i;
  251.  
  252. 	std::cout << "The allocated array contains:";
  253. 	for (int i = 0; i<5; ++i) std::cout << ' ' << p[i];
  254. 	std::cout << '\n';
  255.  
  256. 	mylist.get_allocator().deallocate(p, 5);
  257. }
  258.  
  259. { // list::insert: The container is extended by inserting new elements before the element at the specified position
  260. 	std::list<int> mylist;
  261. 	std::list<int>::iterator it;
  262.  
  263. 	// set some initial values:
  264. 	for (int i = 1; i <= 5; ++i) mylist.push_back(i); // 1 2 3 4 5
  265.  
  266. 	it = mylist.begin();
  267. 	++it;           // it points now to number 2           ^
  268.  
  269. 	mylist.insert(it, 10);                        // 1 10 2 3 4 5
  270.  
  271. 	// "it" still points to number 2                      ^
  272. 	mylist.insert(it, 2, 20);                      // 1 10 20 20 2 3 4 5
  273.  
  274. 	--it;         // it points now to the second 20            ^
  275.  
  276. 	std::vector<int> myvector(2, 30);
  277. 	mylist.insert(it, myvector.begin(), myvector.end());
  278. 						       // 1 10 20 30 30 20 2 3 4 5
  279. 						       //               ^
  280. 	std::cout << "mylist contains:";
  281. 	for (it = mylist.begin(); it != mylist.end(); ++it)
  282. 		std::cout << ' ' << *it;
  283. 	std::cout << '\n';
  284. }
  285.  
  286. { // list::max_size: Returns the maximum number of elements that the list container can hold.
  287.   // list::resize: Resizes the container so that it contains n elements
  288.   // list::size_type: A type that counts the number of elements in a list.
  289. 	unsigned int i;
  290. 	std::list<int> mylist;
  291.  
  292. 	i = 111111;
  293.  
  294. 	if (i<mylist.max_size()) mylist.resize(i);
  295. 	else std::cout << "That size exceeds the limit.\n";
  296.  
  297. 	std::list <int>::size_type ii;
  298. 	ii = mylist.max_size();
  299. 	std::cout << "Maximum possible length of the list is " << ii << "." << std::endl;
  300. }
  301.  
  302. { // list::merge: Merges x into the list by transferring all of its elements at their respective ordered positions
  303.   // into the container (both containers shall already be ordered).
  304. 	std::list<double> first, second;
  305.  
  306. 	first.push_back(3.1);
  307. 	first.push_back(2.2);
  308. 	first.push_back(2.9);
  309.  
  310. 	second.push_back(3.7);
  311. 	second.push_back(7.1);
  312. 	second.push_back(1.4);
  313.  
  314. 	first.sort();
  315. 	second.sort();
  316.  
  317. 	first.merge(second);
  318.  
  319. 	// (second is now empty)
  320.  
  321. 	second.push_back(2.1);
  322.  
  323. 	first.merge(second, mycomparison);
  324.  
  325. 	std::cout << "first contains:";
  326. 	for (std::list<double>::iterator it = first.begin(); it != first.end(); ++it)
  327. 		std::cout << ' ' << *it;
  328. 	std::cout << '\n';
  329. }
  330.  
  331. { // list::sort: Sorts the elements in the list, altering their position within the container
  332. 	std::list<std::string> mylist;
  333. 	std::list<std::string>::iterator it;
  334. 	mylist.push_back("one");
  335. 	mylist.push_back("two");
  336. 	mylist.push_back("Three");
  337.  
  338. 	mylist.sort();
  339.  
  340. 	std::cout << "mylist contains:";
  341. 	for (it = mylist.begin(); it != mylist.end(); ++it)
  342. 		std::cout << ' ' << *it;
  343. 	std::cout << '\n';
  344.  
  345. 	mylist.sort(compare_nocase);
  346.  
  347. 	std::cout << "mylist contains:";
  348. 	for (it = mylist.begin(); it != mylist.end(); ++it)
  349. 		std::cout << ' ' << *it;
  350. 	std::cout << '\n';
  351. }
  352.  
  353. { // list::operator=: Assigns new contents to the container, replacing its current contents, and modifying its size accordingly.
  354. 	std::list<int> first(3);      // list of 3 zero-initialized ints
  355. 	std::list<int> second(5);     // list of 5 zero-initialized ints
  356.  
  357. 	second = first;
  358. 	first = std::list<int>();
  359.  
  360. 	std::cout << "Size of first: " << int(first.size()) << '\n';
  361. 	std::cout << "Size of second: " << int(second.size()) << '\n';
  362. }
  363.  
  364. { // list::push_back: Adds a new element at the end of the list container, after its current last element.
  365.   // list::push_front: Inserts a new element at the beginning of the list, right before its current first element.
  366.   // list::pop_back: Removes the last element in the list container, effectively reducing the container size by one.
  367.   // list::pop_front: Removes the first element in the list container, effectively reducing its size by on
  368. 	std::list<int> mylist;
  369. 	int sum(0);
  370. 	mylist.push_back(100);
  371. 	mylist.push_back(200);
  372. 	mylist.push_back(300);
  373.  
  374. 	while (!mylist.empty()) {
  375. 		sum += mylist.back();
  376. 		mylist.pop_back();
  377. 	}
  378.  
  379. 	std::cout << "The elements of mylist summed " << sum << '\n';
  380.  
  381. 	mylist.push_back(100);
  382. 	mylist.push_back(200);
  383. 	mylist.push_back(300);
  384.  
  385. 	mylist.push_front(200);
  386. 	mylist.push_front(300);
  387.  
  388. 	std::cout << "Popping out the elements in mylist:";
  389. 	while (!mylist.empty()) {
  390. 		std::cout << ' ' << mylist.front();
  391. 		mylist.pop_front();
  392. 	}
  393.  
  394. 	std::cout << "\nFinal size of mylist is " << mylist.size() << '\n';
  395. }
  396.  
  397. { // list::remove: Removes from the container all the elements that compare equal to val.
  398.   // This calls the destructor of these objects and reduces the container size by the number of elements removed.
  399.   // list::remove_if: Removes from the container all the elements for which Predicate pred returns true.
  400.   // This calls the destructor of these objects and reduces the container size by the number of elements removed.
  401. 	int myints[] = { 89, 15, 36, 7, 17, 20, 39, 4, 1 };
  402. 	std::list<int> mylist(myints, myints + 9);
  403.  
  404. 	mylist.remove(89);
  405.  
  406. 	std::cout << "mylist contains:";
  407. 	for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
  408. 		std::cout << ' ' << *it;
  409. 	std::cout << '\n';
  410.  
  411. 	mylist.remove_if(single_digit);           // 15 36 17 20 39
  412. 	mylist.remove_if(is_odd());               // 36 20
  413.  
  414. 	std::cout << "mylist contains:";
  415. 	for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
  416. 		std::cout << ' ' << *it;
  417. 	std::cout << '\n';
  418. }
  419.  
  420. { // list::reverse: reverses the order of the elements in the list container.
  421. 	std::list<int> mylist;
  422.  
  423. 	for (int i = 1; i<10; ++i) mylist.push_back(i);
  424.  
  425. 	mylist.reverse();
  426.  
  427. 	std::cout << "mylist contains:";
  428. 	for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
  429. 		std::cout << ' ' << *it;
  430. 	std::cout << '\n';
  431. }
  432.  
  433. { // list::splice: Transfers elements from x into the container, inserting them at position
  434. 	std::list<int> mylist1, mylist2;
  435. 	std::list<int>::iterator it;
  436.  
  437. 	// set some initial values:
  438. 	for (int i = 1; i <= 4; ++i)
  439. 		mylist1.push_back(i);      // mylist1: 1 2 3 4
  440.  
  441. 	for (int i = 1; i <= 3; ++i)
  442. 		mylist2.push_back(i * 10);   // mylist2: 10 20 30
  443.  
  444. 	it = mylist1.begin();
  445. 	++it;                         // points to 2
  446.  
  447. 	mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
  448. 	// mylist2 (empty)
  449. 	// "it" still points to 2 (the 5th element)
  450.  
  451. 	mylist2.splice(mylist2.begin(), mylist1, it);
  452. 	// mylist1: 1 10 20 30 3 4
  453. 	// mylist2: 2
  454. 	// "it" is now invalid.
  455. 	it = mylist1.begin();
  456. 	std::advance(it, 3);           // "it" points now to 30
  457.  
  458. 	mylist1.splice(mylist1.begin(), mylist1, it, mylist1.end());
  459. 	// mylist1: 30 3 4 1 10 20
  460.  
  461. 	std::cout << "mylist1 contains:";
  462. 	for (it = mylist1.begin(); it != mylist1.end(); ++it)
  463. 		std::cout << ' ' << *it;
  464. 	std::cout << '\n';
  465.  
  466. 	std::cout << "mylist2 contains:";
  467. 	for (it = mylist2.begin(); it != mylist2.end(); ++it)
  468. 		std::cout << ' ' << *it;
  469. 	std::cout << '\n';
  470. }
  471.  
  472. { // list::swap: Exchanges the content of the container by the content of x,
  473.   // which is another list of the same type. Sizes may differ.
  474. 	std::list<int> first(3, 100);   // three ints with a value of 100
  475. 	std::list<int> second(5, 200);  // five ints with a value of 200
  476.  
  477. 	first.swap(second);
  478. 	std::swap(first, second);
  479.  
  480. 	std::cout << "first contains:";
  481. 	for (std::list<int>::iterator it = first.begin(); it != first.end(); it++)
  482. 		std::cout << ' ' << *it;
  483. 	std::cout << '\n';
  484.  
  485. 	std::cout << "second contains:";
  486. 	for (std::list<int>::iterator it = second.begin(); it != second.end(); it++)
  487. 		std::cout << ' ' << *it;
  488. 	std::cout << '\n';
  489. }
  490.  
  491. { // list::unique: Remove duplicate values
  492. 	double mydoubles[] = { 12.15, 2.72, 73.0, 12.77, 3.14,
  493. 			       12.77, 73.35, 72.25, 15.3, 72.25 };
  494. 	std::list<double> mylist(mydoubles, mydoubles + 10);
  495.  
  496. 	mylist.sort();             //  2.72,  3.14, 12.15, 12.77, 12.77,
  497. 				   // 15.3,  72.25, 72.25, 73.0,  73.35
  498.  
  499. 	mylist.unique();           //  2.72,  3.14, 12.15, 12.77
  500. 				    // 15.3,  72.25, 73.0,  73.35
  501.  
  502. 	mylist.unique(same_integral_part);  //  2.72,  3.14, 12.15
  503. 					    // 15.3,  72.25, 73.0
  504.  
  505. 	mylist.unique(is_near());           //  2.72, 12.15, 72.25
  506.  
  507. 	std::cout << "mylist contains:";
  508. 	for (std::list<double>::iterator it = mylist.begin(); it != mylist.end(); ++it)
  509. 		std::cout << ' ' << *it;
  510. 	std::cout << '\n';
  511. }
  512.  
  513. { // Performs the appropriate comparison operation between the list containers lhs and rhs
  514. 	std::list<int> a = { 10, 20, 30 };
  515. 	std::list<int> b = { 10, 20, 30 };
  516. 	std::list<int> c = { 30, 20, 10 };
  517.  
  518. 	if (a == b) std::cout << "a and b are equal\n";
  519. 	if (b != c) std::cout << "b and c are not equal\n";
  520. 	if (b<c) std::cout << "b is less than c\n";
  521. 	if (c>b) std::cout << "c is greater than b\n";
  522. 	if (a <= b) std::cout << "a is less than or equal to b\n";
  523. 	if (a >= b) std::cout << "a is greater than or equal to b\n";
  524. }
  525.  
  526. 	return 0;
  527. }
  528.  
  529. //
  530. // reference: https://msdn.microsoft.com/en-us/library/802d66bt.aspx
  531. int test_list_2()
  532. {
  533. 	using namespace std;
  534. 	// Create an empty list c0  
  535. 	list <int> c0;
  536.  
  537. 	// Create a list c1 with 3 elements of default value 0  
  538. 	list <int> c1(3);
  539.  
  540. 	// Create a list c2 with 5 elements of value 2  
  541. 	list <int> c2(5, 2);
  542.  
  543. 	// Create a list c3 with 3 elements of value 1 and with the   
  544. 	// allocator of list c2  
  545. 	list <int> c3(3, 1, c2.get_allocator());
  546.  
  547. 	// Create a copy, list c4, of list c2  
  548. 	list <int> c4(c2);
  549.  
  550. 	// Create a list c5 by copying the range c4[ first,  last)  
  551. 	list <int>::iterator c4_Iter = c4.begin();
  552. 	c4_Iter++;
  553. 	c4_Iter++;
  554. 	list <int> c5(c4.begin(), c4_Iter);
  555.  
  556. 	// Create a list c6 by copying the range c4[ first,  last) and with   
  557. 	// the allocator of list c2  
  558. 	c4_Iter = c4.begin();
  559. 	c4_Iter++;
  560. 	c4_Iter++;
  561. 	c4_Iter++;
  562. 	list <int> c6(c4.begin(), c4_Iter, c2.get_allocator());
  563.  
  564. 	cout << "c1 =";
  565. 	for (auto c : c1)
  566. 		cout << " " << c;
  567. 	cout << endl;
  568.  
  569. 	cout << "c2 =";
  570. 	for (auto c : c2)
  571. 		cout << " " << c;
  572. 	cout << endl;
  573.  
  574. 	cout << "c3 =";
  575. 	for (auto c : c3)
  576. 		cout << " " << c;
  577. 	cout << endl;
  578.  
  579. 	cout << "c4 =";
  580. 	for (auto c : c4)
  581. 		cout << " " << c;
  582. 	cout << endl;
  583.  
  584. 	cout << "c5 =";
  585. 	for (auto c : c5)
  586. 		cout << " " << c;
  587. 	cout << endl;
  588.  
  589. 	cout << "c6 =";
  590. 	for (auto c : c6)
  591. 		cout << " " << c;
  592. 	cout << endl;
  593.  
  594. 	// Move list c6 to list c7  
  595. 	list <int> c7(move(c6));
  596. 	cout << "c7 =";
  597. 	for (auto c : c7)
  598. 		cout << " " << c;
  599. 	cout << endl;
  600.  
  601. 	// Construct with initializer_list  
  602. 	list<int> c8({ 1, 2, 3, 4 });
  603. 	cout << "c8 =";
  604. 	for (auto c : c8)
  605. 		cout << " " << c;
  606. 	cout << endl;
  607.  
  608. 	return 0;
  609. }
GitHub： https://github.com/fengbingchun/Messy_Test

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/516287
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号