stl源码剖析之vector

vector是一种序列式容器，使用vector时只需要#include <vector>
sgi stl 3.0中vector的具体实现定义在stl_vector.h文件中，vector使用的是连续线性空间，vector的迭代器即为普通指针，截取sgi stl 3.0部分源码，如下

//alloc是第一级或第二级配置器,定义在<stl_alloc.h>中,sgi stl中alloc默认为第二级配置器
template <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维护的是连续线性空间,以普通指针作为vector的迭代器
  typedef const value_type* const_iterator;//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;  //反向迭代器,reverse_iterator是一个template,定义在<stl_iterator.h>
  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;  //simple_alloc定义在<stl_alloc.h>中,用以分配内存
  iterator start;    //目前使用空间的头
  iterator finish;   //目前使用空间的尾
  iterator end_of_storage;  //目前可用空间的尾
};

可以看到sgi stl中以普通指针(T*)作为迭代器，vector维护线性空间，以普通指针作为迭代器可以支持它的快速移动以及vector的随机存取。当vector原空间大小不足时，vector需要申请更大的空间，并将原空间中所有元素移动到新空间,并销毁释放原空间。由此可知,vector扩容时，消耗很大，因此，vector申请空间时一般先申请比客户端需求更大的空间，防止频繁的申请空间。vector维护三个迭代器,分别指向当前使用空间的头，当前使用空间的尾，可用空间的尾。

template <class T, class Alloc = alloc>  
class vector {
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的部分构造函数:

template <class T, class Alloc = alloc>  
class vector {
public:
  vector() : start(0), finish(0), end_of_storage(0) {}   //空的vector
  vector(size_type n, const T& value) { fill_initialize(n, value); } //vector大小为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;
  }

protected:
  iterator allocate_and_copy(size_type n,
                             const_iterator first, const_iterator last) {
    iterator result = data_allocator::allocate(n);  //分配空间
    uninitialized_copy(first, last, result);  //将迭代器[first,last)之间的内容拷贝到result开始的空间
    return result;
  }
 iterator allocate_and_fill(size_type n, const T& x) {
   iterator result = data_allocator::allocate(n);
   uninitialized_fill_n(result, n, x);
   return result;
  }
 void fill_initialize(size_type n, const T& value) {
    start = allocate_and_fill(n, value);
    finish = start + n;
    end_of_storage = finish;
 }
};