PC客户端开发研究者---爱生活,爱code!

STL-Deque 源码剖析

   1 G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_deque.h 完整列表
   2 /*
   3  *
   4  * Copyright (c) 1994
   5  * Hewlett-Packard Company
   6  *
   7  * Permission to use, copy, modify, distribute and sell this software
   8  * and its documentation for any purpose is hereby granted without fee,
   9  * provided that the above copyright notice appear in all copies and
  10  * that both that copyright notice and this permission notice appear
  11  * in supporting documentation.  Hewlett-Packard Company makes no
  12  * representations about the suitability of this software for any
  13  * purpose.  It is provided "as is" without express or implied warranty.
  14  *
  15  *
  16  * Copyright (c) 1997
  17  * Silicon Graphics Computer Systems, Inc.
  18  *
  19  * Permission to use, copy, modify, distribute and sell this software
  20  * and its documentation for any purpose is hereby granted without fee,
  21  * provided that the above copyright notice appear in all copies and
  22  * that both that copyright notice and this permission notice appear
  23  * in supporting documentation.  Silicon Graphics makes no
  24  * representations about the suitability of this software for any
  25  * purpose.  It is provided "as is" without express or implied warranty.
  26  */
  27 
  28 /* NOTE: This is an internal header file, included by other STL headers.
  29  *   You should not attempt to use it directly.
  30  */
  31 
  32 #ifndef __SGI_STL_INTERNAL_DEQUE_H
  33 #define __SGI_STL_INTERNAL_DEQUE_H
  34 
  35 /* Class 的恆長特性(invariants):
  36  *  對於任何 nonsingular iterator I:
  37  *    i.node 是 map array 中的某個元素的位址。
  38  *      i.node 所指內容則是一個指標,指向某個節點(緩衝區)的頭。
  39  *    i.first == *(i.node) 
  40  *    i.last  == i.first + node_size(也就是 buffer_size())
  41  *    i.cur 是一個指標,指向範圍 [i.first, i.last) 之間。注意:
  42  *      這意味 i.cur 永遠是一個 dereferenceable pointer,
  43  *      縱使 i 是一個 past-the-end iterator.
  44  *  Start 和 Finish 總是 nonsingular iterators。注意:這意味
  45  *    empty deque 一定會有一個node,而一個具有N個元素的deque,
  46  *    (N 表示緩衝區大小),一定會有兩個nodes。
  47  *  對於start.node 和finish.node 以外的每一個node,其中的每一個元素
  48  *    都是一個經過初始化的物件。如果 start.node == finish.node,
  49  *    那麼 [start.cur, finish.cur) 都是經過初始化的物件,而該範圍以外
  50  *    元素則是未經初始化的空間。否則,[start.cur, start.last) 和
  51  *    [finish.first, finish.cur) 是經過初始化的物件,而
  52  *    [start.first, start.cur) 和 [finish.cur, finish.last)
  53  *    則是未經初始化的空間
  54  *  [map, map + map_size) 是一個有效的,non-empty 的範圍。  
  55  *  [start.node, finish.node] 是一個有效的範圍,內含於 
  56  *    [map, map + map_size) 之內。  
  57  *  範圍 [map, map + map_size) 內的任何一個指標會指向一個經過配置的
  58  *    node — 若且唯若該指標在範圍 [start.node, finish.node] 之內。
  59  */
  60 
  61 /*
  62  * 在前一版的deque中,node_size 由編譯器定死。這個版本允許使用者選擇節點 
  63  * (node)的大小。Deque 有三個 template 參數,其中第三個是一個型別為 size_t 
  64  * 的數值,代表每個節點(node)內含的元素個數。如果第三個 template 參數為0
  65  * (那是預設值),deque 就使用預設的節點大小。
  66  *
  67  * 使用不同的節點大小的唯一理由是,或許你的程式需要不同的效率並願意付出其他方
  68  * 面的代價。例如,假設你的程式內含許多deques,每一個都只內含一些元素,那麼
  69  * 你可以使用較小的 nodes 來節省記憶體(或許會因此犧牲速度)。
  70  *
  71  * 不幸的是,某些編譯器面對 non-type template 參數會有問題。stl_config.h 之
  72  * 中為此定義了一個 __STL_NON_TYPE_TMPL_PARAM_BUG。如果你的編譯器正是如
  73  * 此,你就無法使用不同的節點大小,你必須使用預設大小。
  74 */
  75 
  76 __STL_BEGIN_NAMESPACE 
  77 
  78 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  79 #pragma set woff 1174
  80 #endif
  81 
  82 // 注意:下面這個函式是七拼八湊的產品,只是為了閃避數家編譯器在處理常數算式
  83 // (constant expressions)時的臭蟲。
  84 // 如果 n 不為 0,傳回 n,表示 buffer size 由使用者自定。
  85 // 如果 n 為 0,表示buffer size 使用預設值,那麼
  86 //   如果 sz(元素大小,sizeof(value_type))小於 512,傳回 512/sz,
  87 //   如果 sz 不小於 512,傳回 1。
  88 inline size_t __deque_buf_size(size_t n, size_t sz)
  89 {
  90   return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
  91 }
  92 
  93 #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
  94 template <class T, class Ref, class Ptr, size_t BufSiz>
  95 struct __deque_iterator {     // 未繼承 std::iterator
  96   typedef __deque_iterator<T, T&, T*, BufSiz>      iterator;
  97   typedef __deque_iterator<T, const T&, const T*, BufSiz> const_iterator;
  98   static size_t buffer_size() {return __deque_buf_size(BufSiz, sizeof(T)); }
  99 #else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
 100 template <class T, class Ref, class Ptr>
 101 struct __deque_iterator {     // 未繼承 std::iterator
 102   typedef __deque_iterator<T, T&, T*>             iterator;
 103   typedef __deque_iterator<T, const T&, const T*> const_iterator;
 104   static size_t buffer_size() {return __deque_buf_size(0, sizeof(T)); }
 105 #endif
 106 
 107   // 未繼承 std::iterator,所以必須自行撰寫五個必要的迭代器相應型別
 108   typedef random_access_iterator_tag iterator_category; // (1)
 109   typedef T value_type;                 // (2)
 110   typedef Ptr pointer;                 // (3)
 111   typedef Ref reference;                 // (4)
 112   typedef size_t size_type;
 113   typedef ptrdiff_t difference_type;     // (5)
 114   typedef T** map_pointer;
 115 
 116   typedef __deque_iterator self;
 117 
 118   // 保持與容器的聯結
 119   T* cur;    // 此迭代器所指之緩衝區中的現行(current)元素
 120   T* first;    // 此迭代器所指之緩衝區的頭
 121   T* last;    // 此迭代器所指之緩衝區的尾(含備用空間)
 122   map_pointer node;
 123 
 124   __deque_iterator(T* x, map_pointer y) 
 125     : cur(x), first(*y), last(*y + buffer_size()), node(y) {}
 126   __deque_iterator() : cur(0), first(0), last(0), node(0) {}
 127   __deque_iterator(const iterator& x)
 128     : cur(x.cur), first(x.first), last(x.last), node(x.node) {}
 129 
 130 
 131 // 以下各個多載化運算子是 __deque_iterator<> 成功運作的關鍵。
 132 
 133   reference operator*() const { return *cur; }
 134 #ifndef __SGI_STL_NO_ARROW_OPERATOR
 135   pointer operator->() const { return &(operator*()); }
 136 #endif /* __SGI_STL_NO_ARROW_OPERATOR */
 137 
 138   difference_type operator-(const self& x) const {
 139     return difference_type(buffer_size()) * (node - x.node - 1) +
 140       (cur - first) + (x.last - x.cur);
 141   }
 142   
 143   // 參考 More Effective C++, item6: Distinguish between prefix and
 144   // postfix forms of increment and decrement operators.
 145   self& operator++() {
 146     ++cur;                // 切換至下一個元素。
 147     if (cur == last) {        // 如果已達所在緩衝區的尾端,
 148       set_node(node + 1);    // 就切換至下一個節點(亦即緩衝區)
 149       cur = first;            //   的第一個元素。
 150     }
 151     return *this; 
 152   }
 153   self operator++(int)  {
 154     self tmp = *this;
 155     ++*this;
 156     return tmp;
 157   }
 158   self& operator--() {
 159     if (cur == first) {    // 如果已達所在緩衝區的頭端,
 160       set_node(node - 1);    // 就切換至前一個節點(亦即緩衝區)
 161       cur = last;            //   的最後一個元素。
 162     }
 163     --cur;                // 切換至前一個元素。
 164     return *this;
 165   }
 166   self operator--(int) {
 167     self tmp = *this;
 168     --*this;
 169     return tmp;
 170   }
 171 
 172   self& operator+=(difference_type n) {
 173     difference_type offset = n + (cur - first);
 174     if (offset >= 0 && offset < difference_type(buffer_size()))
 175       // 目標位置在同一緩衝區內
 176       cur += n;
 177     else {
 178       // 目標位置不在同一緩衝區內
 179       difference_type node_offset =
 180         offset > 0 ? offset / difference_type(buffer_size())
 181                    : -difference_type((-offset - 1) / buffer_size()) - 1;
 182       // 切換至正確的節點(亦即緩衝區)
 183       set_node(node + node_offset);
 184       // 切換至正確的元素
 185       cur = first + (offset - node_offset * difference_type(buffer_size()));
 186     }
 187     return *this;
 188   }
 189 
 190   // 參考 More Effective C++, item22: Consider using op= instead of  
 191   // stand-alone op.
 192   self operator+(difference_type n) const {
 193     self tmp = *this;
 194     return tmp += n; // 喚起operator+=
 195   }
 196 
 197   self& operator-=(difference_type n) { return *this += -n; }
 198   // 以上利用operator+= 來完成 operator-=
 199 
 200   // 參考 More Effective C++, item22: Consider using op= instead of  
 201   // stand-alone op.
 202   self operator-(difference_type n) const {
 203     self tmp = *this;
 204     return tmp -= n; // 喚起operator-=
 205   }
 206 
 207   reference operator[](difference_type n) const { return *(*this + n); }
 208   // 以上喚起operator*, operator+
 209 
 210   bool operator==(const self& x) const { return cur == x.cur; }
 211   bool operator!=(const self& x) const { return !(*this == x); }
 212   bool operator<(const self& x) const {
 213     return (node == x.node) ? (cur < x.cur) : (node < x.node);
 214   }
 215 
 216   void set_node(map_pointer new_node) {
 217     node = new_node;
 218     first = *new_node;
 219     last = first + difference_type(buffer_size());
 220   }
 221 };
 222 
 223 #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 224 // 編譯器不支援 partial specialization 時,才需以下定義
 225 #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
 226 
 227 template <class T, class Ref, class Ptr, size_t BufSiz>
 228 inline random_access_iterator_tag
 229 iterator_category(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
 230   return random_access_iterator_tag();
 231 }
 232 
 233 template <class T, class Ref, class Ptr, size_t BufSiz>
 234 inline T* value_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
 235   return 0;
 236 }
 237 
 238 template <class T, class Ref, class Ptr, size_t BufSiz>
 239 inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
 240   return 0;
 241 }
 242 
 243 #else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
 244 
 245 template <class T, class Ref, class Ptr>
 246 inline random_access_iterator_tag
 247 iterator_category(const __deque_iterator<T, Ref, Ptr>&) {
 248   return random_access_iterator_tag();
 249 }
 250 
 251 template <class T, class Ref, class Ptr>
 252 inline T* value_type(const __deque_iterator<T, Ref, Ptr>&) { return 0; }
 253 
 254 template <class T, class Ref, class Ptr>
 255 inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref, Ptr>&) {
 256   return 0;
 257 }
 258 
 259 #endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
 260 // 編譯器不支援 partial specialization 時,才需以上定義
 261 #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 262 
 263 // 見 __deque_buf_size()。BufSize 預設值為 0 的唯一理由是為了閃避某些
 264 //  編譯器在處理常數算式(constant expressions)時的臭蟲。
 265 // 預設使用 alloc 為配置器
 266 template <class T, class Alloc = alloc, size_t BufSiz = 0> 
 267 class deque {
 268 public:                         // Basic types
 269   typedef T value_type;
 270   typedef value_type* pointer;
 271   typedef const value_type* const_pointer;
 272   typedef value_type& reference;
 273   typedef const value_type& const_reference;
 274   typedef size_t size_type;
 275   typedef ptrdiff_t difference_type;
 276 
 277 public:                         // Iterators
 278 #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
 279   typedef __deque_iterator<T, T&, T*, BufSiz>              iterator;
 280   typedef __deque_iterator<T, const T&, const T&, BufSiz>  const_iterator;
 281 #else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
 282   typedef __deque_iterator<T, T&, T*>                      iterator;
 283   typedef __deque_iterator<T, const T&, const T*>          const_iterator;
 284 #endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
 285 
 286 #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
 287   typedef reverse_iterator<const_iterator> const_reverse_iterator;
 288   typedef reverse_iterator<iterator> reverse_iterator;
 289 #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 290   typedef reverse_iterator<const_iterator, value_type, const_reference, 
 291                            difference_type>  
 292           const_reverse_iterator;
 293   typedef reverse_iterator<iterator, value_type, reference, difference_type>
 294           reverse_iterator; 
 295 #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 296 
 297 protected:                      // Internal typedefs
 298   // 元素的指標的指標(pointer of pointer of T)
 299   typedef pointer* map_pointer;    
 300   // 專屬之空間配置器,每次配置一個元素大小
 301   typedef simple_alloc<value_type, Alloc> data_allocator;
 302   // 專屬之空間配置器,每次配置一個指標大小
 303   typedef simple_alloc<pointer, Alloc> map_allocator;
 304 
 305   static size_type buffer_size() {
 306     return __deque_buf_size(BufSiz, sizeof(value_type));
 307   }
 308   static size_type initial_map_size() { return 8; }
 309 
 310 protected:                      // Data members
 311   iterator start;        // 表現第一個節點。
 312   iterator finish;    // 表現最後一個節點。
 313 
 314   map_pointer map;    // 指向map,map是塊連續空間,
 315                           // 其內的每個元素都是一個指標(稱為節點),指向一塊緩衝區。
 316   size_type map_size;    // map內可容納多少指標。
 317 
 318 public:                         // Basic accessors
 319   iterator begin() { return start; }
 320   iterator end() { return finish; }
 321   const_iterator begin() const { return start; }
 322   const_iterator end() const { return finish; }
 323 
 324   reverse_iterator rbegin() { return reverse_iterator(finish); }
 325   reverse_iterator rend() { return reverse_iterator(start); }
 326   const_reverse_iterator rbegin() const {
 327     return const_reverse_iterator(finish);
 328   }
 329   const_reverse_iterator rend() const {
 330     return const_reverse_iterator(start);
 331   }
 332 
 333   reference operator[](size_type n) {
 334     return start[difference_type(n)]; // 喚起 __deque_iterator<>::operator[]
 335   }
 336   const_reference operator[](size_type n) const {
 337     return start[difference_type(n)];
 338   }
 339 
 340   reference front() { return *start; } // 喚起 __deque_iterator<>::operator*
 341   reference back() {
 342     iterator tmp = finish;    
 343     --tmp;    // 喚起 __deque_iterator<>::operator--
 344     return *tmp;     // 喚起 __deque_iterator<>::operator*
 345     // 以上三行何不改為:return *(finish-1);
 346     // 因為 __deque_iterator<> 沒有為 (finish-1) 定義運算子。待查!
 347   }
 348   const_reference front() const { return *start; }
 349   const_reference back() const {
 350     const_iterator tmp = finish;
 351     --tmp;
 352     return *tmp;
 353   }
 354 
 355   // 下行最後有兩個 ‘;’,雖奇怪但合乎語法。
 356   size_type size() const { return finish - start;; } 
 357   // 以上喚起iterator::operator-
 358   size_type max_size() const { return size_type(-1); }
 359   bool empty() const { return finish == start; }
 360 
 361 public:                         // Constructor, destructor.
 362   deque()
 363     : start(), finish(), map(0), map_size(0)
 364     // 以上 start() 和 finish() 喚起 iterator(亦即 __deque_iterator)
 365     // 的 default ctor,於是令其 cur, first, last, node 皆為0。
 366   {
 367     create_map_and_nodes(0);
 368   }
 369 
 370   deque(const deque& x)
 371     : start(), finish(), map(0), map_size(0)
 372   {
 373     create_map_and_nodes(x.size());
 374     __STL_TRY {
 375       uninitialized_copy(x.begin(), x.end(), start);
 376     }
 377     __STL_UNWIND(destroy_map_and_nodes());
 378   }
 379 
 380   deque(size_type n, const value_type& value)
 381     : start(), finish(), map(0), map_size(0)
 382   {
 383     fill_initialize(n, value);
 384   }
 385 
 386   deque(int n, const value_type& value)
 387     : start(), finish(), map(0), map_size(0)
 388   {
 389     fill_initialize(n, value);
 390   }
 391  
 392   deque(long n, const value_type& value)
 393     : start(), finish(), map(0), map_size(0)
 394   {
 395     fill_initialize(n, value);
 396   }
 397 
 398   explicit deque(size_type n)
 399     : start(), finish(), map(0), map_size(0)
 400   {
 401     fill_initialize(n, value_type());
 402   }
 403 
 404 #ifdef __STL_MEMBER_TEMPLATES
 405 
 406   template <class InputIterator>
 407   deque(InputIterator first, InputIterator last)
 408     : start(), finish(), map(0), map_size(0)
 409   {
 410     range_initialize(first, last, iterator_category(first));
 411   }
 412 
 413 #else /* __STL_MEMBER_TEMPLATES */
 414 
 415   deque(const value_type* first, const value_type* last)
 416     : start(), finish(), map(0), map_size(0)
 417   {
 418     create_map_and_nodes(last - first);
 419     __STL_TRY {
 420       uninitialized_copy(first, last, start);
 421     }
 422     __STL_UNWIND(destroy_map_and_nodes());
 423   }
 424 
 425   deque(const_iterator first, const_iterator last)
 426     : start(), finish(), map(0), map_size(0)
 427   {
 428     create_map_and_nodes(last - first);
 429     __STL_TRY {
 430       uninitialized_copy(first, last, start);
 431     }
 432     __STL_UNWIND(destroy_map_and_nodes());
 433   }
 434 
 435 #endif /* __STL_MEMBER_TEMPLATES */
 436 
 437   ~deque() {
 438     destroy(start, finish);
 439     destroy_map_and_nodes();
 440   }
 441 
 442   deque& operator= (const deque& x) {
 443     const size_type len = size();
 444     if (&x != this) {
 445       if (len >= x.size())
 446         erase(copy(x.begin(), x.end(), start), finish);
 447       else {
 448         const_iterator mid = x.begin() + difference_type(len);
 449         copy(x.begin(), mid, start);
 450         insert(finish, mid, x.end());
 451       }
 452     }
 453     return *this;
 454   }        
 455 
 456   void swap(deque& x) {
 457     __STD::swap(start, x.start);
 458     __STD::swap(finish, x.finish);
 459     __STD::swap(map, x.map);
 460     __STD::swap(map_size, x.map_size);
 461   }
 462 
 463 public:                         // push_* and pop_*
 464   
 465   void push_back(const value_type& t) {
 466     if (finish.cur != finish.last - 1) { 
 467       // 最後緩衝區尚有一個以上的備用空間
 468       construct(finish.cur, t);    // 直接在備用空間上建構元素
 469       ++finish.cur;    // 調整最後緩衝區的使用狀態
 470     }
 471     else  // 最後緩衝區已無(或只剩一個)元素備用空間。
 472       push_back_aux(t);
 473   }
 474 
 475   void push_front(const value_type& t) {
 476     if (start.cur != start.first) {     // 第一緩衝區尚有備用空間
 477       construct(start.cur - 1, t);     // 直接在備用空間上建構元素
 478       --start.cur;        // 調整第一緩衝區的使用狀態
 479     }
 480     else // 第一緩衝區已無備用空間
 481       push_front_aux(t);
 482   }
 483 
 484   void pop_back() {
 485     if (finish.cur != finish.first) {
 486       // 最後緩衝區有一個(或更多)元素
 487 
 488       --finish.cur;        // 調整指標,相當於排除了最後元素
 489       destroy(finish.cur);    // 將最後元素解構
 490     }
 491     else
 492       // 最後緩衝區沒有任何元素
 493       pop_back_aux();        // 這裡將進行緩衝區的釋放工作
 494   }
 495 
 496   void pop_front() {
 497     if (start.cur != start.last - 1) {
 498       // 第一緩衝區有一個(或更多)元素
 499       destroy(start.cur);    // 將第一元素解構
 500       ++start.cur;            // 調整指標,相當於排除了第一元素
 501     }
 502     else 
 503       // 第一緩衝區僅有一個元素
 504       pop_front_aux();        // 這裡將進行緩衝區的釋放工作
 505   }
 506 
 507 public:                         // Insert
 508 
 509   // 在position 處安插一個元素,其值為 x
 510   iterator insert(iterator position, const value_type& x) {
 511     if (position.cur == start.cur) {    // 如果安插點是deque 最前端
 512       push_front(x);                // 交給push_front 去做
 513       return start;
 514     }
 515     else if (position.cur == finish.cur) { // 如果安插點是deque 最尾端
 516       push_back(x);                      // 交給push_back 去做
 517       iterator tmp = finish;
 518       --tmp;
 519       return tmp;
 520     }
 521     else {
 522       return insert_aux(position, x);         // 交給 insert_aux 去做
 523     }
 524   }
 525 
 526   iterator insert(iterator position) { return insert(position, value_type()); }
 527 
 528   void insert(iterator pos, size_type n, const value_type& x); 
 529 
 530   void insert(iterator pos, int n, const value_type& x) {
 531     insert(pos, (size_type) n, x);
 532   }
 533   void insert(iterator pos, long n, const value_type& x) {
 534     insert(pos, (size_type) n, x);
 535   }
 536 
 537 #ifdef __STL_MEMBER_TEMPLATES  
 538 
 539   template <class InputIterator>
 540   void insert(iterator pos, InputIterator first, InputIterator last) {
 541     insert(pos, first, last, iterator_category(first));
 542   }
 543 
 544 #else /* __STL_MEMBER_TEMPLATES */
 545 
 546   void insert(iterator pos, const value_type* first, const value_type* last);
 547   void insert(iterator pos, const_iterator first, const_iterator last);
 548 
 549 #endif /* __STL_MEMBER_TEMPLATES */
 550 
 551   void resize(size_type new_size, const value_type& x) {
 552     const size_type len = size();
 553     if (new_size < len) 
 554       erase(start + new_size, finish);
 555     else
 556       insert(finish, new_size - len, x);
 557   }
 558 
 559   void resize(size_type new_size) { resize(new_size, value_type()); }
 560 
 561 public:                         // Erase
 562   // 清除 pos 所指的元素。pos 為清除點。
 563   iterator erase(iterator pos) {
 564     iterator next = pos;
 565     ++next;
 566     difference_type index = pos - start;    // 清除點之前的元素個數
 567     if (index < (size() >> 1)) {            // 如果清除點之前的元素比較少,
 568       copy_backward(start, pos, next);    // 就搬移清除點之前的元素
 569       pop_front();                // 搬移完畢,最前一個元素贅餘,去除之
 570     }
 571     else {                    // 清除點之後的元素比較少,
 572       copy(next, finish, pos);    // 就搬移清除點之後的元素
 573       pop_back();                // 搬移完畢,最後一個元素贅餘,去除之
 574     }
 575     return start + index;
 576   }
 577 
 578   iterator erase(iterator first, iterator last);
 579   void clear(); 
 580 
 581 protected:                        // Internal construction/destruction
 582 
 583   void create_map_and_nodes(size_type num_elements);
 584   void destroy_map_and_nodes();
 585   void fill_initialize(size_type n, const value_type& value);
 586 
 587 #ifdef __STL_MEMBER_TEMPLATES  
 588 
 589   template <class InputIterator>
 590   void range_initialize(InputIterator first, InputIterator last,
 591                         input_iterator_tag);
 592 
 593   template <class ForwardIterator>
 594   void range_initialize(ForwardIterator first, ForwardIterator last,
 595                         forward_iterator_tag);
 596 
 597 #endif /* __STL_MEMBER_TEMPLATES */
 598 
 599 protected:                        // Internal push_* and pop_*
 600 
 601   void push_back_aux(const value_type& t);
 602   void push_front_aux(const value_type& t);
 603   void pop_back_aux();
 604   void pop_front_aux();
 605 
 606 protected:                        // Internal insert functions
 607 
 608 #ifdef __STL_MEMBER_TEMPLATES  
 609 
 610   template <class InputIterator>
 611   void insert(iterator pos, InputIterator first, InputIterator last,
 612               input_iterator_tag);
 613 
 614   template <class ForwardIterator>
 615   void insert(iterator pos, ForwardIterator first, ForwardIterator last,
 616               forward_iterator_tag);
 617 
 618 #endif /* __STL_MEMBER_TEMPLATES */
 619 
 620   iterator insert_aux(iterator pos, const value_type& x);
 621   void insert_aux(iterator pos, size_type n, const value_type& x);
 622 
 623 #ifdef __STL_MEMBER_TEMPLATES  
 624 
 625   template <class ForwardIterator>
 626   void insert_aux(iterator pos, ForwardIterator first, ForwardIterator last,
 627                   size_type n);
 628 
 629 #else /* __STL_MEMBER_TEMPLATES */
 630   
 631   void insert_aux(iterator pos,
 632                   const value_type* first, const value_type* last,
 633                   size_type n);
 634 
 635   void insert_aux(iterator pos, const_iterator first, const_iterator last,
 636                   size_type n);
 637  
 638 #endif /* __STL_MEMBER_TEMPLATES */
 639 
 640   iterator reserve_elements_at_front(size_type n) {
 641     size_type vacancies = start.cur - start.first;
 642     if (n > vacancies) 
 643       new_elements_at_front(n - vacancies);
 644     return start - difference_type(n);
 645   }
 646 
 647   iterator reserve_elements_at_back(size_type n) {
 648     size_type vacancies = (finish.last - finish.cur) - 1;
 649     if (n > vacancies)
 650       new_elements_at_back(n - vacancies);
 651     return finish + difference_type(n);
 652   }
 653 
 654   void new_elements_at_front(size_type new_elements);
 655   void new_elements_at_back(size_type new_elements);
 656 
 657   void destroy_nodes_at_front(iterator before_start);
 658   void destroy_nodes_at_back(iterator after_finish);
 659 
 660 protected:                      // Allocation of map and nodes
 661 
 662   // Makes sure the map has space for new nodes.  Does not actually
 663   //  add the nodes.  Can invalidate map pointers.  (And consequently, 
 664   //  deque iterators.)
 665 
 666   void reserve_map_at_back (size_type nodes_to_add = 1) {
 667     if (nodes_to_add + 1 > map_size - (finish.node - map))
 668       // 如果 map 尾端的節點備用空間不足
 669       // 符合以上條件則必須重換一個map(配置更大的,拷貝原來的,釋放原來的)
 670       reallocate_map(nodes_to_add, false); 
 671   }
 672 
 673   void reserve_map_at_front (size_type nodes_to_add = 1) {
 674     if (nodes_to_add > start.node - map)
 675       // 如果 map 前端的節點備用空間不足
 676       // 符合以上條件則必須重換一個map(配置更大的,拷貝原來的,釋放原來的)
 677       reallocate_map(nodes_to_add, true);    
 678   }
 679 
 680   void reallocate_map(size_type nodes_to_add, bool add_at_front);
 681 
 682   pointer allocate_node() { return data_allocator::allocate(buffer_size()); }
 683   void deallocate_node(pointer n) {
 684     data_allocator::deallocate(n, buffer_size());
 685   }
 686 
 687 #ifdef __STL_NON_TYPE_TMPL_PARAM_BUG
 688 public:
 689   bool operator==(const deque<T, Alloc, 0>& x) const {
 690     return size() == x.size() && equal(begin(), end(), x.begin());
 691   }
 692   bool operator!=(const deque<T, Alloc, 0>& x) const {
 693     return size() != x.size() || !equal(begin(), end(), x.begin());
 694   }
 695   bool operator<(const deque<T, Alloc, 0>& x) const {
 696     return lexicographical_compare(begin(), end(), x.begin(), x.end());
 697   }
 698 #endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
 699 };
 700 
 701 // Non-inline member functions
 702 
 703 template <class T, class Alloc, size_t BufSize>
 704 void deque<T, Alloc, BufSize>::insert(iterator pos,
 705                                       size_type n, const value_type& x) {
 706   if (pos.cur == start.cur) {
 707     iterator new_start = reserve_elements_at_front(n);
 708     uninitialized_fill(new_start, start, x);
 709     start = new_start;
 710   }
 711   else if (pos.cur == finish.cur) {
 712     iterator new_finish = reserve_elements_at_back(n);
 713     uninitialized_fill(finish, new_finish, x);
 714     finish = new_finish;
 715   }
 716   else 
 717     insert_aux(pos, n, x);
 718 }
 719 
 720 #ifndef __STL_MEMBER_TEMPLATES  
 721 
 722 template <class T, class Alloc, size_t BufSize>
 723 void deque<T, Alloc, BufSize>::insert(iterator pos,
 724                                       const value_type* first,
 725                                       const value_type* last) {
 726   size_type n = last - first;
 727   if (pos.cur == start.cur) {
 728     iterator new_start = reserve_elements_at_front(n);
 729     __STL_TRY {
 730       uninitialized_copy(first, last, new_start);
 731       start = new_start;
 732     }
 733     __STL_UNWIND(destroy_nodes_at_front(new_start));
 734   }
 735   else if (pos.cur == finish.cur) {
 736     iterator new_finish = reserve_elements_at_back(n);
 737     __STL_TRY {
 738       uninitialized_copy(first, last, finish);
 739       finish = new_finish;
 740     }
 741     __STL_UNWIND(destroy_nodes_at_back(new_finish));
 742   }
 743   else
 744     insert_aux(pos, first, last, n);
 745 }
 746 
 747 template <class T, class Alloc, size_t BufSize>
 748 void deque<T, Alloc, BufSize>::insert(iterator pos,
 749                                       const_iterator first,
 750                                       const_iterator last)
 751 {
 752   size_type n = last - first;
 753   if (pos.cur == start.cur) {
 754     iterator new_start = reserve_elements_at_front(n);
 755     __STL_TRY {
 756       uninitialized_copy(first, last, new_start);
 757       start = new_start;
 758     }
 759     __STL_UNWIND(destroy_nodes_at_front(new_start));
 760   }
 761   else if (pos.cur == finish.cur) {
 762     iterator new_finish = reserve_elements_at_back(n);
 763     __STL_TRY {
 764       uninitialized_copy(first, last, finish);
 765       finish = new_finish;
 766     }
 767     __STL_UNWIND(destroy_nodes_at_back(new_finish));
 768   }
 769   else
 770     insert_aux(pos, first, last, n);
 771 }
 772 
 773 #endif /* __STL_MEMBER_TEMPLATES */
 774 
 775 template <class T, class Alloc, size_t BufSize>
 776 deque<T, Alloc, BufSize>::iterator 
 777 deque<T, Alloc, BufSize>::erase(iterator first, iterator last) {
 778   if (first == start && last == finish) { // 如果清除區間就是整個 deque
 779     clear();                            // 直接呼叫 clear() 即可
 780     return finish;
 781   }
 782   else {
 783     difference_type n = last - first;            // 清除區間的長度
 784     difference_type elems_before = first - start;    // 清除區間前方的元素個數
 785     if (elems_before < (size() - n) / 2) {        // 如果前方的元素比較少,
 786       copy_backward(start, first, last);        // 向後搬移前方元素(覆蓋清除區間)
 787       iterator new_start = start + n;            // 標記 deque 的新起點
 788       destroy(start, new_start);                // 搬移完畢,將贅餘的元素解構
 789       // 以下將贅餘的緩衝區釋放
 790       for (map_pointer cur = start.node; cur < new_start.node; ++cur)
 791         data_allocator::deallocate(*cur, buffer_size());
 792       start = new_start;    // 設定 deque 的新起點
 793     }
 794     else {    // 如果清除區間後方的元素比較少
 795       copy(last, finish, first);            // 向前搬移後方元素(覆蓋清除區間)
 796       iterator new_finish = finish - n;    // 標記 deque 的新尾點
 797       destroy(new_finish, finish);        // 搬移完畢,將贅餘的元素解構
 798       // 以下將贅餘的緩衝區釋放
 799       for (map_pointer cur = new_finish.node + 1; cur <= finish.node; ++cur)
 800         data_allocator::deallocate(*cur, buffer_size());
 801       finish = new_finish;    // 設定 deque 的新尾點
 802     }
 803     return start + elems_before;
 804   }
 805 }
 806 
 807 // 注意,最終需要保留一個緩衝區。這是deque 的策略,也是deque 的初始狀態。
 808 template <class T, class Alloc, size_t BufSize>
 809 void deque<T, Alloc, BufSize>::clear() {
 810   // 以下針對頭尾以外的每一個緩衝區(它們一定都是飽滿的)
 811   for (map_pointer node = start.node + 1; node < finish.node; ++node) {
 812     // 將緩衝區內的所有元素解構。注意,呼叫的是destroy() 第二版本,見2.2.3節
 813     destroy(*node, *node + buffer_size());
 814     // 釋放緩衝區記憶體
 815     data_allocator::deallocate(*node, buffer_size());
 816   }
 817 
 818   if (start.node != finish.node) {    // 至少有頭尾兩個緩衝區
 819     destroy(start.cur, start.last);    // 將頭緩衝區的目前所有元素解構
 820     destroy(finish.first, finish.cur); // 將尾緩衝區的目前所有元素解構
 821     // 以下釋放尾緩衝區。注意,頭緩衝區保留。
 822     data_allocator::deallocate(finish.first, buffer_size());
 823   }
 824   else    // 只有一個緩衝區
 825     destroy(start.cur, finish.cur);    // 將此唯一緩衝區內的所有元素解構
 826     // 注意,並不釋放緩衝區空間。這唯一的緩衝區將保留。
 827 
 828   finish = start;    // 調整狀態
 829 }
 830 
 831 template <class T, class Alloc, size_t BufSize>
 832 void deque<T, Alloc, BufSize>::create_map_and_nodes(size_type num_elements) {
 833   // 需要節點數=(元素個數/每個緩衝區可容納的元素個數)+1
 834   // 如果剛好整除,會多配一個節點。
 835   size_type num_nodes = num_elements / buffer_size() + 1;
 836 
 837   // 一個 map 要管理幾個節點。最少8個,最多是 “所需節點數加2”
 838   // (前後各預留一個,擴充時可用)。
 839   map_size = max(initial_map_size(), num_nodes + 2);
 840   map = map_allocator::allocate(map_size);
 841   // 以上配置出一個 “具有 map_size個節點” 的map。
 842 
 843   // 以下令nstart和nfinish指向map所擁有之全部節點的最中央區段。
 844   // 保持在最中央,可使頭尾兩端的擴充能量一樣大。每個節點可對應一個緩衝區。
 845   map_pointer nstart = map + (map_size - num_nodes) / 2;
 846   map_pointer nfinish = nstart + num_nodes - 1;
 847     
 848   map_pointer cur;
 849   __STL_TRY {
 850     // 為map內的每個現用節點配置緩衝區。所有緩衝區加起來就是deque的空間
 851    // (最後一個緩衝區可能留有一些餘裕)。
 852     for (cur = nstart; cur <= nfinish; ++cur)
 853       *cur = allocate_node();
 854   }
 855 #     ifdef  __STL_USE_EXCEPTIONS 
 856   catch(...) {
 857     // "commit or rollback" 語意:若非全部成功,就一個不留。
 858     for (map_pointer n = nstart; n < cur; ++n)
 859       deallocate_node(*n);
 860     map_allocator::deallocate(map, map_size);
 861     throw;
 862   }
 863 #     endif /* __STL_USE_EXCEPTIONS */
 864 
 865   // 為deque內的兩個迭代器start和end 設定正確的內容。
 866   start.set_node(nstart);
 867   finish.set_node(nfinish);
 868   start.cur = start.first;        // first, cur都是public
 869   finish.cur = finish.first + num_elements % buffer_size();
 870   // 前面說過,如果剛好整除,會多配一個節點。
 871   // 此時即令cur指向這多配的一個節點(所對映之緩衝區)的起頭處。
 872 }
 873 
 874 // This is only used as a cleanup function in catch clauses.
 875 template <class T, class Alloc, size_t BufSize>
 876 void deque<T, Alloc, BufSize>::destroy_map_and_nodes() {
 877   for (map_pointer cur = start.node; cur <= finish.node; ++cur)
 878     deallocate_node(*cur);
 879   map_allocator::deallocate(map, map_size);
 880 }
 881   
 882 
 883 template <class T, class Alloc, size_t BufSize>
 884 void deque<T, Alloc, BufSize>::fill_initialize(size_type n,
 885                                                const value_type& value) {
 886   create_map_and_nodes(n);     // 把deque的結構都產生並安排好
 887   map_pointer cur;
 888   __STL_TRY {
 889     // 為每個節點的緩衝區設定初值
 890     for (cur = start.node; cur < finish.node; ++cur)
 891       uninitialized_fill(*cur, *cur + buffer_size(), value);
 892     // 最後一個節點的設定稍有不同(因為尾端可能有備用空間,不必設初值)
 893     uninitialized_fill(finish.first, finish.cur, value);
 894   }
 895 #       ifdef __STL_USE_EXCEPTIONS
 896   catch(...) {
 897     // "commit or rollback" 語意:若非全部成功,就一個不留。
 898     for (map_pointer n = start.node; n < cur; ++n)
 899       destroy(*n, *n + buffer_size());
 900     destroy_map_and_nodes();
 901     throw;
 902   }
 903 #       endif /* __STL_USE_EXCEPTIONS */
 904 }
 905 
 906 #ifdef __STL_MEMBER_TEMPLATES  
 907 
 908 template <class T, class Alloc, size_t BufSize>
 909 template <class InputIterator>
 910 void deque<T, Alloc, BufSize>::range_initialize(InputIterator first,
 911                                                 InputIterator last,
 912                                                 input_iterator_tag) {
 913   create_map_and_nodes(0);
 914   for ( ; first != last; ++first)
 915     push_back(*first);
 916 }
 917 
 918 template <class T, class Alloc, size_t BufSize>
 919 template <class ForwardIterator>
 920 void deque<T, Alloc, BufSize>::range_initialize(ForwardIterator first,
 921                                                 ForwardIterator last,
 922                                                 forward_iterator_tag) {
 923   size_type n = 0;
 924   distance(first, last, n);
 925   create_map_and_nodes(n);
 926   __STL_TRY {
 927     uninitialized_copy(first, last, start);
 928   }
 929   __STL_UNWIND(destroy_map_and_nodes());
 930 }
 931 
 932 #endif /* __STL_MEMBER_TEMPLATES */
 933 
 934 // 只有當 finish.cur == finish.last – 1 時才會被呼叫。
 935 // 也就是說只有當最後一個緩衝區只剩一個備用元素空間時才會被呼叫。
 936 template <class T, class Alloc, size_t BufSize>
 937 void deque<T, Alloc, BufSize>::push_back_aux(const value_type& t) {
 938   value_type t_copy = t;
 939   reserve_map_at_back();        //  若符合某種條件則必須重換一個map
 940   *(finish.node + 1) = allocate_node();    // 配置一個新節點(緩衝區)
 941   __STL_TRY {
 942     construct(finish.cur, t_copy);        // 針對標的元素設值
 943     finish.set_node(finish.node + 1);    // 改變finish,令其指向新節點
 944     finish.cur = finish.first;            // 設定 finish 的狀態
 945   }
 946   __STL_UNWIND(deallocate_node(*(finish.node + 1)));
 947 }
 948 
 949 // 只有當start.cur == start.first時才會被呼叫。
 950 // 也就是說只有當第一個緩衝區沒有任何備用元素時才會被呼叫。
 951 template <class T, class Alloc, size_t BufSize>
 952 void deque<T, Alloc, BufSize>::push_front_aux(const value_type& t) {
 953   value_type t_copy = t;
 954   reserve_map_at_front();        //  若符合某種條件則必須重換一個map
 955   *(start.node - 1) = allocate_node();    // 配置一個新節點(緩衝區)
 956   __STL_TRY {
 957     start.set_node(start.node - 1);        // 改變start,令其指向新節點
 958     start.cur = start.last - 1;            // 設定 start的狀態
 959     construct(start.cur, t_copy);        // 針對標的元素設值
 960   }
 961 #     ifdef __STL_USE_EXCEPTIONS
 962   catch(...) {
 963     // "commit or rollback" 語意:若非全部成功,就一個不留。
 964     start.set_node(start.node + 1);
 965     start.cur = start.first;
 966     deallocate_node(*(start.node - 1));
 967     throw;
 968   }
 969 #     endif /* __STL_USE_EXCEPTIONS */
 970 } 
 971 
 972 // 只有當finish.cur == finish.first時才會被呼叫。
 973 template <class T, class Alloc, size_t BufSize>
 974 void deque<T, Alloc, BufSize>::pop_back_aux() {
 975   deallocate_node(finish.first);    // 釋放最後一個緩衝區
 976   finish.set_node(finish.node - 1);    // 調整 finish 的狀態,使指向
 977   finish.cur = finish.last - 1;        //  上一個緩衝區的最後一個元素
 978   destroy(finish.cur);                // 將該元素解構。
 979 }
 980 
 981 // 只有當start.cur == start.last - 1時才會被呼叫。
 982 template <class T, class Alloc, size_t BufSize>
 983 void deque<T, Alloc, BufSize>::pop_front_aux() {
 984   destroy(start.cur);                // 將第一緩衝區的第一個元素解構。
 985   deallocate_node(start.first);        // 釋放第一緩衝區。
 986   start.set_node(start.node + 1);    // 調整 start 的狀態,使指向
 987   start.cur = start.first;            //  下一個緩衝區的第一個元素。
 988 }      
 989 
 990 #ifdef __STL_MEMBER_TEMPLATES  
 991 
 992 template <class T, class Alloc, size_t BufSize>
 993 template <class InputIterator>
 994 void deque<T, Alloc, BufSize>::insert(iterator pos,
 995                                       InputIterator first, InputIterator last,
 996                                       input_iterator_tag) {
 997   copy(first, last, inserter(*this, pos));
 998 }
 999 
1000 template <class T, class Alloc, size_t BufSize>
1001 template <class ForwardIterator>
1002 void deque<T, Alloc, BufSize>::insert(iterator pos,
1003                                       ForwardIterator first,
1004                                       ForwardIterator last,
1005                                       forward_iterator_tag) {
1006   size_type n = 0;
1007   distance(first, last, n);
1008   if (pos.cur == start.cur) {
1009     iterator new_start = reserve_elements_at_front(n);
1010     __STL_TRY {
1011       uninitialized_copy(first, last, new_start);
1012       start = new_start;
1013     }
1014     __STL_UNWIND(destroy_nodes_at_front(new_start));
1015   }
1016   else if (pos.cur == finish.cur) {
1017     iterator new_finish = reserve_elements_at_back(n);
1018     __STL_TRY {
1019       uninitialized_copy(first, last, finish);
1020       finish = new_finish;
1021     }
1022     __STL_UNWIND(destroy_nodes_at_back(new_finish));
1023   }
1024   else
1025     insert_aux(pos, first, last, n);
1026 }
1027 
1028 #endif /* __STL_MEMBER_TEMPLATES */
1029 
1030 template <class T, class Alloc, size_t BufSize>
1031 typename deque<T, Alloc, BufSize>::iterator
1032 deque<T, Alloc, BufSize>::insert_aux(iterator pos, const value_type& x) {
1033   difference_type index = pos - start;    // 安插點之前的元素個數
1034   value_type x_copy = x;
1035   if (index < size() / 2) {            // 如果安插點之前的元素個數比較少
1036     push_front(front());            // 在最前端加入與第一元素同值的元素。
1037     iterator front1 = start;        // 以下標示記號,然後進行元素搬移...
1038     ++front1;
1039     iterator front2 = front1;
1040     ++front2;
1041     pos = start + index;
1042     iterator pos1 = pos;
1043     ++pos1;
1044     copy(front2, pos1, front1);        // 元素搬移
1045   }
1046   else {                        // 安插點之後的元素個數比較少
1047     push_back(back());            // 在最尾端加入與最後元素同值的元素。
1048     iterator back1 = finish;    // 以下標示記號,然後進行元素搬移...
1049     --back1;
1050     iterator back2 = back1;
1051     --back2;
1052     pos = start + index;
1053     copy_backward(pos, back2, back1);    // 元素搬移
1054   }
1055   *pos = x_copy;    // 在安插點上設定新值
1056   return pos;
1057 }
1058 
1059 template <class T, class Alloc, size_t BufSize>
1060 void deque<T, Alloc, BufSize>::insert_aux(iterator pos,
1061                                           size_type n, const value_type& x) {
1062   const difference_type elems_before = pos - start;
1063   size_type length = size();
1064   value_type x_copy = x;
1065   if (elems_before < length / 2) {
1066     iterator new_start = reserve_elements_at_front(n);
1067     iterator old_start = start;
1068     pos = start + elems_before;
1069     __STL_TRY {
1070       if (elems_before >= difference_type(n)) {
1071         iterator start_n = start + difference_type(n);
1072         uninitialized_copy(start, start_n, new_start);
1073         start = new_start;
1074         copy(start_n, pos, old_start);
1075         fill(pos - difference_type(n), pos, x_copy);
1076       }
1077       else {
1078         __uninitialized_copy_fill(start, pos, new_start, start, x_copy);
1079         start = new_start;
1080         fill(old_start, pos, x_copy);
1081       }
1082     }
1083     __STL_UNWIND(destroy_nodes_at_front(new_start));
1084   }
1085   else {
1086     iterator new_finish = reserve_elements_at_back(n);
1087     iterator old_finish = finish;
1088     const difference_type elems_after = difference_type(length) - elems_before;
1089     pos = finish - elems_after;
1090     __STL_TRY {
1091       if (elems_after > difference_type(n)) {
1092         iterator finish_n = finish - difference_type(n);
1093         uninitialized_copy(finish_n, finish, finish);
1094         finish = new_finish;
1095         copy_backward(pos, finish_n, old_finish);
1096         fill(pos, pos + difference_type(n), x_copy);
1097       }
1098       else {
1099         __uninitialized_fill_copy(finish, pos + difference_type(n),
1100                                   x_copy,
1101                                   pos, finish);
1102         finish = new_finish;
1103         fill(pos, old_finish, x_copy);
1104       }
1105     }
1106     __STL_UNWIND(destroy_nodes_at_back(new_finish));
1107   }
1108 }
1109 
1110 #ifdef __STL_MEMBER_TEMPLATES  
1111 
1112 template <class T, class Alloc, size_t BufSize>
1113 template <class ForwardIterator>
1114 void deque<T, Alloc, BufSize>::insert_aux(iterator pos,
1115                                           ForwardIterator first,
1116                                           ForwardIterator last,
1117                                           size_type n)
1118 {
1119   const difference_type elems_before = pos - start;
1120   size_type length = size();
1121   if (elems_before < length / 2) {
1122     iterator new_start = reserve_elements_at_front(n);
1123     iterator old_start = start;
1124     pos = start + elems_before;
1125     __STL_TRY {
1126       if (elems_before >= difference_type(n)) {
1127         iterator start_n = start + difference_type(n); 
1128         uninitialized_copy(start, start_n, new_start);
1129         start = new_start;
1130         copy(start_n, pos, old_start);
1131         copy(first, last, pos - difference_type(n));
1132       }
1133       else {
1134         ForwardIterator mid = first;
1135         advance(mid, difference_type(n) - elems_before);
1136         __uninitialized_copy_copy(start, pos, first, mid, new_start);
1137         start = new_start;
1138         copy(mid, last, old_start);
1139       }
1140     }
1141     __STL_UNWIND(destroy_nodes_at_front(new_start));
1142   }
1143   else {
1144     iterator new_finish = reserve_elements_at_back(n);
1145     iterator old_finish = finish;
1146     const difference_type elems_after = difference_type(length) - elems_before;
1147     pos = finish - elems_after;
1148     __STL_TRY {
1149       if (elems_after > difference_type(n)) {
1150         iterator finish_n = finish - difference_type(n);
1151         uninitialized_copy(finish_n, finish, finish);
1152         finish = new_finish;
1153         copy_backward(pos, finish_n, old_finish);
1154         copy(first, last, pos);
1155       }
1156       else {
1157         ForwardIterator mid = first;
1158         advance(mid, elems_after);
1159         __uninitialized_copy_copy(mid, last, pos, finish, finish);
1160         finish = new_finish;
1161         copy(first, mid, pos);
1162       }
1163     }
1164     __STL_UNWIND(destroy_nodes_at_back(new_finish));
1165   }
1166 }
1167 
1168 #else /* __STL_MEMBER_TEMPLATES */
1169 
1170 template <class T, class Alloc, size_t BufSize>
1171 void deque<T, Alloc, BufSize>::insert_aux(iterator pos,
1172                                           const value_type* first,
1173                                           const value_type* last,
1174                                           size_type n)
1175 {
1176   const difference_type elems_before = pos - start;
1177   size_type length = size();
1178   if (elems_before < length / 2) {
1179     iterator new_start = reserve_elements_at_front(n);
1180     iterator old_start = start;
1181     pos = start + elems_before;
1182     __STL_TRY {
1183       if (elems_before >= difference_type(n)) {
1184         iterator start_n = start + difference_type(n);
1185         uninitialized_copy(start, start_n, new_start);
1186         start = new_start;
1187         copy(start_n, pos, old_start);
1188         copy(first, last, pos - difference_type(n));
1189       }
1190       else {
1191         const value_type* mid = first + (difference_type(n) - elems_before);
1192         __uninitialized_copy_copy(start, pos, first, mid, new_start);
1193         start = new_start;
1194         copy(mid, last, old_start);
1195       }
1196     }
1197     __STL_UNWIND(destroy_nodes_at_front(new_start));
1198   }
1199   else {
1200     iterator new_finish = reserve_elements_at_back(n);
1201     iterator old_finish = finish;
1202     const difference_type elems_after = difference_type(length) - elems_before;
1203     pos = finish - elems_after;
1204     __STL_TRY {
1205       if (elems_after > difference_type(n)) {
1206         iterator finish_n = finish - difference_type(n);
1207         uninitialized_copy(finish_n, finish, finish);
1208         finish = new_finish;
1209         copy_backward(pos, finish_n, old_finish);
1210         copy(first, last, pos);
1211       }
1212       else {
1213         const value_type* mid = first + elems_after;
1214         __uninitialized_copy_copy(mid, last, pos, finish, finish);
1215         finish = new_finish;
1216         copy(first, mid, pos);
1217       }
1218     }
1219     __STL_UNWIND(destroy_nodes_at_back(new_finish));
1220   }
1221 }
1222 
1223 template <class T, class Alloc, size_t BufSize>
1224 void deque<T, Alloc, BufSize>::insert_aux(iterator pos,
1225                                           const_iterator first,
1226                                           const_iterator last,
1227                                           size_type n)
1228 {
1229   const difference_type elems_before = pos - start;
1230   size_type length = size();
1231   if (elems_before < length / 2) {
1232     iterator new_start = reserve_elements_at_front(n);
1233     iterator old_start = start;
1234     pos = start + elems_before;
1235     __STL_TRY {
1236       if (elems_before >= n) {
1237         iterator start_n = start + n;
1238         uninitialized_copy(start, start_n, new_start);
1239         start = new_start;
1240         copy(start_n, pos, old_start);
1241         copy(first, last, pos - difference_type(n));
1242       }
1243       else {
1244         const_iterator mid = first + (n - elems_before);
1245         __uninitialized_copy_copy(start, pos, first, mid, new_start);
1246         start = new_start;
1247         copy(mid, last, old_start);
1248       }
1249     }
1250     __STL_UNWIND(destroy_nodes_at_front(new_start));
1251   }
1252   else {
1253     iterator new_finish = reserve_elements_at_back(n);
1254     iterator old_finish = finish;
1255     const difference_type elems_after = length - elems_before;
1256     pos = finish - elems_after;
1257     __STL_TRY {
1258       if (elems_after > n) {
1259         iterator finish_n = finish - difference_type(n);
1260         uninitialized_copy(finish_n, finish, finish);
1261         finish = new_finish;
1262         copy_backward(pos, finish_n, old_finish);
1263         copy(first, last, pos);
1264       }
1265       else {
1266         const_iterator mid = first + elems_after;
1267         __uninitialized_copy_copy(mid, last, pos, finish, finish);
1268         finish = new_finish;
1269         copy(first, mid, pos);
1270       }
1271     }
1272     __STL_UNWIND(destroy_nodes_at_back(new_finish));
1273   }
1274 }
1275 
1276 #endif /* __STL_MEMBER_TEMPLATES */
1277 
1278 template <class T, class Alloc, size_t BufSize>
1279 void deque<T, Alloc, BufSize>::new_elements_at_front(size_type new_elements) {
1280   size_type new_nodes = (new_elements + buffer_size() - 1) / buffer_size();
1281   reserve_map_at_front(new_nodes);
1282   size_type i;
1283   __STL_TRY {
1284     for (i = 1; i <= new_nodes; ++i)
1285       *(start.node - i) = allocate_node();
1286   }
1287 #       ifdef __STL_USE_EXCEPTIONS
1288   catch(...) {
1289     for (size_type j = 1; j < i; ++j)
1290       deallocate_node(*(start.node - j));      
1291     throw;
1292   }
1293 #       endif /* __STL_USE_EXCEPTIONS */
1294 }
1295 
1296 template <class T, class Alloc, size_t BufSize>
1297 void deque<T, Alloc, BufSize>::new_elements_at_back(size_type new_elements) {
1298   size_type new_nodes = (new_elements + buffer_size() - 1) / buffer_size();
1299   reserve_map_at_back(new_nodes);
1300   size_type i;
1301   __STL_TRY {
1302     for (i = 1; i <= new_nodes; ++i)
1303       *(finish.node + i) = allocate_node();
1304   }
1305 #       ifdef __STL_USE_EXCEPTIONS
1306   catch(...) {
1307     for (size_type j = 1; j < i; ++j)
1308       deallocate_node(*(finish.node + j));      
1309     throw;
1310   }
1311 #       endif /* __STL_USE_EXCEPTIONS */
1312 }
1313 
1314 template <class T, class Alloc, size_t BufSize>
1315 void deque<T, Alloc, BufSize>::destroy_nodes_at_front(iterator before_start) {
1316   for (map_pointer n = before_start.node; n < start.node; ++n)
1317     deallocate_node(*n);
1318 }
1319 
1320 template <class T, class Alloc, size_t BufSize>
1321 void deque<T, Alloc, BufSize>::destroy_nodes_at_back(iterator after_finish) {
1322   for (map_pointer n = after_finish.node; n > finish.node; --n)
1323     deallocate_node(*n);
1324 }
1325 
1326 template <class T, class Alloc, size_t BufSize>
1327 void deque<T, Alloc, BufSize>::reallocate_map(size_type nodes_to_add,
1328                                               bool add_at_front) {
1329   size_type old_num_nodes = finish.node - start.node + 1;
1330   size_type new_num_nodes = old_num_nodes + nodes_to_add;
1331 
1332   map_pointer new_nstart;
1333   if (map_size > 2 * new_num_nodes) {
1334     new_nstart = map + (map_size - new_num_nodes) / 2 
1335                      + (add_at_front ? nodes_to_add : 0);
1336     if (new_nstart < start.node)
1337       copy(start.node, finish.node + 1, new_nstart);
1338     else
1339       copy_backward(start.node, finish.node + 1, new_nstart + old_num_nodes);
1340   }
1341   else {
1342     size_type new_map_size = map_size + max(map_size, nodes_to_add) + 2;
1343     // 配置一塊空間,準備給新map使用。
1344     map_pointer new_map = map_allocator::allocate(new_map_size);
1345     new_nstart = new_map + (new_map_size - new_num_nodes) / 2
1346                          + (add_at_front ? nodes_to_add : 0);
1347     // 把原map 內容拷貝過來。
1348     copy(start.node, finish.node + 1, new_nstart);
1349     // 釋放原map
1350     map_allocator::deallocate(map, map_size);
1351     // 設定新map的起始位址與大小
1352     map = new_map;
1353     map_size = new_map_size;
1354   }
1355 
1356   // 重新設定迭代器 start 和 finish
1357   start.set_node(new_nstart);
1358   finish.set_node(new_nstart + old_num_nodes - 1);
1359 }
1360 
1361 
1362 // Nonmember functions.
1363 
1364 #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
1365 
1366 template <class T, class Alloc, size_t BufSiz>
1367 bool operator==(const deque<T, Alloc, BufSiz>& x,
1368                 const deque<T, Alloc, BufSiz>& y) {
1369   return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
1370 }
1371 
1372 template <class T, class Alloc, size_t BufSiz>
1373 bool operator<(const deque<T, Alloc, BufSiz>& x,
1374                const deque<T, Alloc, BufSiz>& y) {
1375   return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
1376 }
1377 
1378 #endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
1379 
1380 #if defined(__STL_FUNCTION_TMPL_PARTIAL_ORDER) && \
1381     !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
1382 
1383 template <class T, class Alloc, size_t BufSiz>
1384 inline void swap(deque<T, Alloc, BufSiz>& x, deque<T, Alloc, BufSiz>& y) {
1385   x.swap(y);
1386 }
1387 
1388 #endif
1389 
1390 #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
1391 #pragma reset woff 1174
1392 #endif
1393           
1394 __STL_END_NAMESPACE 
1395   
1396 #endif /* __SGI_STL_INTERNAL_DEQUE_H */
1397 
1398 // Local Variables:
1399 // mode:C++
1400 // End:

 

posted @ 2014-09-10 14:00  xxiaoye  阅读(560)  评论(0编辑  收藏  举报