C++ STL(五)容器_vector

vector(向量)：一个能够存放任意类型的动态数组。它是一个类模板，可用于表示多种不同的数据类型

所需头文件：#include<vector>

vector与数组的区别：

数组长度是固定的，在定义时就确定了数组的长度，不能在定义后修改数组长度，更不能添加或删除数组中的元素

vector长度是非固定的，可以随时改变数组的长度，添加或删除vector中元的元素

 

构造函数：

    vector<int> vA; //构造个空的vector
    vector<int> vB(5); //定义有5个int元素的vector (vB={0,0,0,0,0})
    vector<int> vC(5,1);//定义有5个int元素的vector，每个元素的值为1 (vC={1,1,1,1,1})
    vector<int> vD(vC); //通过vC拷贝构造一个vD (VD={1,1,1,1,1})
    int nArray[] = {1,2,3};
    int nLeng = sizeof(nArray)/sizeof(int);
    vector<int> vE(nArray, nArray+nLeng); //通过数组拷贝构造一个vE (vE={1,2,3})
    //使用迭代器构造
    vector<int> vv;
    vv.push_back(1);
    vv.push_back(2);
    vv.push_back(3);
    vv.push_back(4);
    vv.push_back(5);
    vector<int> vIt(vv.begin(),vv.end()); //正向迭代器方式构造vector (vIt={1,2,3,4,5})
    vector<int> vRit(vv.rbegin(), vv.rend()); //反向迭代器方式构造vector (vRit={5,4,3,2,1})

    //注意：
    //begin()与end()配套使用.   正向迭代器
    //rbegin()与rend()配套使用. 反向迭代器
    //begin()返回指向vector第一个元素的迭代器  end()返回指向vector最后一个元素+1位置的迭代器
    //rbegin()返回指向vector最后一个元素的迭代器  rend()返回指向vector第一个元素-1位置的迭代器

    return;

获取大小和容量：

empty()  返回vector是否为空

size()     返回vector大小

max_size()  返回vector所能存储的最大元素个数,这是由系统自动定义的值

capacity()  返回重新分配空间前所能容纳元素最大个数

resize()    重新设置size，如果变长，变长的元素部份使用默认值，变短就删除多余的元素.会自动修改size与capacity,此时size==capacity

reserve()  重新设置capacity，只会修改capacity，不会修改size

    vector<int> v;
    bool bEmpty = v.empty(); //bEmpty = true 是否为空
    v.push_back(1);
    v.push_back(2);
    bEmpty = v.empty(); //bEmpty = false
    int nLeng = v.size();  //nLeng = 2  容器大小
    int nMaxSize = v.max_size(); //nMaxSize = 1073741823 所能存储的最大元素个数,这是由系统自动定义的值
    int nCapacity = v.capacity(); //nCapacity = 2 重新分配空间前所能容纳元素最大个数

    //resize重新设置size，如果变长，变长的元素部份使用默认值，变短就删除多余的元素.
    //会自动修改size与capacity,此时size==capacity
    v.resize(10);
    nLeng = v.size(); //nLeng = 10
    nCapacity = v.capacity();//nCapacity = 10
    //reserve重新设置capacity,只会修改capacity,不会修改size
    v.reserve(20);
    nLeng = v.size(); //nLeng = 10
    nCapacity = v.capacity(); //nCapacity = 20

注意:size永远<=capacity, 当插入元素时有可能会根据size进行重新配置存储器，修改size和capacity，此时相关的迭代器将会失效

    //例：
    vector<int> vv;
    for (int i=0; i<20; i++)
    {
        vv.push_back(3);
        nLeng = vv.size();
        nCapacity = vv.capacity();
        printf("size=%d, capacity=%d
",nLeng, nCapacity);
    }

    //例：
    vector<int> vvv;
    vector<int>::iterator it = vvv.begin();
    for (int j=0; j<20; j++)
    {
        vvv.push_back(3);
    }
    //错误方法：
    for (it; it!=vvv.end(); ++it)
    {
        printf("%d ",*it);
    }

    //正确方法： 
    it = vvv.begin();//重新获取下迭代器
    for (it; it!=vvv.end(); ++it)
    {
        printf("%d ",*it);
    }

赋值操作：

数组[]和at()方式赋值

    //使用数组[]和at()方式赋值
    vector<int> vA(2);
    vA[0] = 10;  //vA = {10,0}
    vA.at(1) = 11; //vA = {10,11}

assign()方式赋值

    //使用assign()方式赋值
    vector<int> vC;
    //void assign(size_type _Count, const _Ty& _Val)
    vC.assign(2,6); //给vC赋值二个int型元素，元素值为6 (vC={6,6})
    //void assign(_Iter _First, _Iter _Last)
    vector<int> vD;
    vC.assign(vD.begin(),vD.end()); //使用迭代器方式把vD中所有元素赋值给vC (vC={})

    //使用swap()交换方式赋值
    vector<int> vE(2,3);
    vector<int> vF(4,4);
    vE.swap(vF); //vE = {4,4,4,4} VF = {3,3}

    return;

增加元素操作：

push_back()  往vector末尾插入一个元素

insert()  往vector任意位置插入一个元素，指定位置或者指定区间进行插入，第一个参数都是个迭代器。返回值是指向新元素的迭代器

    vector<int> vA;
    //使用push_back()方式
    vA.push_back(1); //vA中push一个1 (vA={1})

    //使用insert()方式插入元素, 第一个参数都是迭代器,返回值是指向新元素的迭代器
    vector<int>::iterator it;
    //iterator insert(const_iterator _Where, const _Ty& _Val) 指定位置插入
    it = vA.insert(vA.begin(),2); //往begin()之前插入一个int元素2 (vA={2,1}) 此时*it=2
    //void insert(const_iterator _Where, size_type _Count, const _Ty& _Val) 指定位置插入
    it = vA.insert(vA.end(),2,3);//往end()之前插入2个int元素3 (vA={2,1,3,3}) 此时*it=3
    //void insert(const_iterator _Where, _Iter _First, _Iter _Last) 指定区间插入
    vector<int> vB(3,6);
    it = vA.insert(vA.end(),vB.begin(),vB.end()); //把vB中所有元素插入到vA的end()之前 (vA={2,1,3,3,6,6,6})
    //此时*it=6,指向最后一个元素值为6的元素位置

    return;

删除元素操作：

pop_back()  从vector末尾删除一个元素

erase()  从vector任意位置删除一个元素，指定位置或者指定区间进行删除，第一个参数都是个迭代器。返回值是指向删除后的下一个元素的迭代器

clear()   清除vector中所有元素, size=0, 不会改变原有capacity值

    vector<int> vA;
    vA.push_back(1);
    vA.push_back(2);
    vA.push_back(3);
    vA.push_back(4);
    vA.push_back(5);
    //使用pop_back()方式
    vA.pop_back(); //pop掉最后一个元素 (vA={1,2,3,4})
    
    //使用erase()方式删除元素，第一个参数都是迭代器,返回值是指向删除后的下一个元素的迭代器
    vector<int>::iterator it;
    //iterator erase(const_iterator _Where) 指定位置删除
    it = vA.erase(vA.begin()); //删除Where位置的元素 (vA={2,3,4}) 此时*it=2
    //void _Reverse(pointer _First, pointer _Last) 指定区间删除
    it = vA.erase(vA.begin(),vA.end()); //把begin()到end()之间的所有元素删除 (vA={})
    //此时vector中己经没有元素了，迭代器指向的下一个元素就是删除前的第一个元素 *it=2

    //使用clear()方式清除所有元素,size变为0
    vector<int> vB(5,5);
    vB.clear(); //(vB={},size=0 capacity=5)
    
    return;

注意：不论是增加还是删除元素，迭代器都会发生改变，后续操作需要重新获取迭代器. 除末尾以外，其它位置插入或删除元素，都需要移动相关元素位置，执行效率低

遍历元素操作：

数组方式、迭代器方式

    vector<int> vv;
    vv.push_back(1);
    vv.push_back(2);
    vv.push_back(3);
    vv.push_back(4);
    vv.push_back(5);

    //使用数组方式正向遍历
    for (size_t i = 0; i<vv.size(); ++i)
    {
        cout<<vv[i]<<" ";
    }
    cout<<endl;
    //使用数组方式反向遍历
    for (size_t i = vv.size()-1; (int)i>=0; --i)
    {
        cout<<vv[i]<<" ";
    }
    cout<<endl;
    //使用正向迭代器方式遍历
    vector<int>::iterator it;
    it = vv.begin();
    for (it; it!=vv.end(); ++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
    //使用反向迭代器方式遍历
    vector<int>::reverse_iterator rit;
    rit = vv.rbegin();
    for (rit; rit!=vv.rend(); ++rit)
    {
        cout<<*rit<<" ";
    }

    return;

 释放内存操作：

使用swap()交换二个对象,使vector离开其自身的作用域，从而强制释放vector所占的内存空间

vector中元素是非指针的数据类型

    vector<int> v(10,1);
    v.clear();
    int nSize = v.size(); //nSize=0
    int nCapacity = v.capacity(); //nCapacity=10,此时并不能减少容量释放内存
    //使用空的vector与v进行交换
    vector<int>().swap(v);
    nSize = v.size(); //nSize=0
    nCapacity = v.capacity(); //nCapacity=0

vector中元素是指针的数据类型

    //new三个int型数据，定义三个指针用来保存，并且修改指针下的内容
    int* p1 = new int();
    *p1 = 1;
    int* p2 = new int();
    *p2 = 2;
    int* p3 = new int();
    *p3 = 3;
    //定义个int*的vector
    vector<int*> vv(3);
    vv[0] = p1;
    vv[1] = p2;
    vv[2] = p3;
    //遍历vector,把所有指针类型元素指向的内存空间进行delete
    vector<int*>::iterator it = vv.begin();   
    for (it; it!=vv.end(); ++it)
    {
         if(NULL != *it)
        {
                delete *it;
                *it = NULL;
        }
    }
    //使用空的vector与vv进行交换
    vector<int*>().swap(vv);


    //此时尝试访问指针下的内容,己经访问不到了,说明己经确定释放了内存空间
    int nValue = *p1;
    nValue = *p2;
    nValue = *p3;
    //vector的Size与Capacity全为0，说明vector占用的内存空间也己经成功释放
    nSize = vv.size(); //nSize=0
    nCapacity = vv.capacity();//nCapacity=0

小练习题：

定义一个int型vector,包含1,3,2,3,3,3,4,3,5,3

删除容器中所有等于3的元素，最后遍历输出剩余元素

    //定义一个int型vector,包含1,3,2,3,3,3,4,3,5,3
    //删除容器中所有等于3的元素，最后遍历输出剩余元素
    
    int nArray[] = {1,3,2,3,3,3,4,3,5,3};
    vector<int> vA(nArray, nArray+10);
    vector<int>::iterator it = vA.begin();

    while (it!=vA.end())
    {
        if(*it == 3)
        {
            //删除当前迭代器指向的元素，然后接收返回指向下个元素的迭代器赋值给it,接着遍历
            it = vA.erase(it); 
        }else
        {
            ++it;
        }
    }

    for (it = vA.begin(); it!=vA.end(); ++it)
    {
        cout<<*it<<" ";
    }
    //输出: 1 2 4 5

    return;