STL源码分析--list

相较于vector的连续线性空间，list就显得复杂许多，它的好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素移除，list永远是常数时间。

list不仅是一个双向链表，而且还是一个环状双向链表。另外，还有一个重要性质，插入操作和接合操作都不会造成原有的list迭代器失效，这在vector是不成立的。因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效。甚至list的元素删除操作（erase），也只有“指向被删除元素”的那个迭代器失效，其他迭代器不受任何影响。

以下是list的节点、迭代器数据结构设计以及list的源码剖析：

[cpp] view plaincopy

1. ////////////////////////////////////////////////////////////////////////////////
2. // list结点, 提供双向访问能力
3. ////////////////////////////////////////////////////////////////////////////////
4. //  --------           --------           --------           --------
5. //  | next |---------->| next |---------->| next |---------->| next |
6. //  --------           --------           --------           --------
7. //  | prev |<----------| prev |<----------| prev |<----------| prev |
8. //  --------           --------           --------           --------
9. //  | data |           | data |           | data |           | data |
10. //  --------           --------           --------           --------
11. ////////////////////////////////////////////////////////////////////////////////
12. template <class T>
13. struct __list_node
14. {
15. typedef void* void_pointer;
16. void_pointer next;
17. void_pointer prev;
18. T data;
19. };
20. // 至于为什么不使用默认参数, 这个是因为有一些编译器不能提供推导能力,
21. // 而作者又不想维护两份代码, 故不使用默认参数
22. template<class T, class Ref, class Ptr>
23. struct __list_iterator
24. {
25. typedef __list_iterator<T, T&, T*>             iterator;   // STL标准强制要求
26. typedef __list_iterator<T, Ref, Ptr>           self;
27. typedef bidirectional_iterator_tag iterator_category;
28. typedef T value_type;
29. typedef Ptr pointer;
30. typedef Ref reference;
31. typedef __list_node<T>* link_type;
32. typedef size_t size_type;
33. typedef ptrdiff_t difference_type;
34. link_type node;   //迭代器内部当然要有一个普通指针，指向list的节点
35. __list_iterator(link_type x) : node(x) {}
36. __list_iterator() {}
37. __list_iterator(const iterator& x) : node(x.node) {}
38. // 在STL算法中需要迭代器提供支持
39. bool operator==(const self& x) const { return node == x.node; }
40. bool operator!=(const self& x) const { return node != x.node; }
41. // 以下对迭代器取值（dereference）,取的是节点的数据值
42. reference operator*() const { return (*node).data; }
43. // 以下是迭代器的成员存取运算子的标准做法
44. pointer operator->() const { return &(operator*()); }
45. // 前缀自加，对迭代器累加1，就是前进一个节点
46. self& operator++()
47. {
48. node = (link_type)((*node).next);
49. return *this;
50. }
51. // 后缀自加, 需要先产生自身的一个副本, 然会再对自身操作, 最后返回副本
52. self operator++(int)
53. {
54. self tmp = *this;
55. ++*this;
56. return tmp;
57. }
58. // 前缀自减
59. self& operator--()
60. {
61. node = (link_type)((*node).prev);
62. return *this;
63. }
64. self operator--(int)
65. {
66. self tmp = *this;
67. --*this;
68. return tmp;
69. }
70. };
71. ////////////////////////////////////////////////////////////////////////////////
72. // list不仅是个双向链表, 而且还是一个环状双向链表
73. ////////////////////////////////////////////////////////////////////////////////
74. //       end()              头结点             begin()
75. //         ↓                  ↓                  ↓
76. //      --------           --------           --------           --------
77. // ---->| next |---------->| next |---------->| next |---------->| next |------
78. // |    --------           --------           --------           --------     |
79. // |  --| prev |<----------| prev |<----------| prev |<----------| prev |<--| |
80. // |  | --------           --------           --------           --------   | |
81. // |  | | data |           | data |           | data |           | data |   | |
82. // |  | --------           --------           --------           --------   | |
83. // |  |                                                                     | |
84. // |  | --------           --------           --------           --------   | |
85. // ---|-| next |<----------| next |<----------| next |<----------| next |<--|--
86. //    | --------           --------           --------           --------   |
87. //    ->| prev |---------->| prev |---------->| prev |---------->| prev |----
88. //      --------           --------           --------           --------
89. //      | data |           | data |           | data |           | data |
90. //      --------           --------           --------           --------
91. ////////////////////////////////////////////////////////////////////////////////
92. // 默认allocator为alloc, 其具体使用版本请参照<stl_alloc.h>
93. template <class T, class Alloc = alloc>
94. class list
95. {
96. protected:
97. typedef void* void_pointer;
98. typedef __list_node<T> list_node;
99. // 专属之空间配置器，每次配置一个节点大小
100. typedef simple_alloc<list_node, Alloc> list_node_allocator;
101. public:
102. typedef T value_type;
103. typedef value_type* pointer;
104. typedef value_type& reference;
105. typedef list_node* link_type;
106. typedef size_t size_type;
107. typedef ptrdiff_t difference_type;
108. typedef __list_iterator<T, T&, T*>             iterator;
109. protected:
110. link_type node ;     // 只要一个指针，便可表示整个环状双向链表
111. // 分配一个新结点, 注意这里并不进行构造,
112. // 构造交给全局的construct, 见<stl_stl_uninitialized.h>
113. link_type get_node() { return list_node_allocator::allocate(); }
114. // 释放指定结点, 不进行析构, 析构交给全局的destroy
115. void put_node(link_type p) { list_node_allocator::deallocate(p); }
116. // 产生（配置并构造）一个节点, 首先分配内存, 然后进行构造
117. // 注: commit or rollback
118. link_type create_node(const T& x)
119. {
120. link_type p = get_node();
121. construct(&p->data, x);
122. return p;
123. }
124. // 析构结点元素, 并释放内存
125. void destroy_node(link_type p)
126. {
127. destroy(&p->data);
128. put_node(p);
129. }
130. protected:
131. // 用于空链表的建立
132. void empty_initialize()
133. {
134. node = get_node();   // 配置一个节点空间，令node指向它
135. node->next = node;   // 令node头尾都指向自己，不设元素值
136. node->prev = node;
137. }
138. // 创建值为value共n个结点的链表
139. // 注: commit or rollback
140. void fill_initialize(size_type n, const T& value)
141. {
142. empty_initialize();
143. __STL_TRY
144. {
145. // 此处插入操作时间复杂度O(1)
146. insert(begin(), n, value);
147. }
148. __STL_UNWIND(clear(); put_node(node));
149. }
150. public:
151. list() { empty_initialize(); }
152. iterator begin() { return (link_type)((*node).next); }
153. // 链表成环, 当指所以头节点也就是end
154. iterator end() { return node; }
155. // 头结点指向自身说明链表中无元素
156. bool empty() const { return node->next == node; }
157. // 使用全局函数distance()进行计算, 时间复杂度O(n)
158. size_type size() const
159. {
160. size_type result = 0;
161. distance(begin(), end(), result);
162. return result;
163. }
164. size_type max_size() const { return size_type(-1); }
165. reference front() { return *begin(); }
166. reference back() { return *(--end()); }
167. ////////////////////////////////////////////////////////////////////////////////
168. // 在指定位置插入元素
169. ////////////////////////////////////////////////////////////////////////////////
170. //       insert(iterator position, const T& x)
171. //                       ↓
172. //                 create_node(x)
173. //                 p = get_node();-------->list_node_allocator::allocate();
174. //                 construct(&p->data, x);
175. //                       ↓
176. //            tmp->next = position.node;
177. //            tmp->prev = position.node->prev;
178. //            (link_type(position.node->prev))->next = tmp;
179. //            position.node->prev = tmp;
180. ////////////////////////////////////////////////////////////////////////////////
181. iterator insert(iterator position, const T& x)
182. {
183. link_type tmp = create_node(x);   // 产生一个节点
184. // 调整双向指针，使tmp插入进去
185. tmp->next = position.node;
186. tmp->prev = position.node->prev;
187. (link_type(position.node->prev))->next = tmp;
188. position.node->prev = tmp;
189. return tmp;
190. }
191. // 指定位置插入n个值为x的元素, 详细解析见实现部分
192. void insert(iterator pos, size_type n, const T& x);
193. void insert(iterator pos, int n, const T& x)
194. {
195. insert(pos, (size_type)n, x);
196. }
197. void insert(iterator pos, long n, const T& x)
198. {
199. insert(pos, (size_type)n, x);
200. }
201. // 在链表前端插入结点
202. void push_front(const T& x) { insert(begin(), x); }
203. // 在链表最后插入结点
204. void push_back(const T& x) { insert(end(), x); }
205. // 移除迭代器position所指节点
206. iterator erase(iterator position)
207. {
208. link_type next_node = link_type(position.node->next);
209. link_type prev_node = link_type(position.node->prev);
210. prev_node->next = next_node;
211. next_node->prev = prev_node;
212. destroy_node(position.node);
213. return iterator(next_node);
214. }
215. // 擦除一个区间的结点, 详细解析见实现部分
216. iterator erase(iterator first, iterator last);
217. void resize(size_type new_size, const T& x);
218. void resize(size_type new_size) { resize(new_size, T()); }
219. void clear();
220. // 删除链表第一个结点
221. void pop_front() { erase(begin()); }
222. // 删除链表最后一个结点
223. void pop_back()
224. {
225. iterator tmp = end();
226. erase(--tmp);
227. }
228. list(size_type n, const T& value) { fill_initialize(n, value); }
229. list(int n, const T& value) { fill_initialize(n, value); }
230. list(long n, const T& value) { fill_initialize(n, value); }
231. ~list()
232. {
233. // 释放所有结点  // 使用全局函数distance()进行计算, 时间复杂度O(n)
234. size_type size() const
235. {
236. size_type result = 0;
237. distance(begin(), end(), result);
238. return result;
239. }
240. clear();
241. // 释放头结点
242. put_node(node);
243. }
244. list<T, Alloc>& operator=(const list<T, Alloc>& x);
245. protected:
246. ////////////////////////////////////////////////////////////////////////////////
247. // 将[first, last)内的所有元素移动到position之前
248. // 如果last == position, 则相当于链表不变化, 不进行操作
249. ////////////////////////////////////////////////////////////////////////////////
250. // 初始状态
251. //                   first                             last
252. //                     ↓                                 ↓
253. //      --------   --------   --------     --------   --------   --------
254. //      | next |-->| next |-->| next |     | next |-->| next |-->| next |
255. //  ... --------   --------   -------- ... --------   --------   -------- ...
256. //      | prev |<--| prev |<--| prev |     | prev |<--| prev |<--| prev |
257. //      --------   --------   --------     --------   --------   --------
258. //
259. //                           position
260. //                               ↓
261. //      --------   --------   --------   --------   --------   --------
262. //      | next |-->| next |-->| next |-->| next |-->| next |-->| next |
263. //  ... --------   --------   --------   --------   --------   -------- ...
264. //      | prev |<--| prev |<--| prev |<--| prev |<--| prev |<--| prev |
265. //      --------   --------   --------   --------   --------   --------
266. //
267. // 操作完成后状态
268. //                           first
269. //                             |
270. //               --------------|--------------------------------------
271. //               | ------------|------------------------------------ |   last
272. //               | |           ↓                                   | |     ↓
273. //      -------- | |        --------   --------     --------       | |  --------   --------
274. //      | next |-- |  ----->| next |-->| next |     | next |-----  | -->| next |-->| next |
275. //  ... --------   |  |     --------   -------- ... --------    |  |    --------   -------- ...
276. //      | prev |<---  |  ---| prev |<--| prev |     | prev |<-- |  -----| prev |<--| prev |
277. //      --------      |  |  --------   --------     --------  | |       --------   --------
278. //                    |  |                                    | |
279. //                    |  ------                               | |
280. //                    ------- |  ------------------------------ |
281. //                          | |  |                              |
282. //                          | |  |  -----------------------------
283. //                          | |  |  |
284. //                          | |  |  |  position
285. //                          | |  |  |     ↓
286. //      --------   -------- | |  |  |  --------   --------   --------   --------
287. //      | next |-->| next |-- |  |  -->| next |-->| next |-->| next |-->| next |
288. //  ... --------   --------   |  |     --------   --------   --------   -------- ...
289. //      | prev |<--| prev |<---  ------| prev |<--| prev |<--| prev |<--| prev |
290. //      --------   --------            --------   --------   --------   --------
291. ////////////////////////////////////////////////////////////////////////////////
292. void transfer(iterator position, iterator first, iterator last)
293. {
294. if (position != last)   // 如果last == position, 则相当于链表不变化, 不进行操作
295. {
296. (*(link_type((*last.node).prev))).next = position.node;
297. (*(link_type((*first.node).prev))).next = last.node;
298. (*(link_type((*position.node).prev))).next = first.node;
299. link_type tmp = link_type((*position.node).prev);
300. (*position.node).prev = (*last.node).prev;
301. (*last.node).prev = (*first.node).prev;
302. (*first.node).prev = tmp;
303. }
304. }
305. public:
306. // 将链表x移动到position所指位置之前
307. void splice(iterator position, list& x)
308. {
309. if (!x.empty())
310. transfer(position, x.begin(), x.end());
311. }
312. // 将链表中i指向的内容移动到position之前
313. void splice(iterator position, list&, iterator i)
314. {
315. iterator j = i;
316. ++j;
317. if (position == i || position == j) return;
318. transfer(position, i, j);
319. }
320. // 将[first, last}元素移动到position之前
321. void splice(iterator position, list&, iterator first, iterator last)
322. {
323. if (first != last)
324. transfer(position, first, last);
325. }
326. void remove(const T& value);
327. void unique();
328. void merge(list& x);
329. void reverse();
330. void sort();
331. };
332. // 销毁所有结点, 将链表置空
333. template <class T, class Alloc>
334. void list<T, Alloc>::clear()
335. {
336. link_type cur = (link_type) node->next;
337. while (cur != node)
338. {
339. link_type tmp = cur;
340. cur = (link_type) cur->next;
341. destroy_node(tmp);
342. }
343. // 恢复node原始状态
344. node->next = node;
345. node->prev = node;
346. }
347. // 链表赋值操作
348. // 如果当前容器元素少于x容器, 则析构多余元素,
349. // 否则将调用insert插入x中剩余的元素
350. template <class T, class Alloc>
351. list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x)
352. {
353. if (this != &x)
354. {
355. iterator first1 = begin();
356. iterator last1 = end();
357. const_iterator first2 = x.begin();
358. const_iterator last2 = x.end();
359. while (first1 != last1 && first2 != last2) *first1++ = *first2++;
360. if (first2 == last2)
361. erase(first1, last1);
362. else
363. insert(last1, first2, last2);
364. }
365. return *this;
366. }
367. // 移除容器内所有的相邻的重复结点
368. // 时间复杂度O(n)
369. // 用户自定义数据类型需要提供operator ==()重载
370. template <class T, class Alloc>
371. void list<T, Alloc>::unique()
372. {
373. iterator first = begin();
374. iterator last = end();
375. if (first == last) return;
376. iterator next = first;
377. while (++next != last)
378. {
379. if (*first == *next)
380. erase(next);
381. else
382. first = next;
383. next = first;
384. }
385. }
386. // 假设当前容器和x都已序, 保证两容器合并后仍然有序
387. template <class T, class Alloc>
388. void list<T, Alloc>::merge(list<T, Alloc>& x)
389. {
390. iterator first1 = begin();
391. iterator last1 = end();
392. iterator first2 = x.begin();
393. iterator last2 = x.end();
394. // 注意：前提是，两个lists都已经递增排序
395. while (first1 != last1 && first2 != last2)
396. if (*first2 < *first1)
397. {
398. iterator next = first2;
399. transfer(first1, first2, ++next);
400. first2 = next;
401. }
402. else
403. ++first1;
404. if (first2 != last2)
405. transfer(last1, first2, last2);
406. }