大胖的部落格

vector是一个能够存放任意类型的动态数组，时刻保证vector内的元素是在容器前部，元素间没有间隔。

reserve：
1、变小时，没有操作
2、变大时，将原vector的元素拷贝至新空间，销毁原vector的元素。

resize：
1、size变大超出capacity时，分配新空间,创建临时对象，并拷贝一份；调用拷贝构造函数复制原对象到新空间,剩余新空间用临时对象的拷贝填充。
2、size变大没有超出capacity时，创建临时对象，并拷贝一份，新空间用临时对象的拷贝填充。
3、size变小时，创建临时对象，销毁额外size里的对象，销毁临时对象。

添加元素：
1、从尾部添加元素时，都是构造临时对象，调用拷贝构造函数向vector中添加。
2、插入元素时，若容量足够，创建临时对象，拷贝一份；将尾部元素向后拷贝；从后往前调用赋值操作符将元素向后挪，最后将第一个临时对象的拷贝赋值给插入位置的元素。
3、容量不够时，分配新空间，增加原容量的一半，创建临时对象，并拷贝一份；调用拷贝构造函数复制原对象到新空间，拷贝临时对象的拷贝至新空间。

删除元素：
1、从尾部删除元素时，直接销毁最后一个元素。
2、从中间删除元素时，调用元素的复制操作符将后面的元素向前赋值，销毁最后一个元素。

class A
{
public:
    A()
    {
        cout<<"default ";
        ++index;
        value=index;
        cout<<value<<endl;
    }

    A(int i)
    {
        cout<<"spec ";
        ++index;
        value=index;
        cout<<value<<endl;
    }

    A(const A& a)
    {
        cout<<"copy ";
        ++index;
        value=index;
        cout<<a.value<<" to "<<value<<endl;
    }

    A& operator=(const A& a)
    {
        cout<<"assign "; 
        cout<<a.value<<" to "<<value<<endl;
        value = a.value;
        return *this;
    }

    ~A() 
    {
        cout<<"des ";
        cout<<value<<endl;
    }

    static int index;
    int value;
};

int A::index = 0;

    vector<A> vA;                                    //创建一个空的vector，不包含任何元素
    cout<<vA.size()<<" "<<vA.capacity()<<endl;        //0，0

    vector<A> vB(4);                                //调用A的默认构造函数创建临时对象，创建临时对象的4个拷贝，放入vector中
    cout<<vB.size()<<" "<<vB.capacity()<<endl;        //4，4

    vector<A> vC(4, A(5));                            //调用A的指定构造函数创建临时对象，创建临时对象的4个拷贝，放入vector中

    vector<A> vD(vC);                                //将目标vector中的对象分别拷贝到当前vector中，当前vector的容量与size一样

    vector<A> vE(vB.begin(),vB.end());                //将目标区间内的元素拷贝到当前vector中

    vB.~vector<A>();                                //销毁所有对象，释放内存
    cout<<vB.size()<<" "<<vB.capacity()<<endl;        //0，0

    vector<A> v;                                //创建一个空的vector，不包含任何元素
    cout<<v.size()<<" "<<v.capacity()<<endl;    //0，0

    //resize关注的是size
    v.resize(3);                                //resize变大时，创建对象，分配内存，拷贝
    cout<<v.size()<<" "<<v.capacity()<<endl;    //3，3

    v.resize(2);                                //resize变小时，销毁对象，内存不变
    cout<<v.size()<<" "<<v.capacity()<<endl;    //2，3

    //reserve关注的是capacity
    v.reserve(5);                                //reserve变大时，重新分配内存，拷贝之前的对象
    cout<<v.size()<<" "<<v.capacity()<<endl;    //2，5

    v.reserve(3);                                //reserve变小时，内存不变
    cout<<v.size()<<" "<<v.capacity()<<endl;    //2，5

    //通过插入元素增加capacity时，增加量是当前capacity的一半（VC编译器）
    vector<int> vi;
    for(int i=0; i<20; ++i)
    {
        vi.push_back(i);
        cout<<vi.size()<<" "<<vi.capacity()<<endl;
    }

    vector<A> v(10);

    vector<A>::iterator it = v.begin();
    it=v.begin();
    for(int i=0; i<3; ++i)
        it++;

    v.insert(it, A());                    //在it指向的位置插入新元素，返回新元素位置
    v.erase(it);                        //删除it指向位置的数据，返回下一元素位置

    v.push_back(A());                    //从尾部加入一个新元素
    v.pop_back();                        //删除尾部元素

    v.assign(6, A());                    //将6个新元素赋值给vector
    v.clear();                            //删除所有元素，内存不变

    vector<A> vv;
    swap(v,vv);                            //将两个vector中的内容交换，包括元素、内存

    vector<int> v(10);

    cout<<v[4]<<v.at(5)<<endl;                    //通过数组下标和at()访问元素
    
    cout<<v.front()<<v.back()<<endl;            //front()返回第一个元素，back()返回的是最后一个元素

    cout<<v.size()<<v.capacity()<<endl;            //size()返回元素个数，capacity()返回vector容量
    
    cout<<v.max_size()<<endl;                    //max_size()返回可容纳元素的最大数量，理论值

    cout<<boolalpha<<v.empty()<<endl;            //empty()返回vector是否为空

    vector<int>::iterator it;
    for(it=v.begin(); it!=v.end(); it++)        //begin()返回iterator指向第一个元素，
    {                                            //end()返回iterator指向最后一个元素后面一个位置
        cout<<*it<<endl;
    }

    vector<int>::reverse_iterator rit;
    for(rit=v.rbegin(); rit!=v.rend(); rit++)    //rbegin()返回reverse_iterator指向最后一个元素，
    {                                            //rend()返回reverse_iterator指向第一个元素前面一个位置
        cout<<*it<<endl;
    }

    vector<bool> v(6);        //bool型的vector每个元素只占一个bit
    
    v.flip();                //所有元素取反
    v[3].flip();            //单个元素取反