STL源码剖析

原文：http://blog.csdn.net/a809146548/article/details/51391893?locationNum=4&fps=1

笔记：

1. alloc：所有STL数据结构的内存分配基于一个alloc，STL 自定义一个alloc，是一个16条不同内存大小的内存链组成，每次申请都选择合适的内存链来取出空闲的内存块。
2. vector，内部是一个数组，可动态增长空间，每次增长时都要copy所有的元素，可随机访问
3. dequeue：内部是多个分段的数组，用额外的一个数组来标记各个分段数组信息，迭代器由于要考虑分段数组边界的问题，实现比较复杂。可在前面添加或后面添加。
4. List：内部是一个双向环形链表，添加和删除不需要移动数据，不可随机访问。
5. 红黑树：类平衡树，每个路径的黑节点数量相同，一个红节点后面必须跟黑节点，这样保证不会有任何一条路径大于别的路径的2倍。没有平衡树那么严格平衡，减少插入和删除的开销。
6. map，multiple_map：内部由红黑树组成
7. set，multiple set：内部由红黑树组成

 

STL源码剖析

标签： C++C++11算法数据结构源码

2016-05-13 01:40  1101人阅读  评论(0)  收藏  举报

  分类：

C++基本知识（196） 

目录(?)[+]

STL源码剖析---空间配置器

看过STL空间配置器的源码，总结一下：
      1、STL空间配置器：主要分三个文件实现，stl_construct.h  这里定义了全局函数construct()和destroy()，负责对象的构造和析构。stl_alloc.h文件中定义了一、二两级配置器，彼此合作，配置器名为alloc. stl_uninitialized.h 这里定义了一些全局函数，用来填充(fill)或复制(copy)大块内存数据，他们也都隶属于STL标准规划。
      在stl_alloc.h中定义了两级配置器，主要思想是申请大块内存池，小块内存直接从内存池中申请，当不够用时再申请新的内存池，还有就是大块内存直接申请。当申请空间大于128字节时调用第一级配置器，第一级配置器没有用operator::new和operator::delete来申请空间，而是直接调用malloc/free和realloc，并且实现了类似c++中new-handler的机制。所谓c++ new handler机制是，你可以要求系统在内存配置需求无法被满足时，调用一个指定的函数。换句话说，一旦::operator::new无法完成任务，在丢出std::bad_alloc异常状态之前，会先调用由客端指定的处理例程，该处理例程通常称为new-handler.new-handler解决内存做法有特定的模式。SGI第一级配置器的allocate()和realloc都是在调用malloc和realloc不成功后，改调用oom_malloc()和oom_realloc()，后两者都有内循环，不断调用"内存不足处理例程"，期望在某次调用之后，获得足够的内存而圆满完成任务。但如果“内存不足处理例程“并未被客端设定，oom_malloc()和oom_realloc便调用_THROW_BAD_ALLOC, 丢出bad_alloc异常信息，或利用exit(1)硬生生中止程序。
     在stl_alloc.h中定义的第二级配置器中，如果区块够大，超过128字节时，就移交给第一级配置器处理。当区块小于128字节时，则以内存池管理，此法又称为次层配置，每次配置一大块内存，并维护对应的自由链表(free-list)。下次若再有相同大小的内存需求，就直接从free-list中拔出。如果客端释还小额区块，就由配置器回收到free-lists中，另外，配置器除了负责配置，也负责回收。为了管理方便，SGI第二级配置器会主动将任何小额区块的内存需求量上调至8的倍数。并维护16个free-lists，各自管理大小分别为8，16，24，32，40，48，56，64，72，80，88，96，104， 112，120，128 字节的小额区块。当申请小于等于128字节时就会检查对应的free list，如果free-list中有可用的区块，就直接拿来，如果没有，就准备为对应的free-list 重新填充空间。新的空间将取自内存池，缺省取得20个新节点，如果内存池不足（还足以一个以上的节点），就返回的相应的节点数.如果当内存池中连一个节点大小都不够时，就申请新的内存池,大小为2*total_bytes+ROUND_UP(heap_size>>4)，totoal_bytes 为申请的空间大小，ROUND_UP调整为8的倍数，heap_size为当前总申请内存池的大小。如果申请该内存池成功就把原来内存池中剩下的空间分配给适当的free-list.万一山穷水尽，整个system heap空间都不够了（以至无法为内存池注入源头活水），malloc()行动失败，就会四处寻找有无"尚有未用区块，且区块足够大 "之free lists.找到了就挖一块交出，找不到就调用第一级配置器。第一级配置器其实也是使用malloc来配置内存。但它有out-of-memory处理机制（类似new-handler机制），或许有机会释放其他的内存拿来此处使用。如果可以就成功，否则发出bad_alloc异常。
      2、STL的默认内存分配器
      隐藏在这些容器后的内存管理工作是通过STL提供的一个默认的allocator实现的。当然，用户也可以定制自己的allocator，只要实现allocator模板所定义的接口方法即可，然后通过将自定义的allocator作为模板参数传递给STL容器，创建一个使用自定义allocator的STL容器对象，如：
    stl::vector<int, UserDefinedAllocator> array;
      大多数情况下，STL默认的allocator就已经足够了。这个allocator是一个由两级分配器构成的内存管理器，当申请的内存大小大于128byte时，就启动第一级分配器通过malloc直接向系统的堆空间分配，如果申请的内存大小小于128byte时，就启动第二级分配器，从一个预先分配好的内存池中取一块内存交付给用户，这个内存池由16个不同大小（8的倍数，8~128byte）的空闲列表组成，allocator会根据申请内存的大小（将这个大小round up成8的倍数）从对应的空闲块列表取表头块给用户。
这种做法有两个优点：
     (1)小对象的快速分配。小对象是从内存池分配的，这个内存池是系统调用一次malloc分配一块足够大的区域给程序备用，当内存池耗尽时再向系统申请一块新的区域，整个过程类似于批发和零售，起先是由allocator向总经商批发一定量的货物，然后零售给用户，与每次都总经商要一个货物再零售给用户的过程相比，显然是快捷了。当然，这里的一个问题时，内存池会带来一些内存的浪费，比如当只需分配一个小对象时，为了这个小对象可能要申请一大块的内存池，但这个浪费还是值得的，况且这种情况在实际应用中也并不多见。
     (2)避免了内存碎片的生成。程序中的小对象的分配极易造成内存碎片，给操作系统的内存管理带来了很大压力，系统中碎片的增多不但会影响内存分配的速度，而且会极大地降低内存的利用率。以内存池组织小对象的内存，从系统的角度看，只是一大块内存池，看不到小对象内存的分配和释放。
实现时，allocator需要维护一个存储16个空闲块列表表头的数组free_list，数组元素i是一个指向块大小为8*(i+1)字节的空闲块列表的表头，一个指向内存池起始地址的指针start_free和一个指向结束地址的指针end_free。空闲块列表节点的结构如下：

[cpp]  view plain  copy

1. union obj  
2. {  
3.     union obj * free_list_link;  
4.     char client_data[1];  
5. };  

      这个结构可以看做是从一个内存块中抠出4个字节大小来，当这个内存块空闲时，它存储了下个空闲块，当这个内存块交付给用户时，它存储的时用户的数据。因此，allocator中的空闲块链表可以表示成：
    obj* free_list[16];
      3、分配算法 

[cpp]  view plain  copy

1. // 算法：allocate  
2. // 输入：申请内存的大小size  
3. // 输出：若分配成功，则返回一个内存的地址，否则返回NULL  
4. {  
5.     if(size 大于 128)  
6.         启动第一级分配器直接调用malloc分配所需的内存并返回内存地址；  
7.     else  
8.     {  
9.         将size向上round up成8的倍数并根据大小从free_list中取对应的表头free_list_head  
10.         if(free_list_head 不为空)  
11.         {  
12.             从该列表中取下第一个空闲块并调整free_list,返回free_list_head  
13.         }  
14.         else  
15.         {  
16.             调用refill算法建立空闲块列表并返回所需的内存地址  
17.         }  
18.     }  
19. }  
20.   
21.   
22. // 算法：refill  
23. // 输入：内存块的大小size  
24. // 输出：建立空闲块链表并返回第一个可用的内存地址  
25. {  
26.     调用chunk_alloc算法分配若干个大小为size的连续内存区域并返回起始地址chunk和成功分配的块数nobj  
27.     if(块数为1)  
28.         直接返回 chunk;  
29.     else  
30.     {  
31.         开始在chunk地址块中建立free_list  
32.         根据size取free_list中对应的表头元素free_list_head   
33.         将free_list_head 指向chunk中偏移起始地址为size的地址处，即free_list_head = (obj*)(chunk+size)  
34.         再将整个chunk中剩下的nobj-1个内存块串联起来构成一个空闲列表  
35.         返回chunk，即chunk中第一个空闲的内存块  
36.     }  
37. }  
38.   
39.   
40. // 算法：chunk_alloc  
41. // 输入：内存块的大小size,预分配的内存块数nobj(以引用传递)  
42. // 输出：一块连续的内存区域的地址和该区域内可以容纳的内存块的块数  
43. {  
44.     计算总共所需的内存大小total_bytes  
45.     if(内存池足以分配，即end_free-start_free >= total_bytes)  
46.     {  
47.         则更新start_free  
48.         返回旧的start_free  
49.     }  
50.     else if(内存池不够分配nobj个内存块，但至少可以分配一个)  
51.     {  
52.         计算可以分配的内存块数并修改nobj  
53.         更新start_free并返回原来的start_free  
54.     }  
55.     else     // 内存池连一个内存块都分配不了  
56.     {  
57.         先将内存池的内存块链入到对应的free_list中后  
58.         调用malloc操作重新分配内存池，大小为2倍的total_bytes为附加量，start_free指向返回的内存地址  
59.         if(分配不成功)  
60.         {  
61.             if(16个空闲列表中尚有空闲块)  
62.                 尝试将16个空闲列表中空闲块回收到内存池中再调用chunk_alloc(size,nobj)  
63.             else  
64.                 调用第一级分配器尝试out of memory机制是否还有用  
65.         }  
66.         更新end_free为start_free+total_bytes，heap_size为2倍的total_bytes  
67.         调用chunk_alloc(size,nobj)  
68.     }  
69. }  
70.   
71.   
72. // 算法：deallocate  
73. // 输入：需要释放的内存块地址p和大小size  
74. {  
75.     if(size 大于128字节)  
76.         直接调用free(p)释放  
77.     else  
78.     {  
79.         将size向上取8的倍数，并据此获取对应的空闲列表表头指针free_list_head  
80.         调整free_list_head将p链入空闲列表块中  
81.     }  
82. }  

假设这样一个场景，free_list[2]已经指向了大小为24字节的空闲块链表，如图1所示，当用户向allocator申请21字节大小的内存块时，allocaotr会首先检查free_list[2]并将free_list[2]所指的内存块分配给用户，然后将表头指向下一个可用的空闲块，如图2所示。注意，当内存块在链表上是，前4个字节是用作指向下一个空闲块，当分配给用户时，它是一块普通的内存区。

                        图1 某时刻allocator的状态 

                                  图2 分配24字节大小的内存块 
4、小结
STL中的内存分配器实际上是基于空闲列表(free list)的分配策略，最主要的特点是通过组织16个空闲列表，对小对象的分配做了优化。
1）小对象的快速分配和释放。当一次性预先分配好一块固定大小的内存池后，对小于128字节的小块内存分配和释放的操作只是一些基本的指针操作，相比于直接调用malloc/free，开销小。
2）避免内存碎片的产生。零乱的内存碎片不仅会浪费内存空间，而且会给OS的内存管理造成压力。
3）尽可能最大化内存的利用率。当内存池尚有的空闲区域不足以分配所需的大小时，分配算法会将其链入到对应的空闲列表中，然后会尝试从空闲列表中寻找是否有合适大小的区域，
但是，这种内存分配器局限于STL容器中使用，并不适合一个通用的内存分配。因为它要求在释放一个内存块时，必须提供这个内存块的大小，以便确定回收到哪个free list中，而STL容器是知道它所需分配的对象大小的，比如上述：
    stl::vector<int> array;
array是知道它需要分配的对象大小为sizeof(int)。一个通用的内存分配器是不需要知道待释放内存的大小的，类似于free(p)。

STL源码剖析---vector

vector容器概述
      vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间的运用的灵活性。array是静态空间，一旦配置了就不能改变；要换个大（或小）一点的房子，可以，一切琐细都得由客户端自己来：首先配置一块新空间，然后将元素从旧址一一搬往新址，再把原来的空间释还给系统。vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。因此，vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必因为害怕空间不足而一开始要求一个大块头的array了，我们可以安心使用array，吃多少用多少。
      vector的实现技术，关键在于其对大小的控制以及重新配置时的数据移动效率。一旦vector的旧有空间满载，如果客户端每新增一个元素，vector的内部只是扩充一个元素的空间，实为不智。因为所谓扩充空间（不论多大），一如稍早所说，是”配置新空间/数据移动/释还旧空间“的大工程，时间成本很高，应该加入某种未雨绸缪的考虑。稍后我们便可看到SGI vector的空间配置策略了。
      另外，由于vector维护的是一个连续线性空间，所以vector支持随机存取。
      注意：vector动态增加大小时，并不是在原空间之后持续新空间（因为无法保证原空间之后尚有可供配置的空间），而是以原大小的两倍另外配置一块较大的空间，然后将原内容拷贝过来，然后才开始在原内容之后构造新元素，并释放原空间。因此，对vector的任何操作，一旦引起空间重新配置，指向原vector的所有迭代器就都失效了。这是程序员易犯的一个错误，务需小心。
以下是vector定义的源代码摘录：

[cpp]  view plain  copy

1. #include<iostream>  
2. using namespace std;  
3. #include<memory.h>    
4.   
5. // alloc是SGI STL的空间配置器  
6. template <class T, class Alloc = alloc>  
7. class vector  
8. {  
9. public:  
10.     // vector的嵌套类型定义,typedefs用于提供iterator_traits<I>支持  
11.     typedef T value_type;  
12.     typedef value_type* pointer;  
13.     typedef value_type* iterator;  
14.     typedef value_type& reference;  
15.     typedef size_t size_type;  
16.     typedef ptrdiff_t difference_type;  
17. protected:  
18.     // 这个提供STL标准的allocator接口  
19.     typedef simple_alloc <value_type, Alloc> data_allocator;  
20.   
21.     iterator start;               // 表示目前使用空间的头  
22.     iterator finish;              // 表示目前使用空间的尾  
23.     iterator end_of_storage;      // 表示实际分配内存空间的尾  
24.   
25.     void insert_aux(iterator position, const T& x);  
26.   
27.     // 释放分配的内存空间  
28.     void deallocate()  
29.     {  
30.         // 由于使用的是data_allocator进行内存空间的分配,  
31.         // 所以需要同样使用data_allocator::deallocate()进行释放  
32.         // 如果直接释放, 对于data_allocator内部使用内存池的版本  
33.         // 就会发生错误  
34.         if (start)  
35.             data_allocator::deallocate(start, end_of_storage - start);  
36.     }  
37.   
38.     void fill_initialize(size_type n, const T& value)  
39.     {  
40.         start = allocate_and_fill(n, value);  
41.         finish = start + n;                         // 设置当前使用内存空间的结束点  
42.         // 构造阶段, 此实作不多分配内存,  
43.         // 所以要设置内存空间结束点和, 已经使用的内存空间结束点相同  
44.         end_of_storage = finish;  
45.     }  
46.   
47. public:  
48.     // 获取几种迭代器  
49.     iterator begin() { return start; }  
50.     iterator end() { return finish; }  
51.   
52.     // 返回当前对象个数  
53.     size_type size() const { return size_type(end() - begin()); }  
54.     size_type max_size() const { return size_type(-1) / sizeof(T); }  
55.     // 返回重新分配内存前最多能存储的对象个数  
56.     size_type capacity() const { return size_type(end_of_storage - begin()); }  
57.     bool empty() const { return begin() == end(); }  
58.     reference operator[](size_type n) { return *(begin() + n); }  
59.   
60.     // 本实作中默认构造出的vector不分配内存空间  
61.     vector() : start(0), finish(0), end_of_storage(0) {}  
62.   
63.   
64.     vector(size_type n, const T& value) { fill_initialize(n, value); }  
65.     vector(int n, const T& value) { fill_initialize(n, value); }  
66.     vector(long n, const T& value) { fill_initialize(n, value); }  
67.   
68.     // 需要对象提供默认构造函数  
69.     explicit vector(size_type n) { fill_initialize(n, T()); }  
70.   
71.     vector(const vector<T, Alloc>& x)  
72.     {  
73.         start = allocate_and_copy(x.end() - x.begin(), x.begin(), x.end());  
74.         finish = start + (x.end() - x.begin());  
75.         end_of_storage = finish;  
76.     }  
77.   
78.     ~vector()  
79.     {  
80.         // 析构对象  
81.         destroy(start, finish);  
82.         // 释放内存  
83.         deallocate();  
84.     }  
85.   
86.     vector<T, Alloc>& operator=(const vector<T, Alloc>& x);  
87.   
88.     // 提供访问函数  
89.     reference front() { return *begin(); }  
90.     reference back() { return *(end() - 1); }  
91.   
92.       
93.     // 向容器尾追加一个元素, 可能导致内存重新分配  
94.       
95.     //                          push_back(const T& x)  
96.     //                                   |  
97.     //                                   |---------------- 容量已满?  
98.     //                                   |  
99.     //               ----------------------------  
100.     //           No  |                          |  Yes  
101.     //               |                          |  
102.     //               ↓                          ↓  
103.     //      construct(finish, x);       insert_aux(end(), x);  
104.     //      ++finish;                           |  
105.     //                                          |------ 内存不足, 重新分配  
106.     //                                          |       大小为原来的2倍  
107.     //      new_finish = data_allocator::allocate(len);       <stl_alloc.h>  
108.     //      uninitialized_copy(start, position, new_start);   <stl_uninitialized.h>  
109.     //      construct(new_finish, x);                         <stl_construct.h>  
110.     //      ++new_finish;  
111.     //      uninitialized_copy(position, finish, new_finish); <stl_uninitialized.h>  
112.       
113.   
114.     void push_back(const T& x)  
115.     {  
116.         // 内存满足条件则直接追加元素, 否则需要重新分配内存空间  
117.         if (finish != end_of_storage)  
118.         {  
119.             construct(finish, x);  
120.             ++finish;  
121.         }  
122.         else  
123.             insert_aux(end(), x);  
124.     }  
125.   
126.   
127.       
128.     // 在指定位置插入元素  
129.       
130.     //                   insert(iterator position, const T& x)  
131.     //                                   |  
132.     //                                   |------------ 容量是否足够 && 是否是end()?  
133.     //                                   |  
134.     //               -------------------------------------------  
135.     //            No |                                         | Yes  
136.     //               |                                         |  
137.     //               ↓                                         ↓  
138.     //    insert_aux(position, x);                  construct(finish, x);  
139.     //               |                              ++finish;  
140.     //               |-------- 容量是否够用?  
141.     //               |  
142.     //        --------------------------------------------------  
143.     //    Yes |                                                | No  
144.     //        |                                                |  
145.     //        ↓                                                |  
146.     // construct(finish, *(finish - 1));                       |  
147.     // ++finish;                                               |  
148.     // T x_copy = x;                                           |  
149.     // copy_backward(position, finish - 2, finish - 1);        |  
150.     // *position = x_copy;                                     |  
151.     //                                                         ↓  
152.     // data_allocator::allocate(len);                       <stl_alloc.h>  
153.     // uninitialized_copy(start, position, new_start);      <stl_uninitialized.h>  
154.     // construct(new_finish, x);                            <stl_construct.h>  
155.     // ++new_finish;  
156.     // uninitialized_copy(position, finish, new_finish);    <stl_uninitialized.h>  
157.     // destroy(begin(), end());                             <stl_construct.h>  
158.     // deallocate();  
159.       
160.   
161.     iterator insert(iterator position, const T& x)  
162.     {  
163.         size_type n = position - begin();  
164.         if (finish != end_of_storage && position == end())  
165.         {  
166.             construct(finish, x);  
167.             ++finish;  
168.         }  
169.         else  
170.             insert_aux(position, x);  
171.         return begin() + n;  
172.     }  
173.   
174.     iterator insert(iterator position) { return insert(position, T()); }  
175.   
176.     void pop_back()  
177.     {  
178.         --finish;  
179.         destroy(finish);  
180.     }  
181.   
182.     iterator erase(iterator position)  
183.     {  
184.         if (position + 1 != end())  
185.             copy(position + 1, finish, position);  
186.         --finish;  
187.         destroy(finish);  
188.         return position;  
189.     }  
190.   
191.   
192.     iterator erase(iterator first, iterator last)  
193.     {  
194.         iterator i = copy(last, finish, first);  
195.         // 析构掉需要析构的元素  
196.         destroy(i, finish);  
197.         finish = finish - (last - first);  
198.         return first;  
199.     }  
200.   
201.     // 调整size, 但是并不会重新分配内存空间  
202.     void resize(size_type new_size, const T& x)  
203.     {  
204.         if (new_size < size())  
205.             erase(begin() + new_size, end());  
206.         else  
207.             insert(end(), new_size - size(), x);  
208.     }  
209.     void resize(size_type new_size) { resize(new_size, T()); }  
210.   
211.     void clear() { erase(begin(), end()); }  
212.   
213. protected:  
214.     // 分配空间, 并且复制对象到分配的空间处  
215.     iterator allocate_and_fill(size_type n, const T& x)  
216.     {  
217.         iterator result = data_allocator::allocate(n);  
218.         uninitialized_fill_n(result, n, x);  
219.         return result;  
220.     }  
221.   
222.     // 提供插入操作  
223.       
224.     //                 insert_aux(iterator position, const T& x)  
225.     //                                   |  
226.     //                                   |---------------- 容量是否足够?  
227.     //                                   ↓  
228.     //              -----------------------------------------  
229.     //        Yes   |                                       | No  
230.     //              |                                       |  
231.     //              ↓                                       |  
232.     // 从opsition开始, 整体向后移动一个位置                     |  
233.     // construct(finish, *(finish - 1));                    |  
234.     // ++finish;                                            |  
235.     // T x_copy = x;                                        |  
236.     // copy_backward(position, finish - 2, finish - 1);     |  
237.     // *position = x_copy;                                  |  
238.     //                                                      ↓  
239.     //                            data_allocator::allocate(len);  
240.     //                            uninitialized_copy(start, position, new_start);  
241.     //                            construct(new_finish, x);  
242.     //                            ++new_finish;  
243.     //                            uninitialized_copy(position, finish, new_finish);  
244.     //                            destroy(begin(), end());  
245.     //                            deallocate();  
246.       
247.   
248.     template <class T, class Alloc>  
249.     void insert_aux(iterator position, const T& x)  
250.     {  
251.         if (finish != end_of_storage)    // 还有备用空间  
252.         {  
253.             // 在备用空间起始处构造一个元素，并以vector最后一个元素值为其初值  
254.             construct(finish, *(finish - 1));  
255.             ++finish;  
256.             T x_copy = x;  
257.             copy_backward(position, finish - 2, finish - 1);  
258.             *position = x_copy;  
259.         }  
260.         else   // 已无备用空间  
261.         {  
262.             const size_type old_size = size();  
263.             const size_type len = old_size != 0 ? 2 * old_size : 1;  
264.             // 以上配置元素：如果大小为0，则配置1（个元素大小）  
265.             // 如果大小不为0，则配置原来大小的两倍  
266.             // 前半段用来放置原数据，后半段准备用来放置新数据  
267.   
268.             iterator new_start = data_allocator::allocate(len);  // 实际配置  
269.             iterator new_finish = new_start;  
270.             // 将内存重新配置  
271.             try  
272.             {  
273.                 // 将原vector的安插点以前的内容拷贝到新vector  
274.                 new_finish = uninitialized_copy(start, position, new_start);  
275.                 // 为新元素设定初值 x  
276.                 construct(new_finish, x);  
277.                 // 调整水位  
278.                 ++new_finish;  
279.                 // 将安插点以后的原内容也拷贝过来  
280.                 new_finish = uninitialized_copy(position, finish, new_finish);  
281.             }  
282.             catch(...)  
283.             {  
284.                 // 回滚操作  
285.                 destroy(new_start, new_finish);  
286.                 data_allocator::deallocate(new_start, len);  
287.                 throw;  
288.             }  
289.             // 析构并释放原vector  
290.             destroy(begin(), end());  
291.             deallocate();  
292.   
293.             // 调整迭代器，指向新vector  
294.             start = new_start;  
295.             finish = new_finish;  
296.             end_of_storage = new_start + len;  
297.         }  
298.     }  
299.   
300.       
301.     // 在指定位置插入n个元素  
302.       
303.     //             insert(iterator position, size_type n, const T& x)  
304.     //                                   |  
305.     //                                   |---------------- 插入元素个数是否为0?  
306.     //                                   ↓  
307.     //              -----------------------------------------  
308.     //        No    |                                       | Yes  
309.     //              |                                       |  
310.     //              |                                       ↓  
311.     //              |                                    return;  
312.     //              |----------- 内存是否足够?  
313.     //              |  
314.     //      -------------------------------------------------  
315.     //  Yes |                                               | No  
316.     //      |                                               |  
317.     //      |------ (finish - position) > n?                |  
318.     //      |       分别调整指针                              |  
319.     //      ↓                                               |  
320.     //    ----------------------------                      |  
321.     // No |                          | Yes                  |  
322.     //    |                          |                      |  
323.     //    ↓                          ↓                      |  
324.     // 插入操作, 调整指针           插入操作, 调整指针           |  
325.     //                                                      ↓  
326.     //            data_allocator::allocate(len);  
327.     //            new_finish = uninitialized_copy(start, position, new_start);  
328.     //            new_finish = uninitialized_fill_n(new_finish, n, x);  
329.     //            new_finish = uninitialized_copy(position, finish, new_finish);  
330.     //            destroy(start, finish);  
331.     //            deallocate();  
332.       
333.   
334.     template <class T, class Alloc>  
335.     void insert(iterator position, size_type n, const T& x)  
336.     {  
337.         // 如果n为0则不进行任何操作  
338.         if (n != 0)  
339.         {  
340.             if (size_type(end_of_storage - finish) >= n)  
341.             {      // 剩下的备用空间大于等于“新增元素的个数”  
342.                 T x_copy = x;  
343.                 // 以下计算插入点之后的现有元素个数  
344.                 const size_type elems_after = finish - position;  
345.                 iterator old_finish = finish;  
346.                 if (elems_after > n)  
347.                 {  
348.                     // 插入点之后的现有元素个数 大于 新增元素个数  
349.                     uninitialized_copy(finish - n, finish, finish);  
350.                     finish += n;    // 将vector 尾端标记后移  
351.                     copy_backward(position, old_finish - n, old_finish);  
352.                     fill(position, position + n, x_copy); // 从插入点开始填入新值  
353.                 }  
354.                 else  
355.                 {  
356.                     // 插入点之后的现有元素个数 小于等于 新增元素个数  
357.                     uninitialized_fill_n(finish, n - elems_after, x_copy);  
358.                     finish += n - elems_after;  
359.                     uninitialized_copy(position, old_finish, finish);  
360.                     finish += elems_after;  
361.                     fill(position, old_finish, x_copy);  
362.                 }  
363.             }  
364.             else  
365.             {   // 剩下的备用空间小于“新增元素个数”（那就必须配置额外的内存）  
366.                 // 首先决定新长度：就长度的两倍 ， 或旧长度+新增元素个数  
367.                 const size_type old_size = size();  
368.                 const size_type len = old_size + max(old_size, n);  
369.                 // 以下配置新的vector空间  
370.                 iterator new_start = data_allocator::allocate(len);  
371.                 iterator new_finish = new_start;  
372.                 __STL_TRY  
373.                 {  
374.                     // 以下首先将旧的vector的插入点之前的元素复制到新空间  
375.                     new_finish = uninitialized_copy(start, position, new_start);  
376.                     // 以下再将新增元素（初值皆为n）填入新空间  
377.                     new_finish = uninitialized_fill_n(new_finish, n, x);  
378.                     // 以下再将旧vector的插入点之后的元素复制到新空间  
379.                     new_finish = uninitialized_copy(position, finish, new_finish);  
380.                 }  
381. #         ifdef  __STL_USE_EXCEPTIONS  
382.                 catch(...)  
383.                 {  
384.                     destroy(new_start, new_finish);  
385.                     data_allocator::deallocate(new_start, len);  
386.                     throw;  
387.                 }  
388. #         endif /* __STL_USE_EXCEPTIONS */  
389.                 destroy(start, finish);  
390.                 deallocate();  
391.                 start = new_start;  
392.                 finish = new_finish;  
393.                 end_of_storage = new_start + len;  
394.             }  
395.         }  
396.     }  
397. };  

STL源码剖析---list

相较于vector的连续线性空间，list就显得复杂许多，它的好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素移除，list永远是常数时间。
      list不仅是一个双向链表，而且还是一个环状双向链表。另外，还有一个重要性质，插入操作和接合操作都不会造成原有的list迭代器失效，这在vector是不成立的。因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效。甚至list的元素删除操作（erase），也只有“指向被删除元素”的那个迭代器失效，其他迭代器不受任何影响。
以下是list的节点、迭代器数据结构设计以及list的源码剖析：

[cpp]  view plain  copy

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

STL源码剖析---deque

一、deque的中控器
      deque是连续空间（至少逻辑上看来如此），连续线性空间总令我们联想到array或vector。array无法成长，vector虽可成长，却只能向尾端成长，而且其所谓的成长原是个假象，事实上是（1）另觅更大空间；（2）将原数据复制过去；（3）释放原空间三部曲。如果不是vector每次配置新空间时都有留下一些余裕，其成长假象所带来的代价将是相当高昂。
      deque系由一段一段的定量连续空间构成。一旦有必要在deque的前端或尾端增加新空间，便配置一段定量连续空间，串接在整个deque的头端或尾端。deque的最大任务，便是在这些分段的定量连续空间上，维护其整体连续的假象，并提供随机存取的借口。避开了“重新配置、复制、释放”的轮回，代价则是复杂的迭代器架构。
      受到分段连续线性空间的字面影响，我们可能以为deque的实现复杂度和vector相比虽不中亦不远矣，其实不然。主要因为，既是分段连续线性空间，就必须有中央控制，而为了维持整体连续的假象，数据结构的设计及迭代器前进后退等操作都颇为繁琐。deque的实现代码分量远比vector或list都多得多。
      deque采用一块所谓的map（注意，不是STL的map容器）作为主控。这里所谓map是一小块连续空间，其中每个元素（此处称为一个节点，node）都是指针，指向另一段（较大的）连续线性空间，称为缓冲区。缓冲区才是deque的储存空间主体。SGI STL 允许我们指定缓冲区大小，默认值0表示将使用512 bytes 缓冲区。
二、deque的迭代器
      让我们思考一下，deque的迭代器应该具备什么结构，首先，它必须能够指出分段连续空间（亦即缓冲区）在哪里，其次它必须能够判断自己是否已经处于其所在缓冲区的边缘，如果是，一旦前进或后退就必须跳跃至下一个或上一个缓冲区。为了能够正确跳跃，deque必须随时掌握管控中心（map）。所以在迭代器中需要定义：当前元素的指针，当前元素所在缓冲区的起始指针，当前元素所在缓冲区的尾指针，指向map中指向所在缓区地址的指针。
在进行迭代器的移动时，需要考虑跨缓冲区的情况。
重载前加(减)，在实现后加(减)时，调用重载的前加(减)。
重载+=,实现+时，直接调用+=,实现-=时，调用+=负数，实现-时，调用-=.
//当需要实现新的功能时，最好使用已经重载好的操作，即方便有安全。。。。
另外，deque在效率上来说是不够vector好的，因此有时候在对deque进行sort的时候，需要先将元素移到vector再进行sort，然后移回来。

构造函数：根据缓冲区设置大小和元素个数，决定map的大小；给map分配空间，根据缓冲区的个数，分配缓冲区，默认指定一个缓冲区；
 设置start和finish迭代器，满足左闭右开的原则。
 push_back:如果空间满足，直接插入；不满足，调用push_back_aux。
 push_back_aux:先调用reverse_map_at_back,若符合某种条件，重换一个map；分配空间。
 reserve_map_at_back:看看map有没有满，满的话，调用reallocate_map。
 reallocate_map:如果前端或后端pop过多，就会导致大量的空闲空间，如果是这种情况，则不用新分配空间，调整一下start的位置即可；
 如果不够，则需要重新申请空间。
 pop：析构元素，如果是最后一块还需要删除空间。
 erase：需要判断，前面的元素少还是后面的元素少，移动较少的部分。
 insert：判断位置，如果为前端或后端直接调用push操作，否则，移动较少的一端。
deque的构造与内存管理：
由于deque的设计思想就是由一块块的缓存区连接起来的，因此它的内存管理会比较复杂。插入的时候要考虑是否要跳转缓存区、是否要新建map节点（和vector一样，其实是重新分配一块空间给map，删除原来空间）、插入后元素是前面元素向前移动还是后面元素向后面移动（谁小移动谁）。而在删除元素的时候，考虑是将前面元素后移覆盖需要移除元素的地方还是后面元素前移覆盖（谁小移动谁）。移动完以后要析构冗余的元素，释放冗余的缓存区。 
三、deque的源码剖析

[cpp]  view plain  copy

1. //   deque的特性:  
2. //   对于任何一个迭代器i  
3. //     i.node是map array中的某元素的地址. i.node的内容是一个指向某个结点的头的指针  
4. //     i.first == *(i.node)  
5. //     i.last  == i.first + node_size  
6. //     i.cur是一个指向[i.first, i.last)之间的指针  
7. //       注意: 这意味着i.cur永远是一个可以解引用的指针,  
8. //            即使其是一个指向结尾后元素的迭代器  
9. //  
10. //   起点和终点总是非奇异(nonsingular)的迭代器.  
11. //     注意: 这意味着空deque一定有一个node, 而一个具有N个元素的deque  
12. //          (N是Buffer Size)一定有有两个nodes  
13. //  
14. //   对于除了start.node和finish.node之外的每一个node, 每一个node中的元素  
15. //   都是一个初始化过的对象. 如果start.node == finish.node,  
16. //   那么[start.cur, finish.cur)都是未初始化的空间.  
17. //   否则, [start.cur, start.last)和[finish.first, finish.cur)都是初始化的对象,  
18. //   而[start.first, start.cur)和[finish.cur, finish.last)是未初始化的空间  
19. //  
20. //   [map, map + map_size)是一个合法的非空区间  
21. //   [start.node, finish.node]是内含在[map, map + map_size)区间的合法区间  
22. //   一个在[map, map + map_size)区间内的指针指向一个分配过的node,  
23. //   当且仅当此指针在[start.node, finish.node]区间内  
24.   
25. inline size_t __deque_buf_size(size_t n, size_t sz)    
26. {    
27.   return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));    
28. }  
29.   
30. // __deque_iterator的数据结构  
31. template <class T, class Ref, class Ptr, size_t BufSiz>  
32. struct __deque_iterator  
33. {  
34.     typedef __deque_iterator<T, T&, T*>             iterator;  
35.     typedef __deque_iterator<T, const T&, const T*> const_iterator;  
36.     static size_t buffer_size() {return __deque_buf_size(0, sizeof(T)); }  
37.   
38.     typedef random_access_iterator_tag iterator_category;  
39.     typedef T value_type;  
40.     typedef Ptr pointer;  
41.     typedef Ref reference;  
42.     typedef size_t size_type;  
43.     typedef ptrdiff_t difference_type;  
44.     typedef T** map_pointer;  
45.   
46.     typedef __deque_iterator self;  
47.   
48.     // 保持与容器的联结  
49.     T* cur;       // 此迭代器所指之缓冲区中的现行元素  
50.     T* first;     // 此迭代器所指之缓冲区的头  
51.     T* last;      // 此迭代器所指之缓冲区的尾（含备用空间）  
52.     map_pointer node;    // 指向管控中心  
53.   
54.   
55. // 这个是deque内存管理的关键, 其模型如下  
56.   
57. //  
58. //       ---------------------------------------------  
59. // map-->|   |   |   |   |   |   | ..... |   |   |   |<------------------  
60. //       ---------------------------------------------                  |  
61. //             |                                                        |  
62. //             |                                                        |  
63. //             |   node                                                 |  
64. //             |   缓冲区buffer, 这里实际存储元素                          |  
65. //             |   ---------------------------------------------        |  
66. //             --->|   |   |   |   |   |   | ..... |   |   | X |        |  
67. //                 ---------------------------------------------        |  
68. //                   ↑       ↑                             ↑            |  
69. //             ------        |                             |            |  
70. //             |             |                             |            |  
71. //             |   -----------   ---------------------------            |  
72. //             ----|-----        |                                      |  
73. //                 |    |        |                                      |  
74. //                 |    |        |                                      |  
75. //                 |    |        |                                      |  
76. //              ---------------------------                             |  
77. //              | cur | first | end | map |------------------------------  
78. //              ---------------------------  
79. //              迭代器, 其内部维护着一个缓冲区状态  
80.   
81.     __deque_iterator(T* x, map_pointer y)  
82.         : cur(x), first(*y), last(*y + buffer_size()), node(y) {}  
83.     __deque_iterator() : cur(0), first(0), last(0), node(0) {}  
84.     __deque_iterator(const iterator& x)  
85.         : cur(x.cur), first(x.first), last(x.last), node(x.node) {}  
86.   
87.     reference operator*() const { return *cur; }  
88.   
89.     // 判断两个迭代器间的距离  
90.     difference_type operator-(const self& x) const  
91.     {  
92.         return difference_type(buffer_size()) * (node - x.node - 1) +  
93.             (cur - first) + (x.last - x.cur);  
94.     }  
95.   
96.   
97. // 下面重载的这些运算符是让deque从外界看上去维护的是一段连续空间的关键!!!  
98.   
99. // 前缀自增  
100.   
101. // 如果当前迭代器指向元素是当前缓冲区的最后一个元素,  
102. // 则将迭代器状态调整为下一个缓冲区的第一个元素  
103.   
104. // 不是当前缓冲区最后一个元素  
105. //  
106. // 执行前缀自增前的状态  
107. // first          cur                     end  
108. // ↓               ↓                       ↓  
109. // ---------------------------------------------  
110. // |   |   |   |   |   |   | ..... |   |   | X | <----- 当前缓冲区  
111. // ---------------------------------------------  
112. //  
113. // 执行完成后的状态  
114. // first              cur                 end  
115. // ↓                   ↓                   ↓  
116. // ---------------------------------------------  
117. // |   |   |   |   |   |   | ..... |   |   | X | <----- 当前缓冲区  
118. // ---------------------------------------------  
119. //  
120.   
121. // 当前元素为当前缓冲区的最后一个元素  
122. //  
123. // 执行前缀自增前的状态  
124. // first                              cur end  
125. // ↓                                   ↓   ↓  
126. // ---------------------------------------------  
127. // |   |   |   |   |   |   | ..... |   |   | X | <----- 当前缓冲区  
128. // ---------------------------------------------  
129. //  
130. // 执行完成后的状态  
131. // first                                  end  
132. // ↓                                       ↓  
133. // ---------------------------------------------  
134. // |   |   |   |   |   |   | ..... |   |   | X | <----- 下一缓冲区  
135. // ---------------------------------------------  
136. // ↑  
137. // cur  
138. //  
139.   
140.     self& operator++()  
141.     {  
142.         ++cur;    // 切换至下一个元素  
143.         if (cur == last)    // 如果已达到缓冲区的尾端  
144.         {  
145.             set_node(node + 1);    // 就切换至下一节点（亦即缓冲区）  
146.             cur = first;           // 的第一个元素  
147.         }  
148.         return *this;  
149.     }  
150.   
151.     // 后缀自增  
152.     // 返回当前迭代器的一个副本, 并调用前缀自增运算符实现迭代器自身的自增  
153.     self operator++(int)  
154.     {  
155.         self tmp = *this;  
156.         ++*this;  
157.         return tmp;  
158.     }  
159.   
160.     // 前缀自减, 处理方式类似于前缀自增  
161.     // 如果当前迭代器指向元素是当前缓冲区的第一个元素  
162.     // 则将迭代器状态调整为前一个缓冲区的最后一个元素  
163.     self& operator--()  
164.     {  
165.         if (cur == first)    // 如果已达到缓冲区的头端  
166.         {  
167.             set_node(node - 1);    // 就切换至前一节点（亦即缓冲区）  
168.             cur = last;            // 的最后一个元素  
169.         }  
170.         --cur;  
171.         return *this;  
172.     }  
173.   
174.     self operator--(int)  
175.     {  
176.         self tmp = *this;  
177.         --*this;  
178.         return tmp;  
179.     }  
180.   
181.   
182. // 将迭代器向前移动n个元素, n可以为负  
183.   
184. //                     operator+=(difference_type n)  
185. //                                   ↓  
186. //                      offset = n + (cur - first)  
187. //                                   |  
188. //                                   |---------- offset > 0 ? &&  
189. //                                   |           移动后是否超出当前缓冲区?  
190. //               ----------------------------  
191. //           No  |                          |  Yes  
192. //               |                          |  
193. //               ↓                          |---------- offset > 0?  
194. //           cur += n;                      |  
195. //                              ----------------------------  
196. //                          Yes |                          | No  
197. //                              |                          |  
198. //                              ↓                          |  
199. //                   计算要向后移动多少个缓冲区                |  
200. //                   node_offset =                         |  
201. //                   offset / difference_type              |  
202. //                   (buffer_size());                      ↓  
203. //                              |           计算要向前移动多少个缓冲区  
204. //                              |           node_offset = -difference_type  
205. //                              |           ((-offset - 1) / buffer_size()) - 1;  
206. //                              |                          |  
207. //                              ----------------------------  
208. //                                           |  
209. //                                           |  
210. //                                           ↓  
211. //                                       调整缓冲区  
212. //                              set_node(node + node_offset);  
213. //                                    计算并调整cur指针  
214.   
215.     // 以下实现随机存取。迭代器可以直接跳跃n个距离  
216.     self& operator+=(difference_type n)  
217.     {  
218.         difference_type offset = n + (cur - first);  
219.         if (offset >= 0 && offset < difference_type(buffer_size()))  
220.             cur += n;        // 目标位置在同一缓冲区内  
221.         else  
222.         {           // 目标位置不在同一缓冲区内  
223.             difference_type node_offset =  
224.                 offset > 0 ? offset / difference_type(buffer_size())  
225.                 : -difference_type((-offset - 1) / buffer_size()) - 1;  
226.             // 切换至正确的节点（亦即缓冲区）  
227.             set_node(node + node_offset);  
228.             // 切换至正确的元素  
229.             cur = first + (offset - node_offset * difference_type(buffer_size()));  
230.         }  
231.         return *this;  
232.     }  
233.   
234.     self operator+(difference_type n) const  
235.     {  
236.         self tmp = *this;  
237.   
238.         // 这里调用了operator +=()可以自动调整指针状态  
239.         return tmp += n;  
240.     }  
241.   
242.     // 将n变为-n就可以使用operator +=()了,  
243.     self& operator-=(difference_type n) { return *this += -n; }  
244.   
245.     self operator-(difference_type n) const  
246.     {  
247.         self tmp = *this;  
248.         return tmp -= n;  
249.     }  
250.   
251.     reference operator[](difference_type n) const { return *(*this + n); }  
252.   
253.     bool operator==(const self& x) const { return cur == x.cur; }  
254.     bool operator!=(const self& x) const { return !(*this == x); }  
255.     bool operator<(const self& x) const  
256.     {  
257.         return (node == x.node) ? (cur < x.cur) : (node < x.node);  
258.     }  
259.   
260.     void set_node(map_pointer new_node)  
261.     {  
262.         node = new_node;  
263.         first = *new_node;  
264.         last = first + difference_type(buffer_size());  
265.     }  
266. };  
267.   
268.   
269. // deque的数据结构  
270. template <class T, class Alloc = alloc, size_t BufSiz = 0>  
271. class deque  
272. {  
273. public:                         // Basic types  
274.     typedef T value_type;  
275.     typedef value_type* pointer;  
276.     typedef value_type& reference;  
277.     typedef size_t size_type;  
278.     typedef ptrdiff_t difference_type;  
279.   
280. public:                         // Iterators  
281.     typedef __deque_iterator<T, T&, T*, BufSiz>       iterator;  
282.   
283. protected:                      // Internal typedefs  
284.   
285.     typedef pointer* map_pointer;  
286.   
287.     // 这个提供STL标准的allocator接口, 见<stl_alloc.h>  
288.     typedef simple_alloc<value_type, Alloc> data_allocator;  
289.     typedef simple_alloc<pointer, Alloc> map_allocator;  
290.   
291.     // 获取缓冲区最大存储元素数量  
292.     static size_type buffer_size()  
293.     {  
294.         return __deque_buf_size(BufSiz, sizeof(value_type));  
295.     }  
296.   
297.     static size_type initial_map_size() { return 8; }  
298.   
299. protected:                      // Data members  
300.     iterator start;               // 起始缓冲区  
301.     iterator finish;              // 最后一个缓冲区  
302.   
303.     // 指向map, map是一个连续的空间, 其每个元素都是一个指针，指向一个节点（缓冲区）  
304.     map_pointer map;  
305.     size_type map_size;   // map容量  
306.   
307. public:  
308.     iterator begin() { return start; }  
309.     iterator end() { return finish; }  
310.   
311.     // 提供随机访问能力, 其调用的是迭代器重载的operator []  
312.     // 其实际地址需要进行一些列的计算, 效率有损失  
313.     reference operator[](size_type n) { return start[difference_type(n)]; }  
314.   
315.     reference front() { return *start; }  
316.     reference back()  
317.     {  
318.         iterator tmp = finish;  
319.         --tmp;  
320.         return *tmp;  
321.     }  
322.   
323.     // 当前容器拥有的元素个数, 调用迭代器重载的operator -  
324.     size_type size() const { return finish - start;; }  
325.     size_type max_size() const { return size_type(-1); }  
326.   
327.     // deque为空的时, 只有一个缓冲区  
328.     bool empty() const { return finish == start; }  
329.   
330. public:                         // Constructor, destructor.  
331.     deque() : start(), finish(), map(0), map_size(0)  
332.     {  
333.         create_map_and_nodes(0);  
334.     }  
335.   
336.     deque(size_type n, const value_type& value)  
337.         : start(), finish(), map(0), map_size(0)  
338.     {  
339.         fill_initialize(n, value);  
340.     }  
341.   
342.     deque(int n, const value_type& value)  
343.         : start(), finish(), map(0), map_size(0)  
344.     {  
345.         fill_initialize(n, value);  
346.     }  
347.   
348.   
349.     ~deque()  
350.     {  
351.         destroy(start, finish);     // <stl_construct.h>  
352.         destroy_map_and_nodes();  
353.     }  
354.   
355.     deque& operator= (const deque& x)  
356.     {  
357.         // 其实我觉得把这个操作放在if内效率更高  
358.         const size_type len = size();  
359.         if (&x != this)  
360.         {  
361.             // 当前容器比x容器拥有元素多, 析构多余元素  
362.             if (len >= x.size())  
363.                 erase(copy(x.begin(), x.end(), start), finish);  
364.             // 将x所有超出部分的元素使用insert()追加进去  
365.             else {  
366.                 const_iterator mid = x.begin() + difference_type(len);  
367.                 copy(x.begin(), mid, start);  
368.                 insert(finish, mid, x.end());  
369.             }  
370.         }  
371.         return *this;  
372.     }  
373.   
374. public:  
375.     void push_back(const value_type& t)  
376.     {  
377.         // 最后缓冲区尚有两个（含）以上的元素备用空间  
378.         if (finish.cur != finish.last - 1)  
379.         {  
380.             construct(finish.cur, t);     // 直接在备用空间上构造元素  
381.             ++finish.cur;     // 调整最后缓冲区的使用状态  
382.         }  
383.         // 容量已满就要新申请内存了  
384.         else  
385.             push_back_aux(t);  
386.     }  
387.   
388.     void push_front(const value_type& t)  
389.     {  
390.         if (start.cur != start.first)      // 第一缓冲区尚有备用空间  
391.         {  
392.             construct(start.cur - 1, t);   // 直接在备用空间上构造元素  
393.             --start.cur;     // 调整第一缓冲区的使用状态  
394.         }  
395.         else    // 第一缓冲区已无备用空间  
396.             push_front_aux(t);  
397.     }  
398.   
399.     void pop_back()  
400.     {  
401.         if (finish.cur != finish.first)    // 最后缓冲区有一个（或更多）元素  
402.         {  
403.             --finish.cur;    // 调整指针，相当于排除了最后元素  
404.             destroy(finish.cur);    // 将最后元素析构  
405.         }  
406.         else  
407.             // 最后缓冲区没有任何元素  
408.             pop_back_aux();    // 这里将进行缓冲区的释放工作  
409.     }  
410.   
411.     void pop_front()  
412.     {  
413.         if (start.cur != start.last - 1)    // 第一缓冲区有两个（或更多）元素  
414.         {  
415.             destroy(start.cur);    // 将第一元素析构  
416.             ++start.cur;           //调整指针，相当于排除了第一元素  
417.         }  
418.         else  
419.             // 第一缓冲区仅有一个元素  
420.             pop_front_aux();    // 这里将进行缓冲区的释放工作  
421.     }  
422.   
423. public:                         // Insert  
424.   
425.   
426. // 在指定位置前插入元素  
427.   
428. //             insert(iterator position, const value_type& x)  
429. //                                   |  
430. //                                   |---------------- 判断插入位置  
431. //                                   |  
432. //               -----------------------------------------------  
433. // deque.begin() |          deque.emd() |                      |  
434. //               |                      |                      |  
435. //               ↓                      ↓                      |  
436. //         push_front(x);         push_back(x);                |  
437. //                                                             ↓  
438. //                                                 insert_aux(position, x);  
439. //                                                 具体剖析见后面实现  
440.   
441.   
442.     iterator insert(iterator position, const value_type& x)  
443.     {  
444.         // 如果是在deque的最前端插入, 那么直接push_front()即可  
445.         if (position.cur == start.cur)  
446.         {  
447.             push_front(x);  
448.             return start;  
449.         }  
450.         // 如果是在deque的末尾插入, 直接调用push_back()  
451.         else if (position.cur == finish.cur)  
452.         {  
453.             push_back(x);  
454.             iterator tmp = finish;  
455.             --tmp;  
456.             return tmp;  
457.         }  
458.         else  
459.         {  
460.             return insert_aux(position, x);  
461.         }  
462.     }  
463.   
464.     iterator insert(iterator position) { return insert(position, value_type()); }  
465.   
466.     // 详解见实现部分  
467.     void insert(iterator pos, size_type n, const value_type& x);  
468.   
469.     void insert(iterator pos, int n, const value_type& x)  
470.     {  
471.         insert(pos, (size_type) n, x);  
472.     }  
473.     void insert(iterator pos, long n, const value_type& x)  
474.     {  
475.         insert(pos, (size_type) n, x);  
476.     }  
477.   
478.     void resize(size_type new_size) { resize(new_size, value_type()); }  
479.   
480. public:                         // Erase  
481.   
482.     iterator erase(iterator pos)  
483.     {  
484.         iterator next = pos;  
485.         ++next;  
486.   
487.         // 清除点之前的元素个数  
488.         difference_type index = pos - start;  
489.   
490.         // 如果清除点之前的元素个数比较少, 哪部分少就移动哪部分  
491.         if (index < (size() >> 1))  
492.         {  
493.             // 就移动清除点之前的元素  
494.             copy_backward(start, pos, next);  
495.             pop_front();   // 移动完毕，最前一个元素冗余，去除之  
496.         }  
497.         else   // 如果清除点之后的元素个数比较少  
498.         {  
499.             copy(next, finish, pos);  // 就移动清除点之后的元素  
500.             pop_back();   // 移动完毕，最后一个元素冗余，去除之  
501.         }  
502.         return start + index;  
503.     }  
504.   
505.     iterator erase(iterator first, iterator last);  
506.     void clear();  
507.   
508. protected:  
509.   
510.     // 详解见实现部分  
511.     void push_back_aux(const value_type& t);  
512.     void push_front_aux(const value_type& t);  
513.     void pop_back_aux();  
514.     void pop_front_aux();  
515.   
516.     iterator insert_aux(iterator pos, const value_type& x);  
517.     void insert_aux(iterator pos, size_type n, const value_type& x);  
518.   
519.     // 分配内存, 不进行构造  
520.     pointer allocate_node() { return data_allocator::allocate(buffer_size()); }  
521.   
522.     // 释放内存, 不进行析构  
523.     void deallocate_node(pointer n)  
524.     {  
525.         data_allocator::deallocate(n, buffer_size());  
526.     }  
527.   
528. };  
529.   
530.   
531.   
532. // 清除[first, last)区间的所有元素  
533.   
534. //                  erase(iterator first, iterator last)  
535. //                                   |  
536. //                                   |---------------- 是否要删除整个区间?  
537. //                                   |  
538. //               ------------------------------------------  
539. //           Yes |                                        | No  
540. //               |                                        |  
541. //               ↓                                        | --- 判断哪侧元素少  
542. //            clear();                                    ↓  
543. //       -----------------------------------------------------------------  
544. // 左侧少 |                                                         右侧少 |  
545. //       |                                                               |  
546. //       ↓                                                               ↓  
547. //   copy_backward(start, first, last);            copy(last, finish, first);  
548. //   new_start = start + n;                        new_finish = finish - n;  
549. //   析构多余的元素                                  析构多余的元素  
550. //   destroy(start, new_start);                    destroy(new_finish, finish);  
551. //   释放多余内存空间                                释放多余内存空间  
552. //   for (...)                                     for (...)  
553. //      ...                                             ...  
554. //   更新map状态                                    更新map状态  
555.   
556. template <class T, class Alloc, size_t BufSize>  
557. deque<T, Alloc, BufSize>::iterator  
558. deque<T, Alloc, BufSize>::erase(iterator first, iterator last)  
559. {  
560.     if (first == start && last == finish)   // 如果清除区间是整个deque  
561.     {  
562.         clear();              // 直接调用clear()即可  
563.         return finish;  
564.     }  
565.     else  
566.     {  
567.         difference_type n = last - first;   // 清除区间的长度  
568.         difference_type elems_before = first - start;   // 清除区间前方的元素个数  
569.         if (elems_before < (size() - n) / 2)   // 如果前方的元素个数比较少  
570.         {  
571.             copy_backward(start, first, last);  // 向后移动前方元素（覆盖清除区间）  
572.             iterator new_start = start + n;     // 标记deque的新起点  
573.             destroy(start, new_start);          // 移动完毕，将冗余的元素析构  
574.             // 以下将冗余的缓冲区释放  
575.             for (map_pointer cur = start.node; cur < new_start.node; ++cur)  
576.                 data_allocator::deallocate(*cur, buffer_size());  
577.             start = new_start;   // 设定deque的新起点  
578.         }  
579.         else    // 如果清除区间后方的元素个数比较少  
580.         {  
581.             copy(last, finish, first);  // 向前移动后方元素（覆盖清除区间）  
582.             iterator new_finish = finish - n;     // 标记deque的新尾点  
583.             destroy(new_finish, finish);          // 移动完毕，将冗余的元素析构  
584.             // 以下将冗余的缓冲区释放  
585.             for (map_pointer cur = new_finish.node + 1; cur <= finish.node; ++cur)  
586.                 data_allocator::deallocate(*cur, buffer_size());  
587.             finish = new_finish;   // 设定deque的新尾点  
588.         }  
589.         return start + elems_before;  
590.     }  
591. }  
592.   
593. template <class T, class Alloc, size_t BufSize>  
594. void deque<T, Alloc, BufSize>::clear()  
595. {  
596.     // 以下针对头尾以外的每一个缓冲区  
597.     for (map_pointer node = start.node + 1; node < finish.node; ++node)  
598.     {  
599.         // 将缓冲区内的所有元素析构  
600.         destroy(*node, *node + buffer_size());  
601.         // 释放缓冲区内存  
602.         data_allocator::deallocate(*node, buffer_size());  
603.     }  
604.   
605.     if (start.node != finish.node)   // 至少有头尾两个缓冲区  
606.     {  
607.         destroy(start.cur, start.last);  // 将头缓冲区的目前所有元素析构  
608.         destroy(finish.first, finish.cur);  // 将尾缓冲区的目前所有元素析构  
609.         // 以下释放尾缓冲区。注意：头缓冲区保留  
610.         data_allocator::deallocate(finish.first, buffer_size());  
611.     }  
612.     else   // 只有一个缓冲区  
613.         destroy(start.cur, finish.cur);   // 将此唯一缓冲区内的所有元素析构  
614.         // 注意：并不释放缓冲区空间，这唯一的缓冲区将保留  
615.   
616.     finish = start;   // 调整状态  
617. }  
618.   
619.   
620. // 只有当finish.cur == finish.last - 1 时才会被调用  
621. // 也就是说，只有当最后一个缓冲区只剩下一个备用元素空间时才会被调用  
622. template <class T, class Alloc, size_t BufSize>  
623. void deque<T, Alloc, BufSize>::push_back_aux(const value_type& t)  
624. {  
625.     value_type t_copy = t;  
626.     reserve_map_at_back();  
627.     *(finish.node + 1) = allocate_node();    // 配置一个新节点（缓冲区）  
628.     __STL_TRY  
629.     {  
630.         construct(finish.cur, t_copy);         // 针对标的元素设值  
631.         finish.set_node(finish.node + 1);      // 改变finish，令其指向新节点  
632.         finish.cur = finish.first;             // 设定finish的状态  
633.     }  
634.     __STL_UNWIND(deallocate_node(*(finish.node + 1)));  
635. }  
636.   
637. // Called only if start.cur == start.first.  
638. template <class T, class Alloc, size_t BufSize>  
639. void deque<T, Alloc, BufSize>::push_front_aux(const value_type& t)  
640. {  
641.     value_type t_copy = t;  
642.     reserve_map_at_front();  
643.     *(start.node - 1) = allocate_node();  
644.     __STL_TRY  
645.     {  
646.         start.set_node(start.node - 1);        // 改变start，令其指向新节点  
647.         start.cur = start.last - 1;            // 设定start的状态  
648.         construct(start.cur, t_copy);          // 针对标的元素设值  
649.     }  
650.     catch(...)  
651.     {  
652.         start.set_node(start.node + 1);  
653.         start.cur = start.first;  
654.         deallocate_node(*(start.node - 1));  
655.         throw;  
656.     }  
657. }  
658.   
659. // 只有当 finish.cur == finish.first 时才会被调用  
660. template <class T, class Alloc, size_t BufSize>  
661. void deque<T, Alloc, BufSize>:: pop_back_aux()  
662. {  
663.     deallocate_node(finish.first);      // 释放最后一个缓冲区  
664.     finish.set_node(finish.node - 1);   // 调整finish状态，使指向  
665.     finish.cur = finish.last - 1;       // 上一个缓冲区的最后一个元素  
666.     destroy(finish.cur);                // 将该元素析构  
667. }  
668.   
669. // 只有当 start.cur == start.last - 1 时才会被调用  
670. template <class T, class Alloc, size_t BufSize>  
671. void deque<T, Alloc, BufSize>::pop_front_aux()  
672. {  
673.     destroy(start.cur);    // 将第一个缓冲区的第一个（也是最后一个、唯一一个）元素析构  
674.     deallocate_node(start.first);    // 释放第一缓冲区  
675.     start.set_node(start.node + 1);  // 调整start状态，使指向  
676.     start.cur = start.first;         // 下一个缓冲区的第一个元素  
677. }  
678.   
679.   
680.   
681. // 在指定位置前插入元素  
682.   
683. //              insert_aux(iterator pos, const value_type& x)  
684. //                                   |  
685. //                                   |----------- 判断pos前端元素少还是后端元素少  
686. //                                   |  
687. //               -----------------------------------------------  
688. //         前端少 |                                       后端少 |  
689. //               |                                             |  
690. //               ↓                                             |  
691. //           进行相关操作                                   进行相关操作  
692.   
693. // 下面以pos前面元素少的情形进行说明, 为了简化, 假设操作不会超过一个缓冲区区间  
694. //  
695. // 插入前状态  
696. //           start            pos                                 end  
697. //             ↓               ↓                                   ↓  
698. // ---------------------------------------------------------------------  
699. // |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | X |  
700. // ---------------------------------------------------------------------  
701. //  
702. // 需要进行操作的区间  
703. //                需要拷贝的区间  
704. //                 -------------  
705. //       start     |           |                                  end  
706. //         ↓       ↓           ↓                                   ↓  
707. // ---------------------------------------------------------------------  
708. // |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | X |  
709. // ---------------------------------------------------------------------  
710. //             ↑   ↑       ↑   ↑  
711. //        front1   |       |   |  
712. //                 |       |   |  
713. //            front2       |   |  
714. //                         |   |  
715. //                       pos   |  
716. //                             |  
717. //                          pos1  
718. // 拷贝操作完成后  
719. //  
720. //         这是[front2, pos1)  
721. //             ------------- --------- 这里是给待插入元素预留的空间  
722. //       start |           | |                                    end  
723. //         ↓   ↓           ↓ ↓                                     ↓  
724. // ---------------------------------------------------------------------  
725. // |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | X |  
726. // ---------------------------------------------------------------------  
727. //         ↑  
728. //   这里存储的是原来的front()  
729. //  
730.   
731.   
732. template <class T, class Alloc, size_t BufSize>  
733. typename deque<T, Alloc, BufSize>::iterator  
734. deque<T, Alloc, BufSize>::insert_aux(iterator pos, const value_type& x)  
735. {  
736.     difference_type index = pos - start;   // 插入点之前的元素个数  
737.     value_type x_copy = x;  
738.   
739.     // 前面的时候用的移位操作, 这里怎么不用了呢^_^?  
740.     if (index < size() / 2)    // 如果插入点之前的元素个数比较少  
741.     {  
742.         push_front(front());       // 在最前端加入与第一元素同值的元素  
743.         iterator front1 = start;   // 以下标示记号，然后进行元素移动  
744.         ++front1;  
745.         iterator front2 = front1;  
746.         ++front2;  
747.         pos = start + index;  
748.         iterator pos1 = pos;  
749.         ++pos1;  
750.         copy(front2, pos1, front1);    // 元素移动  
751.     }  
752.     else    // 插入点之后的元素个数比较少  
753.     {  
754.         push_back(back());         // 在最尾端加入与最后元素同值的元素  
755.         iterator back1 = finish;   // 以下标示记号，然后进行元素移动  
756.         --back1;  
757.         iterator back2 = back1;  
758.         --back2;  
759.         pos = start + index;  
760.         copy_backward(pos, back2, back1);    // 元素移动  
761.     }  
762.     *pos = x_copy;    // 在插入点上设定新值  
763.     return pos;  
764. }  

STL源码剖析---迭代器失效小结

迭代器（iterator）是一个可以对其执行类似指针的操作（如：解除引用（operator*()）和递增（operator++()））的对象，我们可以将它理解成为一个指针。但它又不是我们所谓普通的指针，我们可以称之为广义指针，你可以通过sizeof（vector::iterator）来查看，所占内存并不是4个字节。
     首先对于vector而言，添加和删除操作可能使容器的部分或者全部迭代器失效。那为什么迭代器会失效呢？vector元素在内存中是顺序存储，试想：如果当前容器中已经存在了10个元素，现在又要添加一个元素到容器中，但是内存中紧跟在这10个元素后面没有一个空闲空间，而vector的元素必须顺序存储一边索引访问，所以我们不能在内存中随便找个地方存储这个元素。于是vector必须重新分配存储空间，用来存放原来的元素以及新添加的元素：存放在旧存储空间的元素被复制到新的存储空间里，接着插入新的元素，最后撤销旧的存储空间。这种情况发生，一定会导致vector容器的所有迭代器都失效。
     我们看到实现上述所说的分配和撤销内存空间的方式以实现vector的自增长性，效率是极其低下的。为了使vector容器实现快速的内存分配，实际分配的容器会比当前所需的空间多一些，vector容器预留了这些额外的存储区，用来存放新添加的元素，而不需要每次都重新分配新的存储空间。你可以从vector里实现capacity和reserve成员可以看出这种机制。
    capacity和size的区别：size是容器当前拥有的元素个数，而capacity则指容器在必须分配新存储空间之前可以存储的元素总数。
    vector迭代器的几种失效的情况： 
1、当插入（push_back）一个元素后，end操作返回的迭代器肯定失效。
2、当插入(push_back)一个元素后，capacity返回值与没有插入元素之前相比有改变，则需要重新加载整个容器，此时first和end操作返回的迭代器都会失效。
3、当进行删除操作（erase，pop_back）后，指向删除点的迭代器全部失效；指向删除点后面的元素的迭代器也将全部失效。
    deque迭代器的失效情况： 在C++Primer一书中是这样限定的： 
1、在deque容器首部或者尾部插入元素不会使得任何迭代器失效。 
2、在其首部或尾部删除元素则只会使指向被删除元素的迭代器失效。
3、在deque容器的任何其他位置的插入和删除操作将使指向该容器元素的所有迭代器失效。但是：我在vs2005测试发现第一条都不满足，不知为何？等以后深入STL以后慢慢的领会吧！
     只有list的迭代器好像很少情况下会失效。也许就只是在删除的时候，指向被删除节点的迭代器会失效吧，其他的还没有发现。
先看两条规制：
1、对于节点式容器(map, list, set)元素的删除，插入操作会导致指向该元素的迭代器失效，其他元素迭代器不受影响。
2、对于顺序式容器(vector)元素的删除、插入操作会导致指向该元素以及后面的元素的迭代器失效。
众所周之当使用一个容器的insert或者erase函数通过迭代器插入或删除元素"可能"会导致迭代器失效，因此很多建议都是让我们获取insert或者erase返回的迭代器，以便用重新获取新的有效的迭代器进行正确的操作：
代码如下：

[cpp]  view plain  copy

1. iter = vec.insert(iter);  
2. iter = vec.erase(iter);  

 

STL源码剖析---STL容器特征总结（含迭代器失效）

 

Vector

1、内部数据结构：连续存储，例如数组。
2、随机访问每个元素，所需要的时间为常量。
3、在末尾增加或删除元素所需时间与元素数目无关，在中间或开头增加或删除元素所需时间随元素数目呈线性变化。
4、可动态增加或减少元素，内存管理自动完成，但程序员可以使用reserve()成员函数来管理内存。
5、迭代器失效
插入：vector的迭代器在内存重新分配时将失效（它所指向的元素在该操作的前后不再相同）。当把超过capacity()-size()个元素插入vector中时，内存会重新分配，所有的迭代器都将失效；
删除：当进行删除操作（erase，pop_back）后，指向删除点及其后元素的迭代器全部失效。
建议：使用vector时，用reserve()成员函数预先分配需要的内存空间，它既可以保护迭代器使之不会失效，又可以提高运行效率。

deque

1、内部数据结构：连续存储或者分段连续存储，具体依赖于实现，例如数组。
2、随机访问每个元素，所需要的时间为常量。
3、在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除元素所需时间随元素数目呈线性变化。
4、可动态增加或减少元素，内存管理自动完成，不提供用于内存管理的成员函数。
5、迭代器失效
插入：增加任何元素都将使deque的迭代器失效。
删除：在deque的中间删除元素将使迭代器失效。在deque的头或尾删除元素时，只有指向该元素的迭代器失效。

list

1、内部数据结构：双向环状链表。
2、不能随机访问一个元素。
3、可双向遍历。
4、在开头、末尾和中间任何地方增加或删除元素所需时间都为常量。
5、可动态增加或减少元素，内存管理自动完成。
6、迭代器失效
插入：增加任何元素都不会使迭代器失效。
删除：删除元素时，除了指向当前被删除元素的迭代器外，其它迭代器都不会失效。

slist

1、内部数据结构：单向链表。
2、不可双向遍历，只能从前到后地遍历。
3、其它的特性同list相似。
建议：尽量不要使用slist的insert，erase，previous等操作。因为这些操作需要向前遍历，     但是slist不能直接向前遍历，所以它会从头开始向后搜索，所需时间与位于当前元      素之前的元素个数成正比。slist专门提供了insert_after，erase_after等函数进行优化。         但若经常需要向前遍历，建议选用list。

Stack

1、适配器，它可以将任意类型的序列容器转换为一个堆栈，一般使用deque作为支持的序列容器。
2、元素只能后进先出（LIFO）。
3、不能遍历整个stack。
4、适配器，它可以将任意类型的序列容器转换为一个队列，一般使用deque作为支持的序列容器。
5、元素只能先进先出（FIFO）。
6、不能遍历整个queue。
7、适配器，它可以将任意类型的序列容器转换为一个优先级队列，一般使用vector作为底层存储方式。
8、只能访问第一个元素，不能遍历整个priority_queue。
9、第一个元素始终是优先级最高的一个元素。

queue

priority_queue

建议：当需要stack，queue，或priority_queue这种数据结构时，直接使用对应的容器类，     不要使用deque去做它们类似的工作。

Set

1、键和值相等。
2、键唯一。
3、元素默认按升序排列。
4、迭代器失效
删除：如果迭代器所指向的元素被删除，则该迭代器失效。

map

1、键唯一。
2、元素默认按键的升序排列。
3、迭代器失效
删除：如果迭代器所指向的元素被删除，则该迭代器失效。

hash与set、multiset、map、multimap的结合

       它里面的元素不一定是按键值排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当前和hash函数有关）。
建议：当元素的有序比搜索更重要时，应选用set，multiset，map或multimap。否则，选用   hash_set，hash_multiset，hash_map或hash_multimap
建议：往容器中插入元素时，若元素在容器中的顺序无关紧要，请尽量加在最后面。若经常         需要在序列容器的开头或中间增加或删除元素时，应选用list。
建议：对关联容器而言，尽量不要使用C风格的字符串（即字符指针char*）作为键值。如果非用不可，应显示地定义字符串比较运算符，即operator<，operator==，operator<=     等。
建议：当容器作为参数被传递时，请采用引用传递方式。否则将调用容器的拷贝构造函数，其开销是难以想象的。
      STL组建与平台无关，与应用无关，与数据类型无关。
代码如下：

[cpp]  view plain  copy

1. vector<int> vec;  
2. vector<int>::iterator iter = vec.begin();  
3.   
4. int main(void)  
5. {  
6.     while(iter != vec.end())  
7.     {  
8.         iter = vec.erase(iter);    //vector删除时迭代器失效，要重新获取迭代器。  
9.     }  
10.     return 0;  
11. }  

STL源码剖析---红黑树原理详解上

一、红黑树概述

     红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。
     红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的平衡。学过数据结构的人应该都已经领教过AVL树的复杂，但AVL树的复杂比起红黑树来说简直是小巫见大巫，红黑树才是真正的变态级数据结构。
     由于STL中的关联式容器默认的底层实现都是红黑树，因此红黑树对于后续学习STL源码还是很重要的，有必要掌握红黑树的实现原理和源码实现。
     红黑树是AVL树的变种，红黑树通过一些着色法则确保没有一条路径会比其它路径长出两倍，因而达到接近平衡的目的。所谓红黑树，不仅是一个二叉搜索树，而且必须满足一下规则：
     1、每个节点不是红色就是黑色。
     2、根节点为黑色。
     3、如果节点为红色，其子节点必须为黑色。
     4、任意一个节点到到NULL（树尾端）的任何路径，所含之黑色节点数必须相同。
上面的这些约束保证了这个树大致上是平衡的，这也决定了红黑树的插入、删除、查询等操作是比较快速的。 根据规则4，新增节点必须为红色；根据规则3，新增节点之父节点必须为黑色。当新增节点根据二叉搜索树的规则到达其插入点时，却未能符合上述条件时，就必须调整颜色并旋转树形，如下图：

假设我们为上图分别插入节点3、8、35、75，根据二叉搜索树的规则，插入这四个节点后，我们会发现它们都破坏了红黑树的规则，因此我们必须调整树形，也就是旋转树形并改变节点的颜色。

二、红黑树上结点的插入

      在讨论红黑树的插入操作之前必须要明白，任何一个即将插入的新结点的初始颜色都为红色。这一点很容易理解，因为插入黑点会增加某条路径上黑结点的数目，从而导致整棵树黑高度的不平衡。但如果新结点的父结点为红色时（如下图所示），将会违反红黑树的性质：一条路径上不能出现相邻的两个红色结点。这时就需要通过一系列操作来使红黑树保持平衡。

      为了清楚地表示插入操作以下在结点中使用“新”字表示一个新插入的结点；使用“父”字表示新插入点的父结点；使用“叔”字表示“父”结点的兄弟结点；使用“祖”字表示“父”结点的父结点。插入操作分为以下几种情况：
1、黑父
     如下图所示，如果新节点的父结点为黑色结点，那么插入一个红点将不会影响红黑树的平衡，此时插入操作完成。红黑树比AVL树优秀的地方之一在于黑父的情况比较常见，从而使红黑树需要旋转的几率相对AVL树来说会少一些。

2、红父
     如果新节点的父结点为红色，这时就需要进行一系列操作以保证整棵树红黑性质。如下图所示，由于父结点为红色，此时可以判定，祖父结点必定为黑色。这时需要根据叔父结点的颜色来决定做什么样的操作。青色结点表示颜色未知。由于有可能需要根结点到新点的路径上进行多次旋转操作，而每次进行不平衡判断的起始点（我们可将其视为新点）都不一样。所以我们在此使用一个蓝色箭头指向这个起始点，并称之为判定点。

2.1 红叔
当叔父结点为红色时，如下图所示，无需进行旋转操作，只要将父和叔结点变为黑色，将祖父结点变为红色即可。但由于祖父结点的父结点有可能为红色，从而违反红黑树性质。此时必须将祖父结点作为新的判定点继续向上（迭代）进行平衡操作。

需要注意的是，无论“父节点”在“叔节点”的左边还是右边，无论“新节点”是“父节点”的左孩子还是右孩子，它们的操作都是完全一样的（其实这种情况包括4种，只需调整颜色，不需要旋转树形）。
2.2 黑叔
当叔父结点为黑色时，需要进行旋转，以下图示了所有的旋转可能：
Case 1:

Case 2:

Case 3:

Case 4:

      可以观察到，当旋转完成后，新的旋转根全部为黑色，此时不需要再向上回溯进行平衡操作，插入操作完成。需要注意，上面四张图的“叔”、“1”、“2”、“3”结点有可能为黑哨兵结点。
      其实红黑树的插入操作不是很难，甚至比AVL树的插入操作还更简单些。红黑树的插入操作源代码如下：

[cpp]  view plain  copy

1. // 元素插入操作  insert_unique()  
2. // 插入新值：节点键值不允许重复，若重复则插入无效  
3. // 注意，返回值是个pair，第一个元素是个红黑树迭代器，指向新增节点  
4. // 第二个元素表示插入成功与否  
5. template<class Key , class Value , class KeyOfValue , class Compare , class Alloc>  
6. pair<typename rb_tree<Key , Value , KeyOfValue , Compare , Alloc>::iterator , bool>  
7. rb_tree<Key , Value , KeyOfValue , Compare , Alloc>::insert_unique(const Value &v)  
8. {  
9.     rb_tree_node* y = header;    // 根节点root的父节点  
10.     rb_tree_node* x = root();    // 从根节点开始  
11.     bool comp = true;  
12.     while(x != 0)  
13.     {  
14.         y = x;  
15.         comp = key_compare(KeyOfValue()(v) , key(x));    // v键值小于目前节点之键值？  
16.         x = comp ? left(x) : right(x);   // 遇“大”则往左，遇“小于或等于”则往右  
17.     }  
18.     // 离开while循环之后，y所指即插入点之父节点（此时的它必为叶节点）  
19.     iterator j = iterator(y);     // 令迭代器j指向插入点之父节点y  
20.     if(comp)     // 如果离开while循环时comp为真（表示遇“大”，将插入于左侧）  
21.     {  
22.         if(j == begin())    // 如果插入点之父节点为最左节点  
23.             return pair<iterator , bool>(_insert(x , y , z) , true);  
24.         else     // 否则（插入点之父节点不为最左节点）  
25.             --j;   // 调整j，回头准备测试  
26.     }  
27.     if(key_compare(key(j.node) , KeyOfValue()(v) ))  
28.         // 新键值不与既有节点之键值重复，于是以下执行安插操作  
29.         return pair<iterator , bool>(_insert(x , y , z) , true);  
30.     // 以上，x为新值插入点，y为插入点之父节点，v为新值  
31.   
32.     // 进行至此，表示新值一定与树中键值重复，那么就不应该插入新值  
33.     return pair<iterator , bool>(j , false);  
34. }  
35.   
36. // 真正地插入执行程序 _insert()  
37. template<class Key , class Value , class KeyOfValue , class Compare , class Alloc>  
38. typename<Key , Value , KeyOfValue , Compare , Alloc>::_insert(base_ptr x_ , base_ptr y_ , const Value &v)  
39. {  
40.     // 参数x_ 为新值插入点，参数y_为插入点之父节点，参数v为新值  
41.     link_type x = (link_type) x_;  
42.     link_type y = (link_type) y_;  
43.     link_type z;  
44.   
45.     // key_compare 是键值大小比较准则。应该会是个function object  
46.     if(y == header || x != 0 || key_compare(KeyOfValue()(v) , key(y) ))  
47.     {  
48.         z = create_node(v);    // 产生一个新节点  
49.         left(y) = z;           // 这使得当y即为header时，leftmost() = z  
50.         if(y == header)  
51.         {  
52.             root() = z;  
53.             rightmost() = z;  
54.         }  
55.         else if(y == leftmost())     // 如果y为最左节点  
56.             leftmost() = z;          // 维护leftmost()，使它永远指向最左节点  
57.     }  
58.     else  
59.     {  
60.         z = create_node(v);        // 产生一个新节点  
61.         right(y) = z;              // 令新节点成为插入点之父节点y的右子节点  
62.         if(y == rightmost())  
63.             rightmost() = z;       // 维护rightmost()，使它永远指向最右节点  
64.     }  
65.     parent(z) = y;      // 设定新节点的父节点  
66.     left(z) = 0;        // 设定新节点的左子节点  
67.     right(z) = 0;       // 设定新节点的右子节点  
68.     // 新节点的颜色将在_rb_tree_rebalance()设定（并调整）  
69.     _rb_tree_rebalance(z , header->parent);      // 参数一为新增节点，参数二为根节点root  
70.     ++node_count;       // 节点数累加  
71.     return iterator(z);  // 返回一个迭代器，指向新增节点  
72. }  
73.   
74.   
75. // 全局函数  
76. // 重新令树形平衡（改变颜色及旋转树形）  
77. // 参数一为新增节点，参数二为根节点root  
78. inline void _rb_tree_rebalance(_rb_tree_node_base* x , _rb_tree_node_base*& root)  
79. {  
80.     x->color = _rb_tree_red;    //新节点必为红  
81.     while(x != root && x->parent->color == _rb_tree_red)    // 父节点为红  
82.     {  
83.         if(x->parent == x->parent->parent->left)      // 父节点为祖父节点之左子节点  
84.         {  
85.             _rb_tree_node_base* y = x->parent->parent->right;    // 令y为伯父节点  
86.             if(y && y->color == _rb_tree_red)    // 伯父节点存在，且为红  
87.             {  
88.                 x->parent->color = _rb_tree_black;           // 更改父节点为黑色  
89.                 y->color = _rb_tree_black;                   // 更改伯父节点为黑色  
90.                 x->parent->parent->color = _rb_tree_red;     // 更改祖父节点为红色  
91.                 x = x->parent->parent;  
92.             }  
93.             else    // 无伯父节点，或伯父节点为黑色  
94.             {  
95.                 if(x == x->parent->right)   // 如果新节点为父节点之右子节点  
96.                 {  
97.                     x = x->parent;  
98.                     _rb_tree_rotate_left(x , root);    // 第一个参数为左旋点  
99.                 }  
100.                 x->parent->color = _rb_tree_black;     // 改变颜色  
101.                 x->parent->parent->color = _rb_tree_red;  
102.                 _rb_tree_rotate_right(x->parent->parent , root);    // 第一个参数为右旋点  
103.             }  
104.         }  
105.         else          // 父节点为祖父节点之右子节点  
106.         {  
107.             _rb_tree_node_base* y = x->parent->parent->left;    // 令y为伯父节点  
108.             if(y && y->color == _rb_tree_red)    // 有伯父节点，且为红  
109.             {  
110.                 x->parent->color = _rb_tree_black;           // 更改父节点为黑色  
111.                 y->color = _rb_tree_black;                   // 更改伯父节点为黑色  
112.                 x->parent->parent->color = _rb_tree_red;     // 更改祖父节点为红色  
113.                 x = x->parent->parent;          // 准备继续往上层检查  
114.             }  
115.             else    // 无伯父节点，或伯父节点为黑色  
116.             {  
117.                 if(x == x->parent->left)        // 如果新节点为父节点之左子节点  
118.                 {  
119.                     x = x->parent;  
120.                     _rb_tree_rotate_right(x , root);    // 第一个参数为右旋点  
121.                 }  
122.                 x->parent->color = _rb_tree_black;     // 改变颜色  
123.                 x->parent->parent->color = _rb_tree_red;  
124.                 _rb_tree_rotate_left(x->parent->parent , root);    // 第一个参数为左旋点  
125.             }  
126.         }  
127.     }//while  
128.     root->color = _rb_tree_black;    // 根节点永远为黑色  
129. }  
130.   
131.   
132. // 左旋函数  
133. inline void _rb_tree_rotate_left(_rb_tree_node_base* x , _rb_tree_node_base*& root)  
134. {  
135.     // x 为旋转点  
136.     _rb_tree_node_base* y = x->right;          // 令y为旋转点的右子节点  
137.     x->right = y->left;  
138.     if(y->left != 0)  
139.         y->left->parent = x;           // 别忘了回马枪设定父节点  
140.     y->parent = x->parent;  
141.   
142.     // 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来）  
143.     if(x == root)    // x为根节点  
144.         root = y;  
145.     else if(x == x->parent->left)         // x为其父节点的左子节点  
146.         x->parent->left = y;  
147.     else                                  // x为其父节点的右子节点  
148.         x->parent->right = y;  
149.     y->left = x;  
150.     x->parent = y;  
151. }  
152.   
153.   
154. // 右旋函数  
155. inline void _rb_tree_rotate_right(_rb_tree_node_base* x , _rb_tree_node_base*& root)  
156. {  
157.     // x 为旋转点  
158.     _rb_tree_node_base* y = x->left;          // 令y为旋转点的左子节点  
159.     x->left = y->right;  
160.     if(y->right != 0)  
161.         y->right->parent = x;           // 别忘了回马枪设定父节点  
162.     y->parent = x->parent;  
163.   
164.     // 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来）  
165.     if(x == root)  
166.         root = y;  
167.     else if(x == x->parent->right)         // x为其父节点的右子节点  
168.         x->parent->right = y;  
169.     else                                  // x为其父节点的左子节点  
170.         x->parent->left = y;  
171.     y->right = x;  
172.     x->parent = y;  
173. }  

STL源码剖析---红黑树原理详解下

算法导论书上给出的红黑树的性质如下，跟STL源码剖析书上面的4条性质大同小异。
      1、每个结点或是红色的，或是黑色的
      2、根节点是黑色的
      3、每个叶结点（NIL）是黑色的
      4、如果一个节点是红色的，则它的两个儿子都是黑色的。
      5、对于每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑色结点。
      从红黑树上删除一个节点，可以先用普通二叉搜索树的方法，将节点从红黑树上删除掉，然后再将被破坏的红黑性质进行恢复。
      我们回忆一下普通二叉树的节点删除方法：Z指向需要删除的节点，Y指向实质结构上被删除的结点，如果Z节点只有一个子节点或没有子节点，那么Y就是指向Z指向的节点。如果Z节点有两个子节点，那么Y指向Z节点的后继节点（其实前趋也是一样的），而Z的后继节点绝对不可能有左子树。因此，仅从结构来看，二叉树上实质被删除的节点最多只可能有一个子树。
现在我们来看红黑性质的恢复过程：
      如果Y指向的节点是个红色节点，那么直接删除掉Y以后，红黑性质不会被破坏。操作结束。
      如果Y指向的节点是个黑色节点，那么就有几条红黑性质可能受到破坏了。首先是包含Y节点的所有路径，黑高度都减少了一（第５条被破坏）。其次，如果Y的有红色子节点，Y又有红色的父节点，那么Y被删除后，就出现了两个相邻的红色节点（第４条被破坏）。最后，如果Y指向的是根节点，而Y的子节点又是红色的，那么Y被删除后，根节点就变成红色的了（第２条被破坏）。
      其中，第５条被破坏是让我们比较难受的。因为这影响到了全局。这样动作就太大太复杂了。而且在这个条件下，进行其它红黑性质的恢复也很困难。所以我们首先解决这个问题：如果不改变含Y路径的黑高度，那么树的其它部分的黑高度就必须做出相应的变化来适应它。所以，我们想办法恢复原来含Y节点的路径的黑高度。做法就是：无条件的把Y节点的黑色，推到它的子节点X上去。（X可能是NIL节点）。这样，X就可能具有双重黑色，或同时具有红黑两色，也就是第１条性质被破坏了。
      但第１条性质是比较容易恢复的：一、如果X是同时具有红黑两色，那么好办，直接把X涂成黑色，就行了。而且这样把所有问题都解决了。因为将X变为黑色，２、４两条如果有问题的话也会得到恢复，算法结束。二、如果X是双黑色，那么我们希望把这种情况向上推一直推到根节点（调整树结构和颜色，X的指向新的双黑色节点，X不断向上移动），让根节点具双黑色，这时，直接把X的一层黑色去掉就行了（因为根节点被包含在所有的路径上，所以这样做所有路径同时黑高减少一，不会破坏红黑特征）。
      下面就具体地分析如何恢复1、２、４三个可能被破坏的红黑特性：我们知道，如果X指向的节点是有红黑两色，或是X是根节点时，只需要简单的对X进行一些改变就行了。要对除X节点外的其它节点进行操作时，必定是这样的情况：X节点是双层黑色，且X有父节点P。由知可知，X必然有兄弟节点W，而且这个W节点必定有两个子节点。（因为这是原树满足红黑条件要求而自然具备的。X为双黑色，那么P的另一个子节点以下一定要有至少两层的节点，否则黑色高度不可能和X路径一致）。所以我们就分析这些节点之间如何变形，把问题限制在比较小的范围内解决。另一个前提是：X在一开始，肯定是树底的叶节点或是NIL节点，所以在递归向上的过程中，每一步都保证下一步进行时，至少 X的子树是满足红黑特性的。因此子树的情况就可以认为是已经正确的了，这样，分析就只限制在X节点，X的父节点P和X的兄弟节点W，以及W的两个子节点中。
      下面仅仅考虑X原本是黑色的情况即可。
      在这种情况下，X此时应该具有双重黑色，算法的过程就是将这多出的一重黑色向上移动，直到遇到红节点或者根节点。
      接着往下分析， 会遇到4种情况，实际上是8种， 因为其中4种是相互对称的，这可以通过判断X是其父节点的右孩子还是左孩子来区分。下面我们以X是其父节点的左孩子的情况来分析这4种情况，实际上接下来的调整过程，就是要想方设法将经过X的所有路径上的黑色节点个数增加1。
      具体分为以下四种情况：（下面针对x是左儿子的情况讨论，右儿子对称）
      Case1：X的兄弟W是红色（想办法将其变为黑色）
       由于W是红色的，因此其儿子节点和父节点必为黑色，只要将W和其父节点的颜色对换，在对父节点进行一次左旋转，便将W的左子节点放到了X的兄弟节点上，X的兄弟节点变成了黑色，且红黑性质不变。但还不算完，只是暂时将情况1转变成了下面的情况2或3或4。

    Case2：X的兄弟节点W是黑色的，而且W的两个子节点都是黑色的。此时可以将X的一重黑色和W的黑色同时去掉，而转加给他们的父节点上，这是X就指向它的父节点了，因此此时父节点具有双重颜色了。这一重黑色节点上移。

      如果父节点原来是红色的，现在又加一层黑色，那么X现在指向的这个节点就是红黑两色的，直接把X（也就是父节点）着为黑色。问题就已经完整解决了。
     如果父节点现在是双层黑色，那就以父节点为新的X进行向上的下一次的递归。
    Case3：X的兄弟节点W是黑色的，而且W的左子节点是红色的，右子节点是黑色的。此时通过交换W和其左子节点的颜色并进行一次向右旋转就可转换成下面的第四种情况。注意，原来L是红色的，所以L的子节点一定是黑色的，所以旋转中L节点的一个子树挂到之后着为红色的W节点上不会破坏红黑性质。变形后黑色高度不变。

    Case4： X的兄弟节点W是黑色的，而且W的右子节点是红色的。这种情况下，做一次左旋，W就处于根的位置，将W保持为原来的根的位置的颜色，同时将W的两个新的儿子节点的颜色变为黑色，去掉X的一重黑色。这样 整个问题也就得到了解决。递归结束。（在代码上，为了标识递归结束，我们把X指向根节点）

      因此，只要按上面四种情况一直递归处理下去，X最终总会指向根结点或一个红色结点，这时我们就可以结束递归并把问题解决了。
      以上就是红黑树的节点删除全过程。
      总结：
      如果我们通过上面的情况画出所有的分支图，我们可以得出如下结论
      插入操作：解决的是 红-红 问题
      删除操作：解决的是 黑-黑 问题
      即你可以从分支图中看出，需要往上遍历的情况为红红(插入)，或者为黑黑黑（删除）的情况，如果你认真分析并总结所有的情况后，并坚持下来，红黑树也就没有想象中的那么恐怖了，并且很美妙；
      详细的红黑树删除节点的代码如下：

[cpp]  view plain  copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. // 定义节点颜色    
5. enum COLOR  
6. {    
7.     BLACK = 0,    
8.     RED    
9. };    
10.     
11. // 红黑树节点    
12. typedef struct RB_Tree_Node  
13. {    
14.     int key;    
15.     struct RB_Tree_Node *left;    
16.     struct RB_Tree_Node *right;    
17.     struct RB_Tree_Node *parent;    
18.     unsigned char RB_COLOR;    
19. }RB_Node;  
20.   
21. // 红黑树，包含一个指向根节点的指针    
22. typedef struct RBTree  
23. {    
24.     RB_Node* root;  
25. }*RB_Tree;  
26.   
27. // 红黑树的NIL节点    
28. static RB_Tree_Node NIL = {0, 0, 0, 0, BLACK};   
29.   
30. #define PNIL (&NIL)   // NIL节点地址   
31.   
32. void Init_RBTree(RB_Tree pTree) // 初始化一棵红黑树    
33. {    
34.     pTree->root = PNIL;    
35. }     
36.   
37. // 查找最小键值节点    
38. RB_Node* RBTREE_MIN(RB_Node* pRoot)    
39. {    
40.     while (PNIL != pRoot->left)  
41.     {  
42.         pRoot = pRoot->left;  
43.     }    
44.     return pRoot;  
45. }  
46.   
47.   
48. /* 
49.                           15 
50.                         /    \ 
51.                        /      \ 
52.                       /        \ 
53.                      6          18 
54.                     /  \       /  \ 
55.                    /    \     /    \ 
56.                   3      7   17    20 
57.                  /  \     \ 
58.                 /    \     \ 
59.                2      4     13 
60.                             / 
61.                            / 
62.                           9 
63. */  
64. // 查找指定节点的后继节点    
65. RB_Node* RBTREE_SUCCESSOR(RB_Node*  pRoot)    
66. {    
67.     if (PNIL != pRoot->right)    // 查找图中6的后继节点时就调用RBTREE_MIN函数  
68.     {    
69.         return RBTREE_MIN(pRoot->right);    
70.     }  
71.     // 节点没有右子树的时候，进入下面的while循环（如查找图中13的后继节点时，它的后继节点是15）  
72.     RB_Node* pParent = pRoot->parent;    
73.     while((PNIL != pParent) && (pRoot == pParent->right))  
74.     {    
75.         pRoot = pParent;  
76.         pParent = pRoot->parent;        
77.     }  
78.     return pParent;  
79. }  
80.   
81. // 红黑树的节点删除  
82. RB_Node* Delete(RB_Tree pTree , RB_Node* pDel)    
83. {    
84.     RB_Node* rel_delete_point;  
85.     if(pDel->left == PNIL || pDel->right == PNIL)  
86.         rel_delete_point = pDel;  
87.     else  
88.         rel_delete_point = RBTREE_SUCCESSOR(pDel);     // 查找后继节点  
89.   
90.     RB_Node* delete_point_child;    
91.     if(rel_delete_point->right != PNIL)    
92.     {    
93.         delete_point_child = rel_delete_point->right;    
94.     }    
95.     else if(rel_delete_point->left != PNIL)    
96.     {    
97.         delete_point_child = rel_delete_point->left;    
98.     }    
99.     else    
100.     {    
101.         delete_point_child = PNIL;    
102.     }    
103.     delete_point_child->parent = rel_delete_point->parent;    
104.     if(rel_delete_point->parent == PNIL)    // 删除的节点是根节点  
105.     {    
106.         pTree->root = delete_point_child;  
107.     }    
108.     else if(rel_delete_point == rel_delete_point->parent->right)  
109.     {    
110.         rel_delete_point->parent->right = delete_point_child;    
111.     }    
112.     else    
113.     {    
114.         rel_delete_point->parent->left = delete_point_child;    
115.     }  
116.     if(pDel != rel_delete_point)  
117.     {  
118.         pDel->key = rel_delete_point->key;  
119.     }  
120.     if(rel_delete_point->RB_COLOR == BLACK)    
121.     {    
122.         DeleteFixUp(pTree , delete_point_child);    
123.     }  
124.     return rel_delete_point;    
125. }    
126.                
127.   
128. /* 
129. 算法导论上的描述如下： 
130. RB-DELETE-FIXUP(T, x)  
131. 1 while x ≠ root[T] and color[x] = BLACK  
132. 2     do if x = left[p[x]]  
133. 3           then w ← right[p[x]]  
134. 4                if color[w] = RED  
135. 5                   then color[w] ← BLACK                           Case 1  
136. 6                        color[p[x]] ← RED                          Case 1  
137. 7                        LEFT-ROTATE(T, p[x])                       Case 1  
138. 8                        w ← right[p[x]]                            Case 1  
139. 9                if color[left[w]] = BLACK and color[right[w]] = BLACK  
140. 10                   then color[w] ← RED                            Case 2  
141. 11                        x p[x]                                    Case 2  
142. 12                   else if color[right[w]] = BLACK  
143. 13                           then color[left[w]] ← BLACK            Case 3  
144. 14                                color[w] ← RED                    Case 3  
145. 15                                RIGHT-ROTATE(T, w)                Case 3  
146. 16                                w ← right[p[x]]                   Case 3  
147. 17                         color[w] ← color[p[x]]                   Case 4  
148. 18                         color[p[x]] ← BLACK                      Case 4  
149. 19                         color[right[w]] ← BLACK                  Case 4  
150. 20                         LEFT-ROTATE(T, p[x])                     Case 4  
151. 21                         x ← root[T]                              Case 4  
152. 22        else (same as then clause with "right" and "left" exchanged)  
153. 23 color[x] ← BLACK   
154. */    
155. //接下来的工作，很简单，即把上述伪代码改写成c++代码即可    
156. void DeleteFixUp(RB_Tree pTree , RB_Node* node)    
157. {    
158.     while(node != pTree->root && node->RB_COLOR == BLACK)    
159.     {    
160.         if(node == node->parent->left)    
161.         {    
162.             RB_Node* brother = node->parent->right;    
163.             if(brother->RB_COLOR==RED)   //情况1：x的兄弟w是红色的。    
164.             {    
165.                 brother->RB_COLOR = BLACK;    
166.                 node->parent->RB_COLOR = RED;    
167.                 RotateLeft(node->parent);    
168.             }    
169.             else     //情况2：x的兄弟w是黑色的，    
170.             {    
171.                 if(brother->left->RB_COLOR == BLACK && brother->right->RB_COLOR == BLACK)  //w的两个孩子都是黑色的    
172.                 {    
173.                     brother->RB_COLOR = RED;    
174.                     node = node->parent;    
175.                 }    
176.                 else  
177.                 {  
178.                     if(brother->right->RB_COLOR == BLACK)   //情况3：x的兄弟w是黑色的，w的右孩子是黑色（w的左孩子是红色）。    
179.                     {  
180.                         brother->RB_COLOR = RED;  
181.                         brother->left->RB_COLOR = BLACK;  
182.                         RotateRight(brother);  
183.                         brother = node->parent->right;      //情况3转换为情况4  
184.                     }  
185.                     //情况4：x的兄弟w是黑色的，且w的右孩子时红色的  
186.                     brother->RB_COLOR = node->parent->RB_COLOR;    
187.                     node->parent->RB_COLOR = BLACK;    
188.                     brother->right->RB_COLOR = BLACK;    
189.                     RotateLeft(node->parent);    
190.                     node = pTree->root;  
191.                 }//else  
192.             }//else  
193.         }    
194.         else   //同上，原理一致，只是遇到左旋改为右旋，遇到右旋改为左旋即可。其它代码不变。    
195.         {    
196.             RB_Node* brother = node->parent->left;    
197.             if(brother->RB_COLOR == RED)    
198.             {    
199.                 brother->RB_COLOR = BLACK;    
200.                 node->parent->RB_COLOR = RED;    
201.                 RotateRight(node->parent);    
202.             }    
203.             else    
204.             {    
205.                 if(brother->left->RB_COLOR==BLACK && brother->right->RB_COLOR == BLACK)    
206.                 {    
207.                     brother->RB_COLOR = RED;    
208.                     node = node->parent;    
209.                 }    
210.                 else  
211.                 {  
212.                     if(brother->left->RB_COLOR==BLACK)    
213.                     {    
214.                         brother->RB_COLOR = RED;    
215.                         brother->right->RB_COLOR = BLACK;    
216.                         RotateLeft(brother);  
217.                         brother = node->parent->left;      //情况3转换为情况4  
218.                     }  
219.                     brother->RB_COLOR = node->parent->RB_COLOR;    
220.                     node->parent->RB_COLOR = BLACK;    
221.                     brother->left->RB_COLOR = BLACK;    
222.                     RotateRight(node->parent);    
223.                     node = pTree->root;    
224.                 }    
225.             }    
226.         }    
227.     }//while   
228.     node->RB_COLOR = BLACK;    //如果X节点原来为红色，那么直接改为黑色    
229. }  

上文来自：http://blog.csdn.net/Hackbuteer1/article/category/1181402