vector介绍

vector(向量，也可称为容器): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.

1.1   用法

首先在程序开头处加上#include<vector>

还有一定要加上using namespace std;

#include <vector>
using namespace std;
vector<int> vec;

1.2   基本操作

1. push_back

在数组的最后添加一个数据;vec.push_back(num)

2. pop_back

去掉数组的最后一个数据; vec.pop_back(num)

3. at

得到编号位置的数据

4. begin

得到数组头的指针

5. end

得到数组的最后一个单元+1的指针

6.front

得到数组头的引用

7. back

得到数组的最后一个单元的引用

8. max_size

得到vector最大可以是多大

9. capacity

当前vector分配的大小；

返回Vector（容器）在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素，而不是还可以容纳多少元素。如果你想知道一个vector或string中有多少没有被占用的内存，你必须从capacity()中减去size()。如果size和capacity返回同样的值，容器中就没有剩余空间了，而下一次插入（通过insert或push_back等）会引发上面的重新分配步骤。

10. size

Vector中有多少元素。并不能说明Vector为它容纳的元素分配了多少内存。

成员函数size返回相应的vector类定义的size_type的值。使用方式vector<type>::size_type

   for(vector<int>::size_type i = 0; i != vec.size(); i++) {
        printf("%3d", vec[i]);
    }

11. resize

改变当前使用数据的大小，如果它比当前使用的大，者填充默认值。

强制把Vector改为容纳n个元素。调用resize之后，size将会返回n。如果n小于当前大小，容器尾部的元素会被销毁。如果n大于当前大小，新默认构造的元素会添加到容器尾部。如果n大于当前容量，在元素加入之前会发生重新分配。

12.reserve

改变当前vecotr所分配空间的大小。

使用reserve()函数提前设定容量大小，避免多次容量扩充操作导致效率低下。

强制vecotr把它的容量改为至少n，提供的n不小于当前大小。这一般强迫进行一次重新分配，因为容量需要增加。（如果n小于当前容量，vector忽略它，这个调用什么都不做，string可能把它的容量减少为size()和n中大的数，但string的大小没有改变。

13.erase

删除指针指向的数据项

14.clear

清空当前的vector

15.rbegin

将vector反转后的开始指针返回(其实就是原来的end-1)

16.rend

将vector反转构的结束指针返回(其实就是原来的begin-1)

17.empty

判断vector是否为空

18.swap

与另一个vector交换数据

1.3   resize与reserve的区别

关于STL容器，最令人称赞的特性之一就是是只要不超过它们的最大大小，它们就可以自动增长到足以容纳你放进去的数据。（要知道这个最大值，只要调用名叫max_size的成员函数）

对于vector和string，如果需要更多空间，就以类似realloc的思想来增长大小。vector容器支持随机访问，因此为了提高效率，它内部使用动态数组的方式实现的。在通过 reserve()
来申请特定大小的时候总是按指数边界来增大其内部缓冲区。当进行insert或push_back等增加元素的操作时，如果此时动态数组的内存不够用，就要动态的重新分配当前大小的1.5~2倍的新内存区，再把原数组的内容复制过去。所以，在一般情况下，其访问速度同一般数组，只有在重新分配发生时，其性能才会下降。正如上面的代码告诉你的那样。而进行pop_back操作时，capacity并不会因为vector容器里的元素减少而有所下降，还会维持操作之前的大小。对于vector容器来说，如果有大量的数据需要进行push_back，应当使用reserve()函数提前设定其容量大小，否则会出现许多次容量扩充操作，导致效率低下。

使用reserve()函数提前设定容量大小，避免多次容量扩充操作导致效率低下。

例如：假定你想建立一个容纳1-1000值的vector<int>。没有使用reserve，你可以像这样来做：

vector<int> v;
for (int i = 1; i <= 1000; ++i)
v.push_back(i);

在大多数STL实现中，这段代码在循环过程中将会导致2到10次重新分配。（10这个数没什么奇怪的。记住vector在重新分配发生时一般把容量翻倍，而1000约等于210。）

把代码改为使用reserve，我们得到这个：

vector<int> v;
v.reserve(1000);
for (int i = 1; i <= 1000; ++i)
v.push_back(i);

这在循环中不会发生重新分配。

在大小和容量之间的关系让我们可以预言什么时候插入将引起vector或string执行重新分配，而且，可以预言什么时候插入会使指向容器中的迭代器、指针和引用失效。例如，给出这段代码，

string s;
...
if (s.size() < s.capacity()) {
s.push_back('x');
}

push_back的调用不会使指向这个string中的迭代器、指针或引用失效，因为string的容量保证大于它的大小。如果不是执行push_back，代码在string的任意位置进行一个insert，我们仍然可以保证在插入期间没有发生重新分配，但是，与伴随string插入时迭代器失效的一般规则一致，所有从插入位置到string结尾的迭代器/指针/引用将失效。

回到本条款的主旨，通常有两情况使用reserve来避免不必要的重新分配。第一个可用的情况是当你确切或者大约知道有多少元素将最后出现在容器中。那样的话，就像上面的vector代码，你只是提前reserve适当数量的空间。第二种情况是保留你可能需要的最大的空间，然后，一旦你添加完全部数据，修整掉任何多余的容量。

1.4   示例

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <vector>
#include <iostream>

using namespace std;

#define ELE_MAX_COUNT       150
#define ELE_DEFAULT_COUNT   3
#define ELE_MAX_VALUE       100

vector<int> vec;

/*
 * rand()函数是按指定的顺序来产生整数，因此每次执行上面的语句都打印相同的两个值
 * 因此C语言的随即并不是正真意义上的随机。为了时程序在每次执行时都能生成一个
 * 新序列的随机值，通常通过为随机数生成器提供一粒新的随机种子。
 * 函数srand()(来自stdlib.h)可以为随机数生成器播散种子。
 * 只要种子不同rand()函数就会产生不同的随机数序列。
 * srand()称为随机数生成器的初始化器。
 */

void initVec()
{
    int i = 0;

    srand((int)time(0));
    for(i = 0; i < ELE_DEFAULT_COUNT * 5; i++) {
        cout << "Vec size(" << vec.size()
             << ") capacity(" << vec.capacity() <<")!"
             << endl;
        /*
         * push_back:在vector的末尾增加一个元素
         * rand: 获取随机数
         */
        vec.push_back(rand() % ELE_MAX_VALUE + 1);
    }

    return ;
}

void filterVec()
{
    for(vector<int>::size_type i = 0; i != vec.size(); i++) {
        if (-1 == vec[i]) {
            vec.erase(vec.begin()+i);
            i--;
        }
    }

    return ;
}

void dumpVec()
{
    printf("VecValue:");
    for(vector<int>::iterator iter = vec.begin(); iter != vec.end(); iter++) {
        printf("%3d ", *iter);
    }
    printf("\n");

    return ;
}

void quicksortVec(vector<int> &v, int left, int right)
{
    if (left < right) {
        int key = v[left];
        int low = left;
        int high = right;
        while (low < high) {
            if (v[high] >= key) {
                high--;
            }
            v[low] = v[high];
            if (v[low] < key){
                low++;
            }
            v[high] = v[low];
        }
        v[low] = key;
        quicksortVec(v, left, low - 1);
        quicksortVec(v, low + 1, right);
    }
}

int main(int argc, char *argv[])
{
    if (vec.empty()) {
        /* endl默认添加换行符 */
        cout << "vector is NULL!" << endl;
        vec.resize(ELE_DEFAULT_COUNT, -1);
    }

    initVec();
    /* 判断是否为空 */
    if (vec.empty()) {
        cout << "vector is NULL!" << endl;
        return 0;
    } else {
        cout << "vector is NOT NULL! Size is "<< vec.size() << endl;
    }
    dumpVec();
    filterVec();
    dumpVec();

    quicksortVec(vec, 0, vec.size() - 1);
    dumpVec();
    /* 清空vector */
    vec.clear();
    if (vec.empty()) {
        cout << "vector is NULL!" << endl;
    }
    return 0;
}

结果：

vector is NULL!
Vec size(3) capacity(3)!
Vec size(4) capacity(6)!
Vec size(5) capacity(6)!
Vec size(6) capacity(6)!
Vec size(7) capacity(12)!
Vec size(8) capacity(12)!
Vec size(9) capacity(12)!
Vec size(10) capacity(12)!
Vec size(11) capacity(12)!
Vec size(12) capacity(12)!
Vec size(13) capacity(24)!
Vec size(14) capacity(24)!
Vec size(15) capacity(24)!
Vec size(16) capacity(24)!
Vec size(17) capacity(24)!
vector is NOT NULL! Size is 18
VecValue: -1  -1  -1   8  51  60  42  76  88  39  74  42  70  35  29  33  67  61
VecValue:  8  51  60  42  76  88  39  74  42  70  35  29  33  67  61
VecValue:  8  29  33  35  39  42  42  51  60  61  67  70  74  76  88
vector is NULL!