STL源碼剖析 容器 stl_vector.h

標籤：des   style   blog   http   color   使用   

本文為senlie原創，轉載請保留此地址：http://blog.csdn.net/zhengsenlie

vector
----------------------------------------------------------------------


描述：
1.迭代器
vector 維護的是一個連續線性空間，它的迭代器是普通指標，
能滿足 RandomAccessIterator 所有必要條件：operator*, operator->,operator++,operator--,operator+,
operator-,operator+=,operator-=,operator[]
2.資料結構
vector所採用的資料結構是線性連續空間。
迭代器 start、finish分別表示配置得來的連續空間中目前已經被使用的範圍
迭代器 end_of_storage 指向整塊連續空間的尾端


增加新元素時，如果走過當時的容量，則容量會擴充至兩倍。
如果兩倍容量仍不足，就擴張至足夠大的容量。
擴充容量的過程為：重新設定、元素移動、釋放原空間
所謂動態增加大小，並不是在原空間之後接續新空間，因為無法保證原空間之後
尚有可供配置的空間。因此，對 vector 的任何操作，一旦引起空間重新設定，
指向原 vector 的所有迭代器就失效了。
圖4-2


樣本：

vector<int> V;V.insert(V.begin(), 3);assert(V.size() == 1 && V.capacity() >= 1 && V[0] == 3);

源碼：

#ifndef __SGI_STL_INTERNAL_VECTOR_H#define __SGI_STL_INTERNAL_VECTOR_H__STL_BEGIN_NAMESPACE #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)#pragma set woff 1174#endiftemplate <class T, class Alloc = alloc>class vector {public:  typedef T value_type;  typedef value_type* pointer;  typedef const value_type* const_pointer;  typedef value_type* iterator; //vector 的迭代器是個原生的指標  typedef const value_type* const_iterator;  typedef value_type& reference;  typedef const value_type& const_reference;  typedef size_t size_type;  typedef ptrdiff_t difference_type;#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION  typedef reverse_iterator<const_iterator> const_reverse_iterator;  typedef reverse_iterator<iterator> reverse_iterator;#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */  typedef reverse_iterator<const_iterator, value_type, const_reference,                            difference_type>  const_reverse_iterator;  typedef reverse_iterator<iterator, value_type, reference, difference_type>          reverse_iterator;#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */protected:  typedef simple_alloc<value_type, Alloc> data_allocator; //連續空間？  iterator start; //表示目前使用空間的頭  iterator finish; //表示目前使用空間的尾  iterator end_of_storage; //表示目前可用空間的尾  void insert_aux(iterator position, const T& x);  void deallocate() {    if (start) data_allocator::deallocate(start, end_of_storage - start);  }  // 填充並予以初始化  void fill_initialize(size_type n, const T& value) {    start = allocate_and_fill(n, value);    finish = start + n;    end_of_storage = finish;  }public:  iterator begin() { return start; }  const_iterator begin() const { return start; }  iterator end() { return finish; }  const_iterator end() const { return finish; }  reverse_iterator rbegin() { return reverse_iterator(end()); }  const_reverse_iterator rbegin() const {     return const_reverse_iterator(end());   }  reverse_iterator rend() { return reverse_iterator(begin()); }  const_reverse_iterator rend() const {     return const_reverse_iterator(begin());   }  size_type size() const { return size_type(end() - begin()); }  size_type max_size() const { return size_type(-1) / sizeof(T); }  size_type capacity() const { return size_type(end_of_storage - begin()); }  bool empty() const { return begin() == end(); }  reference operator[](size_type n) { return *(begin() + n); }  const_reference operator[](size_type n) const { return *(begin() + n); }  vector() : start(0), finish(0), end_of_storage(0) {}  //建構函式，允許指定 vector 大小 n 和初值 value  vector(size_type n, const T& value) { fill_initialize(n, value); }  vector(int n, const T& value) { fill_initialize(n, value); }  vector(long n, const T& value) { fill_initialize(n, value); }  explicit vector(size_type n) { fill_initialize(n, T()); }  vector(const vector<T, Alloc>& x) {    start = allocate_and_copy(x.end() - x.begin(), x.begin(), x.end());    finish = start + (x.end() - x.begin());    end_of_storage = finish;  }#ifdef __STL_MEMBER_TEMPLATES  template <class InputIterator>  vector(InputIterator first, InputIterator last) :    start(0), finish(0), end_of_storage(0)  {    range_initialize(first, last, iterator_category(first));  }#else /* __STL_MEMBER_TEMPLATES */  vector(const_iterator first, const_iterator last) {    size_type n = 0;    distance(first, last, n);    start = allocate_and_copy(n, first, last);    finish = start + n;    end_of_storage = finish;  }#endif /* __STL_MEMBER_TEMPLATES */  ~vector() {     destroy(start, finish);    deallocate();  }  vector<T, Alloc>& operator=(const vector<T, Alloc>& x);  void reserve(size_type n) {    if (capacity() < n) {      const size_type old_size = size();      iterator tmp = allocate_and_copy(n, start, finish);      destroy(start, finish);      deallocate();      start = tmp;      finish = tmp + old_size;      end_of_storage = start + n;    }  }  reference front() { return *begin(); }  const_reference front() const { return *begin(); }  reference back() { return *(end() - 1); }  const_reference back() const { return *(end() - 1); }  //  void push_back(const T& x) {    if (finish != end_of_storage) { //檢查是否還有備用空間      construct(finish, x); //有，直接在備用空間上構造元素      ++finish; //調整迭代器 finish    }    else      insert_aux(end(), x); //沒有，擴充空間(重新設定、元素移動、釋放原空間)  }  void swap(vector<T, Alloc>& x) {    __STD::swap(start, x.start);    __STD::swap(finish, x.finish);    __STD::swap(end_of_storage, x.end_of_storage);  }  iterator insert(iterator position, const T& x) {    size_type n = position - begin();    if (finish != end_of_storage && position == end()) {      construct(finish, x);      ++finish;    }    else      insert_aux(position, x);    return begin() + n;  }  iterator insert(iterator position) { return insert(position, T()); }#ifdef __STL_MEMBER_TEMPLATES  template <class InputIterator>  void insert(iterator position, InputIterator first, InputIterator last) {    range_insert(position, first, last, iterator_category(first));  }#else /* __STL_MEMBER_TEMPLATES */  void insert(iterator position,              const_iterator first, const_iterator last);#endif /* __STL_MEMBER_TEMPLATES */  void insert (iterator pos, size_type n, const T& x);  void insert (iterator pos, int n, const T& x) {    insert(pos, (size_type) n, x);  }  void insert (iterator pos, long n, const T& x) {    insert(pos, (size_type) n, x);  }  void pop_back() {    --finish; //將尾端標記往前移一格，表示將放棄尾端元素    destroy(finish); //析構尾端元素  }  //清除 position 指向的元素  iterator erase(iterator position) {    if (position + 1 != end())      copy(position + 1, finish, position);    --finish;    destroy(finish);    return position;  }  //清除[first, last)中的所有元素  iterator erase(iterator first, iterator last) {    iterator i = copy(last, finish, first); 將 [last, finish) 指示的元素拷貝至 first 迭代器開頭的地方     destroy(i, finish); 析構[i, finish) 裡的元素    finish = finish - (last - first); 調整 finish 指示的位置 last - first 表示清除掉了的元素個數    return first;  }  void resize(size_type new_size, const T& x) {    if (new_size < size())       erase(begin() + new_size, end());    else      insert(end(), new_size - size(), x);  }  void resize(size_type new_size) { resize(new_size, T()); }  //調用 erase 清除所有元素  void clear() { erase(begin(), end()); }protected:  //配置而後填充  iterator allocate_and_fill(size_type n, const T& x) {    iterator result = data_allocator::allocate(n); //配置 n 個元素空間    __STL_TRY {      uninitialized_fill_n(result, n, x); //全域函數。全根據 result 的類型特性(type traits)決定使用演算法 fill_n() 或反覆調用  construct() 來完成任務      return result;    }    __STL_UNWIND(data_allocator::deallocate(result, n));  }#ifdef __STL_MEMBER_TEMPLATES  template <class ForwardIterator>  iterator allocate_and_copy(size_type n,                             ForwardIterator first, ForwardIterator last) {    iterator result = data_allocator::allocate(n);    __STL_TRY {      uninitialized_copy(first, last, result);      return result;    }    __STL_UNWIND(data_allocator::deallocate(result, n));  }#else /* __STL_MEMBER_TEMPLATES */  iterator allocate_and_copy(size_type n,                             const_iterator first, const_iterator last) {    iterator result = data_allocator::allocate(n);    __STL_TRY {      uninitialized_copy(first, last, result);      return result;    }    __STL_UNWIND(data_allocator::deallocate(result, n));  }#endif /* __STL_MEMBER_TEMPLATES */#ifdef __STL_MEMBER_TEMPLATES  template <class InputIterator>  void range_initialize(InputIterator first, InputIterator last,                        input_iterator_tag) {    for ( ; first != last; ++first)      push_back(*first);  }  // This function is only called by the constructor.  We have to worry  //  about resource leaks, but not about maintaining invariants.  template <class ForwardIterator>  void range_initialize(ForwardIterator first, ForwardIterator last,                        forward_iterator_tag) {    size_type n = 0;    distance(first, last, n);    start = allocate_and_copy(n, first, last);    finish = start + n;    end_of_storage = finish;  }  template <class InputIterator>  void range_insert(iterator pos,                    InputIterator first, InputIterator last,                    input_iterator_tag);  template <class ForwardIterator>  void range_insert(iterator pos,                    ForwardIterator first, ForwardIterator last,                    forward_iterator_tag);#endif /* __STL_MEMBER_TEMPLATES */};template <class T, class Alloc>inline bool operator==(const vector<T, Alloc>& x, const vector<T, Alloc>& y) {  return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());}template <class T, class Alloc>inline bool operator<(const vector<T, Alloc>& x, const vector<T, Alloc>& y) {  return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());}#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDERtemplate <class T, class Alloc>inline void swap(vector<T, Alloc>& x, vector<T, Alloc>& y) {  x.swap(y);}#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */template <class T, class Alloc>vector<T, Alloc>& vector<T, Alloc>::operator=(const vector<T, Alloc>& x) {  if (&x != this) {    if (x.size() > capacity()) {      iterator tmp = allocate_and_copy(x.end() - x.begin(),                                       x.begin(), x.end());      destroy(start, finish);      deallocate();      start = tmp;      end_of_storage = start + (x.end() - x.begin());    }    else if (size() >= x.size()) {      iterator i = copy(x.begin(), x.end(), begin());      destroy(i, finish);    }    else {      copy(x.begin(), x.begin() + size(), start);      uninitialized_copy(x.begin() + size(), x.end(), finish);    }    finish = start + x.size();  }  return *this;}template <class T, class Alloc>void vector<T, Alloc>::insert_aux(iterator position, const T& x) {   if (finish != end_of_storage) { // 不是備用空間不夠才會調用 insert_aux 來插入元素嗎？ 為什麼還會出現 finish != end_of_storage 的情況 ？  // --> 除了 push_back 不夠空間時會調用 insert_aux，正常的 insert 也是調用 insert_aux 實現的。//為什麼不直接 copy_backward(position, finish - 1, finish)， 然後 *position = x_copy 呢？construct(finish, *(finish - 1));    ++finish;    T x_copy = x;    copy_backward(position, finish - 2, finish - 1);    *position = x_copy;  }  else { //無備用空間 position == finish    const size_type old_size = size();    const size_type len = old_size != 0 ? 2 * old_size : 1;    //如果原大小為0，則配置1個元素大小的空間，否則配置原大小兩倍的空間iterator new_start = data_allocator::allocate(len); //實際配置    iterator new_finish = new_start;     __STL_TRY {  //將原空間的全部內容拷貝到新空間 positition      new_finish = uninitialized_copy(start, position, new_start);      //為新元素設定初值 x  construct(new_finish, x);      //調整迭代器 finish  ++new_finish;  //？？我覺得下面這行代碼沒用。因為無備用空間的情況，position == finish       new_finish = uninitialized_copy(position, finish, new_finish);    }#       ifdef  __STL_USE_EXCEPTIONS     catch(...) { //異常竟然可以用三個小點 ... ??   //復原      destroy(new_start, new_finish);       data_allocator::deallocate(new_start, len);      throw;    }#       endif /* __STL_USE_EXCEPTIONS *///析構並釋放原空間    destroy(begin(), end());    deallocate();//調整迭代器，指向新 vector    start = new_start;    finish = new_finish;    end_of_storage = new_start + len;  }}template <class T, class Alloc>//從 position 開始，插入 n 個元素，元素初值為 xvoid vector<T, Alloc>::insert(iterator position, size_type n, const T& x) {  if (n != 0) { // 當 n != 0 才進行以下所有操作    if (size_type(end_of_storage - finish) >= n) { //備用空間大於新增元素個數      T x_copy = x;       const size_type elems_after = finish - position; //插入點之後的的現有元素個數      iterator old_finish = finish;      if (elems_after > n) { //"插入點之後的的現有元素個數"大於"新增元素個數"        //空間還沒初始化時用 uninitialized_copy ， 已經初始化了用 copy_backwarduninitialized_copy(finish - n, finish, finish);        finish += n;        copy_backward(position, old_finish - n, old_finish);        fill(position, position + n, x_copy); //從插入點開始填入新值      }      else { //"插入點之後的的現有元素個數"小於"新增元素個數"        uninitialized_fill_n(finish, n - elems_after, x_copy);        finish += n - elems_after;        uninitialized_copy(position, old_finish, finish);        finish += elems_after;        fill(position, old_finish, x_copy);      }    }    else {//備用空間小於新增元素個數      const size_type old_size = size();  // 首先決定新長度：舊長度的兩倍或舊長度+新元素個數，這兩個中取最大值      const size_type len = old_size + max(old_size, n);      iterator new_start = data_allocator::allocate(len);      iterator new_finish = new_start;      __STL_TRY {    //先用 uninitialized_copy 將舊 vector 的插入點之前的元素複製到新空間        new_finish = uninitialized_copy(start, position, new_start);        //再用 uninitialized_fill_n 將新增元素填入新空間new_finish = uninitialized_fill_n(new_finish, n, x);        //最後再用 uninitialized_copy 將舊 vector 的插入點之後的元素複製到新空間new_finish = uninitialized_copy(position, finish, new_finish);      }#         ifdef  __STL_USE_EXCEPTIONS       catch(...) {        destroy(new_start, new_finish);        data_allocator::deallocate(new_start, len);        throw;      }#         endif /* __STL_USE_EXCEPTIONS */      //清除並釋放舊的 vector  destroy(start, finish);      deallocate();  //調整標記      start = new_start;      finish = new_finish;      end_of_storage = new_start + len;    }  }}#ifdef __STL_MEMBER_TEMPLATEStemplate <class T, class Alloc> template <class InputIterator>void vector<T, Alloc>::range_insert(iterator pos,                                    InputIterator first, InputIterator last,                                    input_iterator_tag) {  for ( ; first != last; ++first) {    pos = insert(pos, *first);    ++pos;  }}template <class T, class Alloc> template <class ForwardIterator>void vector<T, Alloc>::range_insert(iterator position,                                    ForwardIterator first,                                    ForwardIterator last,                                    forward_iterator_tag) {  if (first != last) {    size_type n = 0;    distance(first, last, n);    if (size_type(end_of_storage - finish) >= n) {      const size_type elems_after = finish - position;      iterator old_finish = finish;      if (elems_after > n) {        uninitialized_copy(finish - n, finish, finish);        finish += n;        copy_backward(position, old_finish - n, old_finish);        copy(first, last, position);      }      else {        ForwardIterator mid = first;        advance(mid, elems_after);        uninitialized_copy(mid, last, finish);        finish += n - elems_after;        uninitialized_copy(position, old_finish, finish);        finish += elems_after;        copy(first, mid, position);      }    }    else {      const size_type old_size = size();      const size_type len = old_size + max(old_size, n);      iterator new_start = data_allocator::allocate(len);      iterator new_finish = new_start;      __STL_TRY {        new_finish = uninitialized_copy(start, position, new_start);        new_finish = uninitialized_copy(first, last, new_finish);        new_finish = uninitialized_copy(position, finish, new_finish);      }#         ifdef __STL_USE_EXCEPTIONS      catch(...) {        destroy(new_start, new_finish);        data_allocator::deallocate(new_start, len);        throw;      }#         endif /* __STL_USE_EXCEPTIONS */      destroy(start, finish);      deallocate();      start = new_start;      finish = new_finish;      end_of_storage = new_start + len;    }  }}#else /* __STL_MEMBER_TEMPLATES */template <class T, class Alloc>void vector<T, Alloc>::insert(iterator position,                               const_iterator first,                               const_iterator last) {  if (first != last) {    size_type n = 0;    distance(first, last, n);    if (size_type(end_of_storage - finish) >= n) {      const size_type elems_after = finish - position;      iterator old_finish = finish;      if (elems_after > n) {        uninitialized_copy(finish - n, finish, finish);        finish += n;        copy_backward(position, old_finish - n, old_finish);        copy(first, last, position);      }      else {        uninitialized_copy(first + elems_after, last, finish);        finish += n - elems_after;        uninitialized_copy(position, old_finish, finish);        finish += elems_after;        copy(first, first + elems_after, position);      }    }    else {      const size_type old_size = size();      const size_type len = old_size + max(old_size, n);      iterator new_start = data_allocator::allocate(len);      iterator new_finish = new_start;      __STL_TRY {        new_finish = uninitialized_copy(start, position, new_start);        new_finish = uninitialized_copy(first, last, new_finish);        new_finish = uninitialized_copy(position, finish, new_finish);      }#         ifdef __STL_USE_EXCEPTIONS      catch(...) {        destroy(new_start, new_finish);        data_allocator::deallocate(new_start, len);        throw;      }#         endif /* __STL_USE_EXCEPTIONS */      destroy(start, finish);      deallocate();      start = new_start;      finish = new_finish;      end_of_storage = new_start + len;    }  }}#endif /* __STL_MEMBER_TEMPLATES */#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)#pragma reset woff 1174#endif__STL_END_NAMESPACE #endif /* __SGI_STL_INTERNAL_VECTOR_H */// Local Variables:// mode:C++// End: