STL学习笔记-- vector

vector 向量容器

    作为数组的一个泛化推广的 vector 容器，不仅可以进行数组一样的元素随机访问，还可以在容器的尾端插入新元素，是一个实现了 Random Access Container 和 Back Insertion Sequence 概念的模型 
    vector 是一种简单、高效的容器。在尾端插入和删除元素，算法时间复杂度为 O(1) 常数阶，其他元素的插入删除为 O(n) 线型阶，其中 n 为 vector 容器的元素个数。 vector 具有自动的内存管理功能，对于元素的插入和删除，可动态调整所占用的内存空间。

    vector 容器的 C++ 标准头文件为 vector， 因此，必须将宏语句 "#include <vector>" 包含到cpp文件中，才可正确编译使用。

创建 vector 对象
如下4个vector的构造函数，均可创建一个vector对象
1.    vector(const A& a = A())
    创建一个空的 vector 对象，A 是内存分配器，此参数可以省略，相当于一个 vector() 的调用。
例如，下面一行代码创建了一个 vector 对象 vInt
    vector<int>  vInt;  

2.    vector(size_type n)
     创建一个具有 n 个元素的 vector 对象，每个 vector 元素具有它的类型下的默认值。此时， n 个 vector 元素的内存空间已被分配。
例如，下面一行代码创建了具有 10 个元素的 vector 对象 vDou，每个元素的默认值为 0.0
    vector<double>  vDou(10);
    
3.    vector(size_type n, const T& value)
    创建一个具有 n 个元素的 vector 对象，每个元素具有初始值 value 。
例如，下面一行代码创建了一个具有 10 个元素的 vector 对象 vDou, 每个元素的初始值为 9.3
    vector<double>  vDou(10, 9.3);
    
4.    vector(const vector&)
    通过拷贝一个 vector 对象的各个元素值，创建一个新的 vector 对象。
例如，下面使用 v1 对象 创建 v2 对象，此时，v2 对象的 5 个元素也具有字符值 "K"
    vector<char>  v1(5,'K');
    vector<char>  v2(v1);

这是第五种创建方法   
5.    vector(const InputInerator first, const InputIterator last, const A& a = A())
    InputIterator 为输入迭代器，通过拷贝迭代器区间 [first, last ) 的元素值，创建一个新的vector对象，内存分配器可省略。
例如，利用 int 数组 iArray 各元素值，创建了 vector 对象 v
    int iArray[] = {11, 13, 19, 23, 28};
    vector<int>  v(iArray, iArray + 5);

// 创建对象之后，再赋值的方法，  assign 函数
vector<int> vecIntA, vecIntB, vecIntC;
int  iArray[] = {0,1,2,3,4};
vecIntA.assign(iArray,iArray+5);

vecIntB.assign( vecIntA.begin(),  vecIntA.end() );    //用其它容器的迭代器作参数。

vecIntC.assign(3,9);  // 在对象vecIntC中添加 3 个元素，元素值值为 9

vector<int> vecIntD;  // 直接赋值也可以，这是深拷贝，赋值之后，vecIntA 中的值改变，不会影响vecIntD
vecIntD = vecIntA;

 

初始化赋值
vector 提供的 push_back() 函数，常用来进行 vector 容器的初始化。 push_back() 函数在容器的尾端插入新元素。


元素的遍历访问
 vector 的元素可以采用数组，.at() 函数或者迭代器的方式进行遍历访问。

 

#include <vector>
#include <iostream>
using namespace std;
int main()
{
    vector<int> vInt;
    vInt.push_back(20);
    vInt.push_back(26);
    vInt.push_back(39);
    
//    cout << "VInt【2】 = " << vInt[2] <<endl;
//    cout << "VInt【3】 = " << vInt[3] <<endl;
//    cout << "VInt【4】 = " << vInt[4] <<endl << endl << endl;
//    
//    cout << "VInt【2】 = " << vInt.at(2) <<endl;    
//    cout << "VInt【3】 = " << vInt.at(3) <<endl;
//    cout << "VInt【4】 = " << vInt.at(4) <<endl;
    

    for (int i=0; i<vInt.size(); i++)
    {
        // vInt[i] 为数组方式的访问。访问越界时，不产生异常
        //cout << "VInt【" << i << "】 = " << vInt[i] <<endl;
        
        // vInt.at(i) 为函数访问方式。当访问越界时，会抛出异常
        cout << "VInt【" << i << "】 = " << vInt.at(i) <<endl;
    }


    return 0;
}

 

 

#include <vector>
#include <iostream>
using namespace std;
int main()
{
    vector<int> vInt;
    vInt.push_back(20);
    vInt.push_back(26);
    vInt.push_back(39);

    // 起始 和 末尾 迭代器值 
    vector<int>::iterator i, iend;
    iend = vInt.end();
    int j;
    for (i=vInt.begin(), j=0; i!=iend; i++, j++)
    {
        cout << "v[" << j << "] = " << *i << endl;
    }

    return 0;
}

 

 

/*        解释：
    不同于在 vector 容器尾部添加元素的 push_back 函数， insert 函数可以在任意位置插入元素。
由于插入时，需要先将插入位置后面的元素移位，以空出一个位置进行插入，因此，insert 函数的执行比较 push_back 函数较为耗时。
*/

-------------------------------- 在任意位置插入 vector 元素
#include <vector>
#include <iostream>
using namespace std;
int main()
{
    vector<int> vInt;
    vInt.push_back(6);
    vInt.push_back(7);
    vInt.push_back(8);
    vInt.push_back(10);
    // 在元素 10 的前面插入 9
    vInt.insert(vInt.begin() + 3, 9);
    // 插入 5 为首元素
    vInt.insert(vInt.begin(), 5);
    // 插入 11 为末元素
    vInt.insert(vInt.end(), 11);

    for (int i=0; i<vInt.size(); i++)
    {
        cout << "V[" << i << "]=" << vInt[i] << endl;
    }

    return 0;
}

 

 

 

---------------------------------------- 利用 erase 函数删除 vector 元素
#include <iostream>
#include <vector>
using namespace std;
class MyAnimal
{
public:
    char* m_name;
    int m_age;
public:
    MyAnimal(char* name, int age)
    {
        this->m_name = name;
        this->m_age = age;
    }
    ~MyAnimal(){}

};

int main()
{
    MyAnimal* pDog = new MyAnimal("dog", 1);
    MyAnimal* pMonkey = new MyAnimal("monkey", 2);
    MyAnimal* pChicken = new MyAnimal("chicken", 3);
    MyAnimal* pSnake = new MyAnimal("snake", 4);

    // v 将存放各对象的地址
    vector<MyAnimal*> v;
    v.push_back(pDog);
    v.push_back(pMonkey);
    v.push_back(pChicken);
    v.push_back(pSnake);

    // 物理删除 pMonkey 所指的对象
    delete pMonkey;
    // 删除第 2 个元素，即删除 vector 容器的元素 pMonkey
    v.erase(v.begin()+1);
    vector<MyAnimal*>::iterator i, iend;
    iend = v.end();
    for (i=v.begin(); i!=iend; ++i)
    {
        cout << (*i)->m_name << ' ' << (*i)->m_age <<endl;
    }
    // 清除所有 vector 元素
    v.clear();
    cout << " 执行 clear() " << endl << "vector 元素已全部清除。" <<endl;

    return 0;
}

 

-------- erase 的补充
 vecInt是用vector<int>声明的容器，现已包含按顺序的1,3,2,3,3,3,4,3,5,3元素。现要求删除容器中所有等于3的元素。
for(vector<int>::iterator it=vecInt.begin(); it!=vecInt.end(); )    //小括号里不需写  ++it
{
    if(*it == 3)
   {
        it  =  vecInt.erase(it);       //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。
         //此时，不执行  ++it；  
   }
    else
   {
       ++it;
   }
}

 

 

 

-------------------------------------------------- 反向遍历 vector 的元素
#include <vector>
#include <iostream>
using namespace std;
int main()
{
    vector<int> vInt;
    vInt.push_back(1);
    vInt.push_back(3);
    vInt.push_back(5);
    vInt.push_back(7);
    vInt.push_back(9);
    // 元素的反向遍历访问
    vector<int>::reverse_iterator ri,riend;
    riend = vInt.rend();
    for (ri=vInt.rbegin(); ri!=riend; ++ri)
    {
        cout << *ri << endl;
    }

    return 0;
}

 

 

-------------------------------------------------- 两个 vector 容器元素的交换
#include <vector>
#include <iostream>
using namespace std;
void print(vector<int>& vInt);
int main()
{
    //vIntA
    vector<int> vIntA;
    vIntA.push_back(11);
    vIntA.push_back(12);
    vIntA.push_back(13);
    cout << " vIntA = ";
    print(vIntA);

    //vIntB
    vector<int> vIntB;
    vIntB.push_back(90);
    vIntB.push_back(92);
    cout<< " vIntB = ";
    print(vIntB);

    // vIntA 与 vIntB 交换
    swap(vIntA, vIntB);
    cout << "vIntA 与 vIntB 交换后" << endl;
    cout << "vIntA =";
    print(vIntA);
    cout << "vIntB =";
    print(vIntB);

    return 0;
}

// vector 元素打印
void print(vector<int>& v)
{
    for (int i=0; i<v.size(); i++)
        cout<< v[i] << "  " ;
    cout << endl;
}

 

 

/*        解释：
1. bool empty()  判断容器 vector 是否为空，若容器没有一个元素则返回 true, 否则返回 false
2. size_type size()  当前 vector 容器的实际元素个数
3. size_type max_size()  系统所允许的 vector 容器的最大元素个数
4. size_type capacity()  当前可容纳的 vector 元素个数
5. reference front()  vector容器的首元素（引用），要求 vector 不为空
6. reference back()  vector容器的末元素（引用），要求 vector 不为空
7. void pop_back()  与 push_back() 函数相反，pop_back() 函数用于删除末尾的一个容器元素
*/

-------------------------------- vector 的其他常用函数
#include <vector>
#include <iostream>
using namespace std;
void print(vector<int>& v);
int main()
{
    vector<int> vInt;
    print(vInt);
    // 添加 5 个元素
    vInt.push_back(1);
    vInt.push_back(2);
    vInt.push_back(3);
    vInt.push_back(4);
    vInt.push_back(5);
    print(vInt);

    // 再添加 4 个元素
    vInt.push_back(6);
    vInt.push_back(7);
    vInt.push_back(8);
    vInt.push_back(9);
    print(vInt);

    // 调整 vector 数据空间大小
    vInt.reserve(30);
    print(vInt);

    return 0;
}

void print(vector<int>& v)
{
    cout << "----------------------" << endl;
    cout << "empty = " << v.empty()<< endl;
    cout << "size = " << v.size()<< endl;
    cout << "max_size = " << v.max_size()<< endl;
    cout << "capacity = " << v.capacity()<< endl;

}

 

 

 

 

------------ vector 小结:
    vector 向量容器是一个实现数据线型存储的泛型类，除了可以使用数组方式进行元素访问外，还可以利用前向和反向迭代器
iterator/reverse_iterator ，以及 push_back 、 begin 、 end 、 erase 和 clear 等函数，对容器元素进行插入、遍历和删除操作。
　　vector尾部添加或移除元素非常快速。但是在中部或头部插入元素或移除元素比较费时

    vector 缺点： vector 不适合那种 【容器元素在任意位置进行  插入、删除 操作非常频繁】 的情况
    vector 优点： 看最前面的介绍