STL源码剖析(vector)

在SGI STL中，vector使用的是连续的内存空间，迭代器使用普通指针来实现。

因为使用的是连续的内存空间，在vector容量不足的时候会直接分配一块新的内存，把原来的元素copy进去，回收原来的内存空间。

因此在vector扩容的时候，原来的所有迭代器都会失效。

vector的实现基本都是围绕这start、end、end_of_storage三个指针，首先先看看vector的基本定义

template <class T, class Alloc = alloc>
class vector {
public:
    // 基本型别定义
    typedef T value_type;
    typedef value_type* pointer;
    typedef value_type* iterator;
    typedef value_type& reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
protected:
    // 空间配置器 只是对Alloc的进一步封装
    typedef simple_alloc<value_type, Alloc> data_allocator;
    // 关键的几个迭代器
    iterator start;
    iterator finish;
    iterator end_of_storage;
public:
    vector() : start(0), finish(0), end_of_storage(0) {}
    // 回收内存
    void deallocate() {
        if (start) data_allocator::deallocate(start, end_of_storage -    start);
    }
    ~vector() { 
        destroy(start, finish); // 对[start, finish)的元素调用相应的析构函数(如果是POD类型则什么都不做)
        deallocate();
    }
    // 提供简单的接口
    iterator begin() { return start; }
    iterator end() { return finish; }
    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); }
};

因为vector实现比较简单，所以就不一一的列出全部成员函数的实现了，主要还是关注其关于插入元素的实现。

先看看比较常用的push_back的实现。

void push_back(const T& x) {
    if (finish != end_of_storage) {
      construct(finish, x); // 调用placement new构造对象
      ++finish;
    }
    else // 容量不足的情况
      insert_aux(end(), x);
  }

insert_aux用于在position中插入元素，该函数还可以处理容量不足的情况

template <class T, class Alloc>
void vector<T, Alloc>::insert_aux(iterator position, const T& x) {
    // 有剩余空间
    if (finish != end_of_storage) {
        construct(finish, *(finish - 1));
        ++finish;
        T x_copy = x;
        copy_backward(position, finish - 2, finish - 1);
        *position = x_copy;
    }
    // 容量不足
    else {
        const size_type old_size = size();
        // 分配原来的两倍大小
        const size_type len = old_size != 0 ? 2 * old_size : 1;
        // 重新分配空间
        iterator new_start = data_allocator::allocate(len);
        iterator new_finish = new_start;
        try {
            // 将原来的内容复制到新的vector
            new_finish = uninitialized_copy(start, position, new_start);
            construct(new_finish, x);
            ++new_finish;
            new_finish = uninitialized_copy(position, finish, new_finish);
        }
        catch(...) {
            destroy(new_start, new_finish); 
            data_allocator::deallocate(new_start, len);
            throw;
        }
        // 析构并释放原来的vector
        destroy(begin(), end());
        deallocate();
        // 调整三个迭代器
        start = new_start;
        finish = new_finish;
        end_of_storage = new_start + len;
  }
}

普通的insert函数也是通过insert_aux实现的

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

对应的erase函数实现更加的简单

iterator erase(iterator position) {
    if (position + 1 != end())
        copy(position + 1, finish, position); 
    --finish;
    destroy(finish);
    return position;
}

iterator erase(iterator first, iterator last) {
    iterator i = copy(last, finish, first);
    destroy(i, finish);
    finish = finish - (last - first);
    return first;
}