STL Source --vector

1, first look at the most common vector is the most commonly used constructor (vector <int> vec): constructor with no arguments

template <class _Tp, class _Alloc> 
class _Vector_base {
public:
  _Vector_base(const _Alloc&)	//vector无参构造
    : _M_start(0), _M_finish(0), _M_end_of_storage(0) {}
protected:
  _Tp* _M_start;		//指向第一个元素
  _Tp* _M_finish;		//指向最后一个元素的下一个
  _Tp* _M_end_of_storage;		//指向所分配内存的下一个
};
//vector的类，继承_Vector_base
template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> {
	typedef _Vector_base<_Tp, _Alloc> _Base;
	//allocator_type是一个类型分配器，每个构造函数都有一个
	explicit vector(const allocator_type& __a = allocator_type())
    	: _Base(__a) {}	//调用基类_Vector_base的构造函数
}；

It follows that the sizeof (Vector) = 16 ;
Vector total of 6 configured ways, each method has a dispenser type; the number of elements of the first to open up the memory requirements in the base class, the second call fill or copy function data replication; following

//vector<int>vec(10,20);		 构造一个有十个元素且值为20的vector
vector(size_type __n, const _Tp& __value,
         const allocator_type& __a = allocator_type()) 
    : _Base(__n, __a)
    { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }
    
  vector(const vector<_Tp, _Alloc>& __x) 
    : _Base(__x.size(), __x.get_allocator())
    { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }

2, vector a variety of methods:

iterator begin() { return _M_start; }
iterator end() { return _M_finish; }
void push_back(const _Tp& __x) {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
    //	扩容 0-1-2-4-8  二倍扩容
      _M_insert_aux(end(), __x);
  }
  //  pop_back和erase方法，只向前移动了finsh指针，并没有改变原值（实践得出）
  void pop_back() {
    --_M_finish;
    destroy(_M_finish);
  }
  iterator erase(iterator __position) {
    if (__position + 1 != end())
      copy(__position + 1, _M_finish, __position);
    --_M_finish;
    destroy(_M_finish);
    return __position;
  }
//返回最后一个指向元素的指针（end-1）
reverse_iterator rbegin()
    { return reverse_iterator(end()); }
// size方法
size_type size() const					
    { return size_type(end() - begin()); }
 //此方法指最多可包含元素个数   
 size_type max_size() const		
    { return size_type(-1) / sizeof(_Tp); }
    **size_type：unsigned int类型，所以size_type（-1）为2^32-1
  //capacity方法得到vector的目前开辟内存可存放元素个数
  size_type capacity() const			
    { return size_type(_M_end_of_storage - begin()); }
 //得到_n下标的元素；如大于元素个数，则抛出异常
 reference at(size_type __n)			
    { _M_range_check(__n); return (*this)[__n]; }
  void _M_range_check(size_type __n) const {
    if (__n >= this->size())
      __stl_throw_range_error("vector");
  }

/* 
assign设置元素的值，可以看到
（1）当n大于capavity（）时，重新开辟内存。然后交换容器
（2）当n大于元素个数时，改变全部元素值为val，且添加n-size()个val元素
（3）改变n个元素值为val后，删除n之后所有元素
*/
void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }
void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const value_type& __val) 
{
  if (__n > capacity()) {
    vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
    __tmp.swap(*this);
  }
  else if (__n > size()) {
    fill(begin(), end(), __val);
    _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);
  }
  else
    erase(fill_n(begin(), __n, __val), end());
}