STL_学习_vector容器源码解析

这里自己总结了自己对SGI的vector容器的操作原理的一点理解。

#ifndef _STL_VECTOR_H_
#define _STL_VECTOR_H_

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;
    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;
protected:
    //定义一个空间配置器，以元素大小为配置单位，也就是value_type类型的大小为配置单位
    typedef simple_alloc<value_type, Alloc> data_allocator;
    //目前使用空间的头
    iterator start;
    //目前使用空间的尾
    iterator finish;
    //目前可用空间的尾
    iterator end_of_storage;
    //负责释放空间
    void deallocate()
    {
        if(start){
            data_allocator::deallocate(start, end_of_storage - start);
        }
    }
    //填充空间并且进行初始化
    void fill_initialize(size_type n, const T& value)
    {
        start = allocate_and_fill(n, value);
        finish = start + n;
        end_of_storage = finish;
    }

    iterator allocate_and_fill(size_type n, const T& x)
    {
        iterator result = data_allocator::allocate(n);
        uninitialized_fill_n(result, n, x);
        return result;
    }

//以下是vector容器提供的相应的接口，这里没有写全
public:
    iterator begin(){return start;}//返回容器的起始位置
    iterator end(){return finish;}//返回容器的结束位置
    size_type size(){return size_type(end() - begin());}//使用空间的大小
   //返回容器的大小
    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);}
    
public:
    //5个构造函数的重载
    vector():start(0),finish(0),end_of_storage(0){}
    vector(size_type n, const T& value)
    {
        fill_initialize(n, value);
    }
    vector(int n, const T& value){fill_initialize(n, value);}
    vector(long n, const T& value){fill_initialize(n, value);}
    vector(size_type n){fill_initialize(n, T());}

    ~vector()
    {
        destroy(start, finish);
        deallocate();
    }

    reference front(){return *begin();}//返回容器第一个元素的值
    reference back(){return *(end() - 1);}
    //尾插
    void push_back(const T & x)
    {
        if(finish != end_of_storage){
            construct(finish, x);
            ++finish;
        }
        //如果空间不足则调用insert_aux()
        else{
            insert_aux(end(), x);
        }
    }
    //尾删，这里注意尾删只是将最后一个元素删除但是空间并没有释放
    void pop_back()
    {
        --finish;
        destory(finish);
    }
    //删除范围内的元素
    iterator erase(iterator first, iterator last)
    {
        iterator i = copy(last, finish, first);
        destory(i, finish);
        finish = finish - (last - first);
        return first;
    }
    //删除某个位置上的元素（将删除位置后面的元素直接往前移动覆盖掉要删除的元素即可）
    iterator erase(iterator position)
    {
        if(position + 1 != end()){
            copy(position + 1, finish, position);
        }
        --finish;
        destory(finish);
        return position;
    }
    //清空容器
    void clear()
    {
        erase(begin(), end());
    }
    //插入
    void insert(iterator position, size_type n, const T & x);


};

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;
    }
    //没有空间则扩充空间（申请新的空间大小为旧空间的2倍，拷贝元素到新空间，释放旧空间）
    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;
        new_finish = uninitialzed_copy(start, position, new_start);
        construct(new_finish, x);
        ++new_finish;
        new_finish = uninitialzed_copy(position, finish, new_finish);
        
    }
    destory(begin(), end());
    deallocate();
    start = new_start;
    finish = new_finish;
    end_of_storage = new_start + len;
    
}
//这里的插入操作分为2类
//（1）有足够的空间
//     （1）判断插入的元素个数如果小于插入点之后的元素个数，先确定新的finish，然后再将插入
//          点后面的元素拷贝到old_finish，最后填充要插入的元素
//     （2）插入的元素个数大于等于插入点之后的元素个数，先将要插入的元素的结束位置固定好，
//          然后将插入点以后的元素拷贝到之前固定好的结束位置处，最后填充要插入的元素
//（2）空间不足
template<class T, class Alloc>
void vector<T, Alloc>::insert(iterator position, size_type n, T& x)
{
    if(n != 0){
        if(n < (size_type)(end_of_storage - finish)){
            T x_copy = x;
            const size_type elems_after = finish - position;
            iterator old_finish = finish;
            if(elems_after > n){
               uninitialized_copy(finish - n, finish, finish);
               finish += n;
               copy_backward(position, old_finish - n, old_finish);
               fill(position, position + n, x_copy);
            }
            else{
                uninitialized_fill_n(finish, n - elems_after, x_copy);
                finish += n - elems_after;
                uninitialized_copy(position, old_finish, finish);
                finish += elems_after;
                fill(position, position + n, 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);
            iteratoe new_finish = new_start;
            new_finish = uninitialized_copy(start, position, new_start);
            new_finish = uninitialized_fill_n(new_finish, n, x);
            new_finish = uninitialized_copy(position, finish, new_finish);
      
            destory(start, finish);
            deallocate();

            start = new_start;
            finish = new_finish;
            end_of_storage = finish + len;
        }
        
    }
}

#endif