STL之list学习（2）（list代码实现）（只剩最后一步，迭代器升级！！）

《数据结构与算法分析》书本代码，书本的代码内容居然分开超多部分，看起来真得很痛苦，之前看这一章老是看到这一部分就不想看，list的实现本来就麻烦，而且分开，所以一直都是跳开。不过通过认真分析，再敲代码，一边敲代码一边理解，收获真得很不错，而且这本书的习题很赞，有很多题都是要你在程序上完善，修改、添加。好了，体外话说完。

PS：这次加了两张图片！（《数据结构与算法分析》的图片，方便理解）。

PS：添加了习题3.15和3.16.

见：http://www.cnblogs.com/alan-forever/archive/2012/10/15/2725290.html

看了这些代码有数遍之后，觉得将const_iterator、iterator迭代器设置为公有嵌套类是很不错的。因为const_iterator、iterator迭代器，不同于Vector的迭代器，Vector的迭代器只是简单指针而这个List的迭代器的基本实现要比Vector的复杂。Vector原理是数组，数组本来就是指针，里面的元素储存在连续的地址里面，（++）（--）操作符不用重载就可以实现功能。而List不一样除了储存元素，它还有前指针、后指针，它是通过这些指针连接它之前及之后的Node（结点），因此List里面的元素在物理上是不连续的，所以要实现它的迭代器功能就需要定义一个类，并且重载操作符。（个人愚见）

  1 #include<iostream>
  2 using namespace std;
  3 
  4 template <typename Object>
  5 class List
  6 {
  7 private:
  8     struct Node                                 //私有嵌套结构体。
  9     {
 10         Object data;
 11         Node *prev;
 12         Node *next;
 13 
 14         Node( const Object & d = Object( ), Node *p = NULL, Node *n = NULL ) : data( d ), prev( p ), next( n ) { }
 15     };                                          /*Node结构体包含存储的项、指向Node之前及之后的指针和一个构造函数。都是公有的数据成员*/
 16 public:
 17     class const_iterator                        //公有嵌套类。
 18     {
 19     public:
 20         const_iterator( ) : current ( NULL ) { }     //const_iterator类的无参数构造函数。
 21 
 22         const Object & operator* ( ) const
 23         {
 24             return retrieve( );
 25         }                                           //解引用操作符的重载。调用retrieve函数。
 26 
 27         const_iterator & operator++ ( )
 28         {
 29             current = current->next;
 30             return *this;
 31         }
 32         //前自增操作符重载。当前的结点直接变成它指向的下一个结点，并返回。
 33         const_iterator operator++ ( int )
 34         {
 35             const_iterator old = *this;
 36             ++( *this );
 37             return old;
 38         }
 39         //后自增操作符重载。要先存储当前的结点，再调用前自增操作符，最后返回储存的结点。
 40         const_iterator operator-- ( )
 41         {
 42             current = current->prev;
 43             return *this;
 44         }
 45         //前自减操作符重载。当前的结点直接直接变成它指向的前一个结点，并返回。
 46         const_iterator operator-- ( int )
 47         {
 48             const_iterator old = *this;
 49             --( *this );
 50             return old;
 51         }
 52         //后自减操作符重载。先储存当前结点，再调用前自减操作符，最后返回储存的结点。
 53         const_iterator  operator+( int k ) const
 54         {
 55             const_iterator itr = *this;
 56             for( int i = 1; i <= k; ++i )
 57                 itr.current = itr.current->next;
 58             return itr;
 59         }
 60 
 61         bool operator== ( const const_iterator & rhs ) const
 62         {
 63             return current == rhs.current;
 64         }
 65         bool operator != ( const const_iterator & rhs ) const
 66         {
 67             return !( *this == rhs );
 68         }
 69         //（==）（!=）操作符的重载。
 70     protected:
 71         Node *current;
 72 
 73         Object & retrieve( ) const
 74         {
 75             return current->data;
 76         }                                       //返回当前结点储存的元素。
 77 
 78         const_iterator( Node *p ) : current( p ) { }    //const_iterator的构造函数，储存当前结点
 79 
 80         friend class List<Object>;              //友元函数，可以让List调用const_iterator的函数。
 81     };
 82 
 83     class iterator//安装书本的代码，这个应该是const_iterator的派生类，因为很多操作都一样，但是老是报错，也只好这样写。
 84     {
 85     public:
 86         iterator( ) : current ( NULL ) { }
 87 
 88         Object & operator* ( )
 89         {
 90             return retrieve( );
 91         }
 92 
 93         iterator & operator++ ( )
 94         {
 95             current = current->next;
 96             return *this;
 97         }
 98 
 99         iterator operator++ ( int )
100         {
101             iterator old = *this;
102             ++( *this );
103             return old;
104         }
105         iterator operator-- ( )
106         {
107             current = current->prev;
108             return *this;
109         }
110         iterator operator-- ( int )
111         {
112             iterator old = *this;
113             --( *this );
114             return old;
115         }
116 
117         iterator  operator+( int k )
118         {
119             iterator itr = *this;
120             for( int i = 1; i <= k; ++i )
121                 itr.current = itr.current->next;
122             return itr;
123         }
124 
125 
126         bool operator== ( const iterator & rhs ) const
127         {
128             return current == rhs.current;
129         }
130         bool operator != ( const iterator & rhs ) const
131         {
132             return !( *this == rhs );
133         }
134 
135     protected:
136         Node *current;
137 
138         Object & retrieve( ) const
139         {
140             return current->data;
141         }
142 
143         iterator( Node *p ) : current( p ) { }
144 
145         friend class List<Object>;
146     };
147 
148     class const_reverse_iterator
149     {
150     public:
151         const_reverse_iterator( ) : current( NULL ) { }
152 
153         const Object & operator* ( ) const
154         {
155             return retrieve( );
156         }
157 
158         const_reverse_iterator & operator++ ( )
159         {
160             current = current->prev;
161             return * this;
162         }
163 
164         const_reverse_iterator  operator++ ( int )
165         {
166             const_reverse_iterator old = *this;
167             ++( *this );
168             return old;
169         }
170 
171         const_reverse_iterator & operator--  ( )
172         {
173             current = current->next;
174             return * this;
175         }
176 
177         const_reverse_iterator  operator-- ( int )
178         {
179             const_reverse_iterator old = *this;
180             ++( *this );
181             return old;
182         }
183 
184         bool operator== ( const const_reverse_iterator & rhs ) const
185         {
186             return current == rhs.current;
187         }
188 
189         bool operator!= ( const const_reverse_iterator & rhs ) const
190         {
191             return !( *this == rhs );
192         }
193 
194     private:
195         Node * current;
196 
197         Object & retrieve( ) const
198         {
199             return current->data;
200         }
201 
202         const_reverse_iterator( Node * p ) : current( p ) { }
203 
204         friend class List<Object>;
205     };
206     //逆向迭代器
207 
208     class reverse_iterator
209     {
210     public:
211         reverse_iterator( ) : current( NULL ) { }
212 
213         const Object & operator* ( ) const
214         {
215             return retrieve( );
216         }
217 
218         reverse_iterator & operator++ ( )
219         {
220             current = current->prev;
221             return * this;
222         }
223 
224         reverse_iterator  operator++ ( int )
225         {
226             reverse_iterator old = *this;
227             ++( *this );
228             return old;
229         }
230 
231         const_reverse_iterator & operator--  ( )
232         {
233             current = current->next;
234             return * this;
235         }
236 
237         reverse_iterator  operator-- ( int )
238         {
239             const_reverse_iterator old = *this;
240             --( *this );
241             return old;
242         }
243 
244         bool operator== ( const reverse_iterator & rhs ) const
245         {
246             return current == rhs.current;
247         }
248 
249         bool operator!= ( const reverse_iterator & rhs ) const
250         {
251             return !( *this == rhs );
252         }
253 
254     private:
255         Node * current;
256 
257         Object & retrieve( ) const
258         {
259             return current->data;
260         }
261 
262         reverse_iterator( Node * p ) : current( p ) { }
263 
264         friend class List<Object>;
265     };
266     //逆向迭代器
267 
268 public:
269     List()
270     {
271         init( );
272     }
273     //List的构造函数，调用私有成员函数init。生成一个默认链表（有表头、表尾结点的链表）。
274     ~List()
275     {
276         clear();
277         delete head;
278         delete tail;
279     }
280     //析构函数，要将里面都东西删除了。
281     List( const List & rhs)
282     {
283         init( );
284         *this = rhs;
285     }
286     //复制构造函数。
287     const List & operator= ( const List & rhs)
288     {
289         if( this == &rhs)
290             return *this;
291         clear();
292         for( const_iterator itr = rhs.begin(); itr != rhs.end(); ++itr)
293             push_back( *itr );
294         return *this;
295     }
296     //（=）操作符重载。
297     iterator begin( )
298     {
299         return iterator( head->next );
300     }
301     const_iterator begin( ) const
302     {
303         return const_iterator( head->next );
304     }                                           //begin迭代器。不是返回head。head只是表头，不是储存第一个元素的结点。
305     iterator end( )
306     {
307         return iterator( tail );
308     }
309     const_iterator end( ) const
310     {
311         return const_iterator( tail );
312     }
313     //end迭代器。返回tail，因为它一定是储存最后一个元素的结点的后一个。
314 
315     reverse_iterator rbegin( )
316     {
317         return reverse_iterator( tail->prev );
318     }
319     const_reverse_iterator rbegin( ) const
320     {
321         return const_reverse_iterator( tail->prev );
322     }
323     //逆向begin迭代器，返回tail的前一个迭代器。
324     
325     reverse_iterator rend( )
326     {
327         return reverse_iterator( head );
328     }
329     const_reverse_iterator rend( ) const
330     {
331         return const_reverse_iterator( head );
332     }
333     //逆向end迭代器，返回head节点的迭代器。
334 
335     int size( )
336     {
337         return theSize;
338     }                                           //返回链表的大小。
339     bool empty( )
340     {
341         return size( ) == 0;
342     }
343 
344     void clear( )
345     {
346         while( !empty( ) )
347             pop_front( );
348     }
349     //将链表清空。
350     Object & front( )
351     {
352         return *begin( );
353     }
354     const Object & front( ) const
355     {
356         return *begin( );
357     }
358     //返回第一个元素，即返回begin迭代器指向的元素。调用iterator的（*）操作符。
359     Object & back( )
360     {
361         return *--end( );
362     }
363     const Object & back( ) const
364     {
365         return *--end( );
366     }
367     //返回最后一个元素，即返回end迭代器的前一个结点的元素。
368     void push_front( const Object & x)
369     {
370         insert( begin( ), x );
371     }
372     //头插入！调用insert函数，在第一个元素前插入新的元素。
373     void push_back( const Object & x )
374     {
375         insert( end( ), x );
376     }
377     //尾插入！调用insert函数，在表尾结点前插入新的元素，相当于插在最后一个元素的后面。
378     void pop_front( )
379     {
380         erase( begin( ) );
381     }
382     //删除第一个元素，调用erase函数。
383     void pop_back( )
384     {
385         erase( --end( ) );
386     }
387     //删除最后一个函数。所以end迭代器返回的迭代器要自减才是最后一个函数。
388     iterator insert( iterator itr, const Object & x )
389     {
390         Node *p = itr.current;
391         theSize++;
392         return iterator( p->prev = p->prev->next = new Node( x, p->prev, p ) );
393     }
394     //将新的结点插入指定的迭代器的前面。见图二。
395     iterator erase ( iterator itr)
396     {
397         Node *p = itr.current;
398         iterator retVal( p->next );
399         p->prev->next = p->next;
400         p->next->prev = p->prev;
401         delete p;
402         theSize--;
403 
404         return retVal;
405     }                                           //删除迭代器指向的结点，并返回一个迭代器，指向被删除元素后面的元素。
406     iterator erase ( iterator start, iterator end )
407     {
408         for( iterator itr = start; itr != end; )
409             itr = erase( itr );
410 
411         return end;
412     }
413 
414     //删除迭代器start和end所标记的范围所有元素，返回一个迭代器，指向被删除元素段后面的元素。
415 
416     void splice( iterator position, List<Object> & lst )
417     {
418         Node *p = position.current;
419 
420         p->prev->next = lst.head->next;
421         lst.head->next->prev = p->prev;
422         lst.tail->prev->next = p;
423         p->prev = lst.tail->prev;
424 
425         theSize += lst.size();
426 
427         lst.init();
428     }
429 
430     friend iterator find(iterator start, iterator end, const Object & x )
431     {
432         iterator itr = start;
433         while( itr != end && *itr != x )
434         {
435             ++itr;
436         }
437         return itr;
438     }
439 
440 private:
441     int theSize;                                //链表的大小
442     Node *head;                                 //表头结点
443     Node *tail;                                 //表尾结点
444 
445     void init()
446     {
447         theSize = 0;
448         head = new Node;
449         tail = new Node;
450         head->next = tail;
451         tail->prev = head;
452     }                                           //init函数，初始化链表。见图一
453 };
454 
455 
456 int main( )
457 {
458     List<int> l1;
459     List<int> l2;
460     int num, m;
461     cout << "l1的元素数量：" << endl;
462     cout << l1.size() << endl;
463     if( l2.empty() )
464         cout << "l2为空的！" << endl;
465     else
466         cout << "l2不是空的！" << endl;
467     cout << "输入你想插入链表的元素个数：" << endl;
468     cin >> num;
469     for(int i = 1; i <= num; ++i)
470     {
471         cin >> m;
472         l1.push_back(m);
473         l2.push_front(m);
474     }
475 
476     /*List<int>::iterator itr1 = l1.begin();
477     List<int>::iterator itr = itr1 + 5;
478     cout << *itr << endl;*/
479     //3.14
480 
481     /*List<int>::iterator itr1 = l1.begin();
482     List<int>::iterator itr2 = --l2.end();
483     List<int>::iterator itr = find( itr1, itr2, 20);
484     cout << *itr << endl;*/
485     //3.3
486 
487     /*List<int>::reverse_iterator itr1 = l1.rbegin();
488     while( itr1 != l1.rend() )
489         cout << *itr1++ <<" ";
490     cout << endl;*/
491     //3.16
492 
493     /*List<int>::iterator pos = l1.begin();
494     l1.splice( pos, l2 );
495 
496     for(List<int>::iterator itr = l1.begin(); itr != l1.end(); ++itr)
497         cout << *itr << " ";
498     cout << endl;*/
499     //3.15
500 
501     cout << "l1的元素数量：" << endl;
502     cout << l1.size() << endl;
503     cout << "l2的元素数量：" << endl;
504     cout << l2.size() << endl;
505     cout << "l1是尾插入，l2是头插入！！！！" << endl;
506     cout << "l1的全部元素顺序输出：" << endl;
507     for(List<int>::iterator itr = l1.begin(); itr != l1.end(); ++itr)
508         cout << *itr << " ";
509     cout << endl;
510     cout << "l2的全部元素顺序输出：" << endl;
511     for(List<int>::iterator itr = l2.begin(); itr != l2.end(); ++itr)
512         cout << *itr << " ";
513     cout << endl;
514     cout << "l1的第一个元素： " <<l1.front() << endl;
515     cout << "l1的最后一个元素： " <<l1.back() << endl;
516     cout << "l2的第一个元素： " <<l2.front() << endl;
517     cout << "l2的最后一个元素： " <<l2.back() << endl;
518     List<int> l3(l1);
519     cout << "l3为调用复制构造函数！" << endl;
520     cout << "l3中元素的数目：" << endl;
521     cout << l3.size() << endl;
522     cout << "输出l3的全部元素！（与l1的全部元素比较，同一个位置上的元素是一样！）" << endl;
523     for(List<int>::iterator itr = l3.begin(); itr != l3.end(); ++itr)
524         cout << *itr << " ";
525     cout << endl;
526     List<int>::iterator itr1 = l3.begin();
527     l3.erase( itr1 );
528     cout << "对l3调用erase函数，删除begin迭代器所知指向的元素！" << endl;
529     cout << "输出l3中元素的数数目：" << endl;
530     cout << l3.size() << endl;
531     cout << "输出l3的全部元素：" << endl;
532     for(List<int>::iterator itr = l3.begin(); itr != l3.end(); ++itr)
533         cout << *itr << " ";
534     cout << endl;
535     List<int>::iterator itr2 = l3.begin();
536     List<int>::iterator itr3 = l3.end();
537     l3.erase( itr2, itr3);
538     cout << "对l3调用erase函数，删除迭代器begin和end之间的全部元素！" << endl;
539     cout << "输出l3重元素的数目！" << endl;
540     cout << l3.size() << endl;
541     return 0;
542 }