20170323STL06_STL_SGI_vector

SGI vector：

  void push_back(const _Tp& __x) {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(end(), __x);//这个是可能会导致内存大小和地址发生改变的，这样外部指向他的指针也就失效了，这些指针需要更新
	//使用vector的时候一定要注意这点，内部重新分配空间的时候，外部指针会失效。
  }
  void swap(vector<_Tp, _Alloc>& __x) {//成员函数，接收的是一个模板类型一样的元素来互换
    __STD::swap(_M_start, __x._M_start);
    __STD::swap(_M_finish, __x._M_finish);
    __STD::swap(_M_end_of_storage, __x._M_end_of_storage);
  }
  iterator insert(iterator __position, const _Tp& __x) {
    size_type __n = __position - begin();
    if (_M_finish != _M_end_of_storage && __position == end()) {
      construct(_M_finish, __x);//空间足够且插入位置在最后，就直接构造这个（placement new）。
      ++_M_finish;
    }
    else
      _M_insert_aux(__position, __x);//在指定位置插入元素，也可能重新分配。
    return begin() + __n;
  }
template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n, 
                                         const _Tp& __x)//指定位置插入一段一样的值。
{
  if (__n != 0) {
    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
      _Tp __x_copy = __x;
      const size_type __elems_after = _M_finish - __position;//后面需要移动元素的数量
      iterator __old_finish = _M_finish;
      if (__elems_after > __n) {//如果需要往后移的元素个数比需要插入的多
        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);//先移动后面n个，有调用构造的（复制到为初始化空间需要构造）
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
	//再移动前面部分，直接拷贝，不需构造（否则会导致构造函数和析构函数调用次数不一致，是undefined behavior。）
        fill(__position, __position + __n, __x_copy);//直接赋值，不需构造
      }
      else {//这个ifelse就是为了考虑需不需要构造才分开写的的，else里面有部分需要插入的元素会在已构造空间，有部分在未构造空间。
        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);//将未构造空间需要插入__x的部分全部构造成__x
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_finish, _M_finish);//将需要移动的元素移动到_M_finish之后
        _M_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 = _M_allocate(__len);
      iterator __new_finish = __new_start;
      __STL_TRY {
        __new_finish = uninitialized_copy(_M_start, __position, __new_start);
        __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
        __new_finish
          = uninitialized_copy(__position, _M_finish, __new_finish);
      }
      __STL_UNWIND((destroy(__new_start,__new_finish), 
                    _M_deallocate(__new_start,__len)));
      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start;
      _M_finish = __new_finish;
      _M_end_of_storage = __new_start + __len;
    }
  }
}
  iterator erase(iterator __position) {//擦出指定位置的元素
    if (__position + 1 != end())
      copy(__position + 1, _M_finish, __position);//赋值后面的直接覆盖前面的，对象还是原来的，但是值改变了。
    --_M_finish;
    destroy(_M_finish);//析构最后一个（半闭半开）。他只是擦出值，如果里面存放的指针就可能发生泄漏。
    return __position;
  }

注意：如果vector里面装的指针，在查处的时候就会泄漏。
STL里面所有的容器都是浅拷贝，是值语义，他不会负责元素的生命周期，这样做是因为值语义是可以转化成对象语义的，对象语义没办法转换成值语义。
转换成对象语义：析构函数里面有delete就可以转换成对象语义，最常用的就是智能指针（就是将一个指针包装成一个类），还可以通过继承来做，但是用的很少。
STL里面的东西是不能改写，但是可以继承的。