STL—vector(向量容器)详解

什么是vector：

vector是一种可以完全代替数组的高效容器。完全代替数组的意思就是，数组能干的vector都能干，如随机访问元素，用下标遍历元素等（注：下标操作符[]可以获取已存在的元素，或将其重新赋值，但是不能添加元素）。数组不能干的它也能干，如内存自动管理功能，即它可以根据元素的插删动态调整所占的内存空间。

头文件

 #include<vector>

基本操作

     push_back();               //从尾部插入元素
     insert();                  //插入新元素，并返回指向新元素的迭代器。可在任意位置
     erase();                   //删除迭代器所指的一个元素或一个区域
     clear()；                  //删除所有元素
     pop_back();                //删除最后一个元素
     size();                    //返回向量的大小
     empty();                   //判断是否为空
     find()                     //元素查找，需加头文件#include< algorithm>
     reverse();                 //反向排序算法，此算法需要声明头文件 #include<algorithm>
     sort();                    //默认用升序排序，但是也可以自定义排序规则，加头文件#include<algorithm>

创建vector对象

    vector<int> p;             //创建对象p,不指定元素个数
    vector<double> p(10);      //创建对象p ,指定有10个元素，默认为0.0
    vector<double> p(10,12.3); //创建对象p,指定有10个元素，且每个元素的值都为12.3
    vector<int> p[10];         //创建一个由10个vector对象组成的数组

元素插入

1.从尾部扩张插入

    p.push_back(a);            //将 a 的值插入到对象 p 的尾部

2.利用迭代器插入

    p.insert(p.begin(),5);     //在最前面插入新元素5，并返回指向新元素5的迭代器
    p.insert(p.begin()+2,5)    //在下标为2的元素前面插入新元素5
    p.insert(iter,start,end)   //把迭代器start和end所指定的范围内的所有元素插入到迭代器iter所指向的元素之前，返回void。

元素删除

    p.erase(p.begin()+2);      //删除下标为2的元素
    p.erase(p.begin()+1,p.begin()+5); //删除下标为[1.5)的元素，区间左闭右开
    p.clear();                 //删除所有元素
    p.pop_back();              //删除最后一个元素

元素查找

    find(p.begin(),p.end(),b); //找到的话返回元素b的迭代器地址，否则返回p.end()

利用reverse反向排序

    reverse(p.begin(),p.end()); //这种方法还可以只排序规定的区间，如
    reverse(p.begin()+2,p.begin()+8)//将下标为[2,8)的元素进行反排序

利用sort算法排序

    sort(p.begin(),p.end());   //默认升序排列，也可以只排列一个区间
    sort(p.begin(),p.end(),comp) //利用自定义排序规则comp进行排序

sort排序规则定义方法

非结构体

  bool comp(const &a,const &b)
  {
        return a>b;//降序
  }
 另：
  bool comp(int a,int b)
  {
        return a>b;
  }

结构体

struct lei
{
    int k;
    int w;
}a,b;
bool com(lei a,lei b)
{
    return a.k>b.k;//降序
}

后续补充

定义和初始化：

int a[]={1,2,3};
vector<int> b(a,a+3);       //相当于迭代器，此时b中元素为1、2、3；
vector<int> c(b);           //用b中的元素创建一个对象c,此时c中的元素为1、2、3；
vector<int> d(c.begin(),c.end());//用c中对应迭代器区间(左闭右开)的元素创建对象d,此时d中元素为1、2、3；

元素访问操作：

p.at(n);      //等价于p[n],但因下标运算符[]有越界检查，所以没有at访问安全
p.front();    //返回首元素
p.back();     //返回尾元素
p.begin();    //返回首元素的迭代器
p.end();      //返回向量中最后一个元素的下一个位置的迭代器，仅作结束游标，不可解引用。
c.rbegin()    //返回一个反向迭代器，该迭代器指向容器的最后一个元素。
c.rend()      //返回一个反向迭代器，该迭代器指向容器第一个元素前面的位置

注：vector对象之间可以直接用比较运算符比较，比较规则与字符串相同。

代码示例

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main()
{
    int i;
    vector<double> p;
//  vector<int> p(10);                       //创建一个对象，内部存储着是个元素，每个元素都为0
//  vector<int> p(10,8);                     //创建vector对象，规定有10个元素，都为8，同样可用 p.push_back()从尾部扩张元素
    for(i=0;i<10;i++)
    {
        p.push_back(i+1);                    //尾插法扩张元素
    }
    cout<<p.size()<<endl;
//  p.insert(p.begin()+2,6);                 //insert()随意插入，插在下标为2的前面
    for(i=0;i<10;i++)                        //下标法遍历
    {
        cout<<p[i]<<" ";
    }
//  reverse(p.begin(),p.end());              //反向排序
    cout<<endl;
    p.erase(p.begin()+2);                     //删除单个元素    第三个   可理解为下标，p.begin()为首元素地址，首元素其下标为0，故p.begin()+2则为下标为2的元素
    p.erase(p.begin(),p.begin()+3);           //删除区间元素    第一个到第三个     /*凡涉及到区间的都是左闭右开*/
//  p.clear()                                 //删除所有元素    p.erase(p.begin(),p.end());效果一样
    vector<double>::iterator it,il;           //定义迭代器变量
    for(it=p.begin();it!=p.end();it++)        //迭代器法遍历
    {
        cout<<*it<<" ";
    }
    cout<<endl;
    return 0;
}