vector

1.vector概述

vector和array非常類似，區別在於array是靜態空間，一旦配置就不能改變了。空間不夠之後需要換個更大的空間，這個工作需要有客戶端自己打理。vector是動態空間，內部機制會自行擴充空間來容納新元素。vector技術中關鍵部分在於，對大小的配置以及重新配置時數據移動的效率。

2.vector定義

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);

private:
  typedef _Vector_base<_Tp, _Alloc> _Base;
public:
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type* iterator;
  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;
.
.
.}

這裏從比<vector>更底層的<stl_vector.h>中摘出來的，其中需要注意的有兩個地方：

1.__STL_DEFAULT_ALLOCATOR(_Tp)是SGI STL的空間配置器。

2.上面標紅的是vector的迭代器，vector迭代器所需要的操作行爲，入operator*、operator->、operator++、operator--、operator+、operator-、operator+=、operator-=，
vector支持隨機存取，而普通指針也具備這樣的能力，所以，vector<T>的迭代器就是T*，實質上是指針。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
...
protected:
#ifdef __STL_HAS_NAMESPACES
  using _Base::_M_allocate;
  using _Base::_M_deallocate;
  using _Base::_M_start;
  using _Base::_M_finish;
  using _Base::_M_end_of_storage;
#endif /* __STL_HAS_NAMESPACES */
...
}

vector所採用的數據結構爲線性連續空間，兩個迭代器_M_start，_M_finish分別指向配置得來的連續空間中目前已被使用的範圍，並以_M_end_of_storage指向整塊連續空間（含備用空間）的尾端。利用這三個迭代器，可以輕鬆的提供首尾標識，大小，容量，空容器判斷，註標（[ ]）運算子，最前端元素，最後端元素等等機能。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
...
public:
  iterator begin() { return _M_start; }
  const_iterator begin() const { return _M_start; }
  iterator end() { return _M_finish; }
  const_iterator end() const { return _M_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(_Tp); }
  size_type capacity() const
    { return size_type(_M_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); }
...
}

3.vector的構造和內存管理

直接借用書中的測試代碼，可以看到隨着不同的操作，vector<int>的size和capacity一直在不停的變化之中，下面從源碼之中來找出這些變化的本質。

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc> 
{
...
  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }
...
}

拿其中一個構造函數爲例，指定vector的大小n和初值value

  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); }

在<stl_uninitialized.h>中，定義了uninitialized_fill_n()

template <class _ForwardIter, class _Size, class _Tp>
inline _ForwardIter 
uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
{
  return __uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first));
}

調用__uninitialized_fill_n().

template <class _ForwardIter, class _Size, class _Tp, class _Tp1>
inline _ForwardIter 
__uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*)
{
  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
}

調用_uninitialized_fill_n_aux()會根據第一參數的型別特徵決定使用算法fill_n()，或者是反覆調用construct()來完成任務。

// Valid if copy construction is equivalent to assignment, and if the
// destructor is trivial.
template <class _ForwardIter, class _Tp>
inline void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
                         const _Tp& __x, __true_type)
{
  fill(__first, __last, __x);
}

template <class _ForwardIter, class _Tp>
void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
                         const _Tp& __x, __false_type)
{
  _ForwardIter __cur = __first;
  __STL_TRY {
    for ( ; __cur != __last; ++__cur)
      _Construct(&*__cur, __x);
  }
  __STL_UNWIND(_Destroy(__first, __cur));
}

使用push_back（）將新元素插入到vector尾端時，首先判斷是否還有備用空間，有的話直接在備用空間上構造函數，同時調整迭代器_M_finish。

如果沒有備用空間，就擴充空間（重新分配，移動數據，釋放原空間）

  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);
  }

template <class _Tp, class _Alloc>
void 
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
  if (_M_finish != _M_end_of_storage) {//如果還有備用空間
    construct(_M_finish, *(_M_finish - 1));//在_M_finish地址上新建一個值爲以前隊尾元素的值。
    ++_M_finish;
    _Tp __x_copy = __x;
    copy_backward(__position, _M_finish - 2, _M_finish - 1);//將[__position, _M_finish - 2)之間的元素複製到以_M_finish - 1的地址上
    *__position = __x_copy;//插入的地方賦值
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;//如果原有空間爲0，則配置1，不爲0，則配置原大小的兩倍

    iterator __new_start = _M_allocate(__len);//重新再堆上申請內存
    iterator __new_finish = __new_start;
    __STL_TRY {
      __new_finish = uninitialized_copy(_M_start, __position, __new_start);//將原來的vector拷貝到新申請的地址
      construct(__new_finish, __x);//在vector的尾部添加繼續你的元素
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);//將安插點的原內容也拷貝過來
    }
    __STL_UNWIND((destroy(__new_start,__new_finish), 
                  _M_deallocate(__new_start,__len)));
    destroy(begin(), end());//析構並釋放原vector
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start;//調整迭代器，指向新的vector
    _M_finish = __new_finish;
    _M_end_of_storage = __new_start + __len;
  }
}

這一部分的代碼還是很清晰的，配上書中的圖很容易就可以理解。

4.vector的元素操作：pop_back，erase，clear，insert

pop_back相對容易

  void pop_back() {
    --_M_finish;
    destroy(_M_finish);
  }

erase（），清除[first, last)之間的所有元素或者指定位置的元素，配合書上的圖應該很好理解。

  iterator erase(iterator __position) {
    if (__position + 1 != end())
      copy(__position + 1, _M_finish, __position);
    --_M_finish;
    destroy(_M_finish);
    return __position;
  }
  iterator erase(iterator __first, iterator __last) {
    iterator __i = copy(__last, _M_finish, __first);
    destroy(__i, _M_finish);
    _M_finish = _M_finish - (__last - __first);
    return __first;
  }

insert（）

這裏就討論一種：

  void insert (iterator __pos, size_type __n, const _Tp& __x)
    { _M_fill_insert(__pos, __n, __x); }

插入過程可以分爲兩種情況，一種是備用空間大於要插入的元素，這種情況又分爲插入的點之後現有元素個數大於新增元素個數和小於兩種。

第二種情況是備用空間小於要插入的元素

1.備用空間大於新增元素個數

1）插入點之後的現有元素個數大於新增元素個數

給個圖就能看的很明白

2）插入點之後的現有元素個數小於新增元素個數

2.備用空間小於新增元素個數

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);
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
        fill(__position, __position + __n, __x_copy);
      }
      else {//插入點之後的現有元素個數小於於新增元素個數

        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_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;
    }
  }
}

最後需要注意的地方是，vector中的迭代器在經過類似push_back、insert之後可能不在指向之前的值，因爲其本質爲指針，如果在容量不夠的情況下擴充內容之後，之前的迭代器有可能全部失效。

STL vector源碼分析

vector

1.vector概述

2.vector定義

3.vector的構造和內存管理

4.vector的元素操作：pop_back，erase，clear，insert

STL vector源碼分析

637. Average of Levels in Binary Tree 104. Maximum Depth of Binary Tree

389. Find the Difference

226. Invert Binary Tree

485. Max Consecutive Ones

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結