关于c++:STLvector内部实现原理及基本用法

insert函数：

//插入 在值为value的一个元素到position的地位上
    void insert(iterator position, const T& value){
        insert(position, 1, value);
    }

    //在position地位之后，插入n的值为value的元素
    void insert(iterator position, size_type n, const T& value){
        if (n == 0)return;

        if ((end_of_storage - finish) >= n){//备用空间够插入n个新元素
            T x_copy = value;
            const  size_type size_from_position_to_end = finish - position;

            iterator old_finish = finish;
            if (size_from_position_to_end > n){
                //先从pos到oldfinish拿出后n个数，放到前面
                //再将pos到剩下的几个数向后挪动到oldfinish
                //插入n个value到pos->pos+n
                __copy(finish - n, finish, finish);
                finish += n;
                __backCopy(position, old_finish - n, old_finish);
                __fill(position, position + n, x_copy);
            }
            else{
                //在前面先插入多的value，而后再将pos到oldfinish的拿进去插到前面
                //而后将剩下的value放到pos到oldfinsh
                __fill_n(finish, n - size_from_position_to_end, x_copy);
                finish += n - size_from_position_to_end;
                __copy(position, old_finish, finish);
                finish += size_from_position_to_end;
                __fill(position, old_finish, x_copy);//在
            }
        }
        else{
            //从新申请空间
            const size_type old_size = size();
            size_type _max = 0;
            if (old_size > n) _max = old_size;
            else _max = n;
            const size_type len = old_size + _max;
            iterator new_start = (iterator)malloc(len * sizeof(T));
            iterator new_finish = new_start;
            //内存的调配要有原子性，即:要么全副胜利，要么全副失败。
            try{
                new_finish = __copy(begin(), position, new_start);//1.将原内容 至position的所有元素(不蕴含position) 拷贝到新的vector
                new_finish = __fill_n(new_finish, n, value);//2.将position地位到前面的n个元素都填充为value
                new_finish = __copy(position, end(), new_finish);//3.拷贝从 position地位到end()地位的原vector的所有残余元素
            }
            catch (...)//如果失败了
            {
                destroy(new_start, new_finish);
                free(new_start);//删除申请到的内存
                new_start = new_finish = NULL;
                throw;        //抛出异样
            }
            //析构并开释原vector
            destroy(begin(), end());
            //删除内存
            free(start);
            //调整迭代器，指向新的vector
            start = new_start;
            finish = new_finish;
            end_of_storage = new_start + len;
        }
    }

//重载操作符
    reference operator[](size_type n){ return *(begin() + n); }//取 第n个元素
    const_reference operator[](size_type n) const{ return *(begin() + n); }

    //两个容器是否相等（每个元素）
    bool operator==(const myVector&v){
        if (v.size() != size())return false;
        iterator it;
        for (it = v.begin(); it 

#pragma once

template
inline void construct(T1 *p, const T2 &value){
    new (p)T1(value);      //用placement new在所指对象上创立一个对象，value是初始化对象的值
}

template
inline void destroy(T* pointer){//只做了一层包装，将指针所指的对象析构--通过间接调用类的析构函数
    pointer->~T();
}

template
inline void destroy(ForwardIterator first, ForwardIterator last){//destroy的泛化版 承受两个迭代器为参数
    for (; first 

void display(const myVector &v){
    for (myVector::iterator it = v.begin(); it != v.end(); ++it){
        cout <<*it <<" ";
    }
    cout < v(100);
    v.push_back(10);
    v.push_back(9);
    v.push_back(8);
    v.push_back(7);
    v.push_back(6);
    v.push_back(5);
    for (int i = 0; i ::iterator it;
    for (it = v.begin(); it != v.end(); ++it){
        cout <<*it <<" ";
    }
    cout <

void test1(){
    cout <<"test1--------" < v(100);
    v.push_back(10);
    v.push_back(9);
    v.push_back(8);
    v.push_back(7);
    v.push_back(6);
    v.push_back(5);

    myVector::iterator it = v.begin() + 3;

    v.insert(it, 3, 300); display(v);
    v.insert(it, 4, 500); display(v);
    v.insert(it, 2, 200); display(v);
    v.insert(it, 2, 20); display(v);
    v.insert(it, 3, 30); display(v);
    v.insert(it, 4, 40); display(v);
}

void test2(){
    cout <<"test2--------" < v(100);
    v.push_back(10);
    v.push_back(9);
    v.push_back(8);
    v.push_back(7);
    v.push_back(6);
    v.push_back(5);

    myVector::iterator it = v.begin();

    v.insert(it, 300); display(v);
    v.insert(it, 500); display(v);
    v.insert(it, 200); display(v);
    v.insert(it, 20); display(v);
    v.insert(it, 30); display(v);
    v.insert(it, 40); display(v);
}

/*
test--------
10 9 8 7 6 5 
10 9 8 7 6 5 
size: 6
test1--------
10 9 8 300 300 300 7 6 5 
10 9 8 500 500 500 500 300 300 300 7 6 5 
10 9 8 200 200 500 500 500 500 300 300 300 7 6 5 
10 9 8 20 20 200 200 500 500 500 500 300 300 300 7 6 5 
10 9 8 30 30 30 20 20 200 200 500 500 500 500 300 300 300 7 6 5 
10 9 8 40 40 40 40 30 30 30 20 20 200 200 500 500 500 500 300 300 300 7 6 5 
test2--------
300 10 9 8 7 6 5 
500 300 10 9 8 7 6 5 
200 500 300 10 9 8 7 6 5 
20 200 500 300 10 9 8 7 6 5 
30 20 200 500 300 10 9 8 7 6 5 
40 30 20 200 500 300 10 9 8 7 6 5 
Program ended with exit code: 0
*/