C++STL——vector

一、相关定义

vector

• 数组
• 随机访问迭代器
• 快速随机访问元素
• 尾部进行快速随机地插入和删除操作

特征：

• 能够存放任意类型；
• 访问vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成；
• 查找特定值的元素所处的位置或是在vector中插入元素则是线性时间复杂度。

二、vector

【使用前提】

1. #include <vector>
2. using namespace std;

【函数列表】

• vector<ElemType> c;   创建一个空的vector

vector<string> m_vector;			//定义一个string类型的向量容器
vector<int> m_vector;				//定义一个int类型的向量容器
vector<int> m_vector(10);			//创建了具有10个元素的容器,每个元素初始值为0
vector<int> m_vector(10,5);			//创建具有10个元素的容器，每个元素初始值为5
vector<char> v1(5,'k');
vector<char> v2(v1);				//v2和v1相同。
int iArray[]={11,13,19,23,27};
vector<int> v(iArray,iArray+5);		//用数组iArray创建容器。

• c.push_back(elem);   在容器最后位置添加一个元素elem

#include <vector>
#include <iostream>
#include <string>
using namespace std;
int main()
{
          vector<string> m_vector;
          m_vector.push_back("B08020526");
          m_vector.push_back("B08020888");
          m_vector.push_back("南邮");
          for (int i=0;i<3;i++)
          {
                   cout<<m_vector[i]<<endl;
          }
          return 0;
}

• c.pop_back();            删除容器最后位置处的元素
• c.at(index);                返回指定index位置处的元素
• c.begin();                   返回指向容器最开始位置数据的指针
• c.end();                      返回指向容器最后一个数据单元的指针+1
• c.front();                     返回容器最开始单元数据的引用
• c.back();                     返回容器最后一个数据的引用
• c.max_size();              返回容器的最大容量
• c.size();                      返回当前容器中实际存放元素的个数
• c.capacity();               同c.size()

#include <iostream>
#include <vector>
using namespace std ;
typedef vector<int> INTVECTOR;
void main()
{
    INTVECTOR thevector;
    thevector.push_back(42) ;
    cout << "size=" << thevector.size() << endl;
    cout << "max_size=" << thevector.max_size()<< endl;
    cout << "capacity=" << thevector.capacity() << endl;
    thevector.reserve(1000);
    cout << "size is: " << thevector.size() << endl;
    cout << "max_size is: " << thevector.max_size()<< endl;
    cout << "capacity is: " << thevector.capacity() << endl;
}
// size=1
// max_size=1073741823
// capacity=1
// size is: 1
// max_size is: 1073741823
// capacity is: 1000

• c.resize();                   重新设置vector的容量
• c.reserve();                 同c.resize()

#include <vector>
#include <iostream>
using namespace std;
void main (void)
{
       vector<int> Myvector;
       Myvector.reserve(4);//限定大小为4
       for(unsigned int i=0;i<4;i++)
       {
              Myvector[i]=i;
              cout<<Myvector[i]<<" ";
       }
}

• c.erase(p);                  删除迭代器p指向的数据，返回指向下一个数据位置的指针（迭代器）
• c.erase(begin,end)     删除迭代器指向的begin,end区间的数据，返回指向下一个数据位置的指针（迭代器）

Myvector.erase(Myvector.begin()+1);
Myvector.erase(Myvector.begin(),Myvector.end()-1);

• c.clear();                     清除所有数据
• c.rbegin();                   将vector反转后的开始指针返回(其实就是原来的end-1)
• c.rend();                      将vector反转后的结束指针返回(其实就是原来的begin-1)
• c.empty();                    判断容器是否为空，若为空返回true，否则返回false
• c1.swap(c2);                交换两个容器中的数据
• c.insert(p,elem);           在指针p指向的位置插入数据elem,返回指向elem位置的指针
• c.insert(p,n,elem);        在位置p插入n个elem数据，无返回值

Myvector.insert(Myvector.begin()+2,2,stu4);
//第一个参数是迭代器类型，表示插入的位置；第二个参数表示参入的个数；第三个参数表示插入的元素。

• c.insert(p,begin,end)    在位置p插入在区间[begin,end)的数据，无返回值

student stu_array[4]={stu1,stu2,stu3,stu4};
Myvector.insert(Myvector.begin()+2,&stu_array[0],&stu_array[3]);

【vector的遍历】

//使用迭代器和循环相结合
#include <iostream>
#include <vector>
#include <string>
using namespace std;
struct student
{
         int ID;
         string name;
         student(int i,string n)
         {
                   ID=i;
                   name=n;
         }
};
void main (void)
{
         vector<student> Myvector;
         vector<student>::iterator m_Iterator;//生成迭代器
         student stu1(1,"张三");
         student stu2(4,"李四");
         student stu3(2,"王五");
         student stu4(3,"张三");
         Myvector.push_back(stu1);
         Myvector.push_back(stu2);
         Myvector.push_back(stu3);
         Myvector.push_back(stu4);
         for (m_Iterator=Myvector.begin();m_Iterator!=Myvector.end();m_Iterator++)
         {
                   cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
         }
}
//1 张三
//4 李四
//2 王五
//3 张三

//使用for_each()算法
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>//for_each()
using namespace std;
struct student
{
       int ID;
       string name;
       student(int i,string n)
       {
              ID=i;
              name=n;
       }
};
void OutFun(student &OutStu);//自定义输出函数
void main (void)
{
       vector<student> Myvector;
       student stu1(1,"张三");
       student stu2(4,"李四");
       student stu3(2,"王五");
       student stu4(3,"张三");
       Myvector.push_back(stu1);
       Myvector.push_back(stu2);
       Myvector.push_back(stu3);
       Myvector.push_back(stu4);
       for_each(Myvector.begin(),Myvector.end(),OutFun);
}
void OutFun(student &OutStu)
{
   cout<<OutStu.ID<<" "<<OutStu.name<<endl;
}

//使用size()函数及[]运算法符和for循环相结合。
for(int i=0;i<Myvector.size();i++){
	cout<<Myvector[i].ID<<" "<<Myvector[i].name<<endl;
}

【其他常用操作】

排序

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>//for_each()
using namespace std;
class student
{
public:
       int ID;
       string name;
       student(int i,string n)
       {
              ID=i;
              name=n;
       }
       bool operator == (const student& ob)
       {
              if (ob.ID==ID&&ob.name==name)
              {
                  return true;
              }
              else
              {
                     return false;
              }
       }
};
void OutFun(student &OutStu);
bool ForFindFun(student &OutStu);
bool MySort(student &stuE,student&Temp_stu);
void main (void)
{
       vector<student> Myvector;
       vector<student>::iterator m_Iterator;
       student stu1(1,"张三");
       student stu2(4,"李四");
       student stu3(2,"王五");
       student stu4(3,"赵六");
       Myvector.push_back(stu1);
       Myvector.push_back(stu2);
       Myvector.push_back(stu3);
       Myvector.push_back(stu4);
       for (m_Iterator=Myvector.begin();m_Iterator!=Myvector.end();m_Iterator++)
       {
              cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
       }
    cout<<"----------------------------------------"<<endl;
       for_each(Myvector.rbegin(),Myvector.rend(),OutFun);
    cout<<"----------------------------------------"<<endl;
       m_Iterator=remove(Myvector.begin(),Myvector.end(),stu2);
       Myvector.insert(Myvector.begin()+2,2,stu4);
       for_each(Myvector.begin(),Myvector.end(),OutFun);
//   student stu_array[4]={stu1,stu2,stu3,stu4};
//  Myvector.insert(Myvector.begin()+2,&stu_array[0],&stu_array[3]);
//   for_each(Myvector.begin(),Myvector.end(),OutFun);
       int var_count(0);
       var_count=count(Myvector.begin(),Myvector.end(),stu1);
       cout<<"\n与stu1相同的个数为"<<var_count<<endl;
       var_count=count_if(Myvector.begin(),Myvector.end(),ForFindFun);
       cout<<"\nID大于2的个数有："<<var_count<<endl;

       cout<<"---------------整理结果--------------------"<<endl;
       for (int i=Myvector.size();i>0;i--)
       {
              sort(Myvector.begin(),Myvector.end(),MySort);
       }
       for_each(Myvector.begin(),Myvector.end(),OutFun);

}
void OutFun(student &OutStu)
{
   cout<<OutStu.ID<<" "<<OutStu.name<<endl;
}
bool ForFindFun(student &OutStu)
{
       if (OutStu.ID>2)
       {
              return true;
       }
       return false;
}
bool MySort(student &stuE,student&Temp_stu)
{
   // student temp(0,"");
       if (stuE.ID>Temp_stu.ID)
       {
              student temp(stuE.ID,stuE.name);
        stuE.ID=Temp_stu.ID;
              stuE.name=Temp_stu.name;
              Temp_stu.ID=temp.ID;
              Temp_stu.name=temp.name;
       }
       return true;
}

查找

1.很显然，要用算法中的find函数或者find_if函数。当vector中存储的是普通类型，如int,double等时，find的第三个参数，可以是这种类型的一个值；
　 当vector中存储的是一个类时，该类必须重载‘==’运算符。
2对于find_if，其第三个参数是一个函数名。而且这个函数的返回值必须为bool类型的，而且其参数必须是vector存储的类型的引用。
举例：
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>//for_each()
using namespace std;
class student
{
public:
       int ID;
       string name;
       student(int i,string n)
       {
              ID=i;
              name=n;
       }
       bool operator == (const student& ob)
       {
              if (ob.ID==ID&&ob.name==name)
              {
                  return true;
              }
              else
              {
                     return false;
              }
       }
};
void OutFun(student &OutStu);
bool ForFindFun(student &OutStu);
void main (void)
{
       vector<student> Myvector;
       vector<student>::iterator m_Iterator;
       student stu1(1,"张三");
       student stu2(4,"李四");
       student stu3(2,"王五");
       student stu4(3,"赵六");
       Myvector.push_back(stu1);
       Myvector.push_back(stu2);
       Myvector.push_back(stu3);
       Myvector.push_back(stu4);
       for (m_Iterator=Myvector.begin();m_Iterator!=Myvector.end();m_Iterator++)
       {
              cout<<m_Iterator->ID<<" "<<m_Iterator->name<<endl;
       }
    cout<<"----------------------------------------"<<endl;
       for_each(Myvector.rbegin(),Myvector.rend(),OutFun);
    cout<<"----------------------------------------"<<endl;
       /*m_Iterator=remove(Myvector.begin(),Myvector.end(),&stu2);*/
       Myvector.insert(Myvector.begin()+2,2,stu4);
       for_each(Myvector.begin(),Myvector.end(),OutFun);
//   student stu_array[4]={stu1,stu2,stu3,stu4};
//  Myvector.insert(Myvector.begin()+2,&stu_array[0],&stu_array[3]);
//   for_each(Myvector.begin(),Myvector.end(),OutFun);
       int var_count(0);
       var_count=count(Myvector.begin(),Myvector.end(),stu1);
       cout<<"\n与stu1相同的个数为"<<var_count<<endl;
       var_count=count_if(Myvector.begin(),Myvector.end(),ForFindFun);
       cout<<"\nID大于2的个数有："<<var_count<<endl;}
void OutFun(student &OutStu)
{
   cout<<OutStu.ID<<" "<<OutStu.name<<endl;
}
bool ForFindFun(student &OutStu)
{
       if (OutStu.ID>2)
       {
          return true;
       }
       return false;
}//输出结果为：
1 张三
4 李四
2 王五
3 赵六
----------------------------------------
3 赵六
2 王五
4 李四
1 张三
----------------------------------------
1 张三
4 李四
3 赵六
3 赵六
2 王五
3 赵六
与stu1相同的个数为1
ID大于2的个数有：4

二维容器

声明：

• vector <vector <int> > arrayTwo2(3);

解释：

• arrayTwo可以保存3个向量，向量的长度是可以改变的；
• arrayTwo[i]返回的是第i个向量，同理，arrayTwo[i][j]返回的是第i个向量中的第j个元素；

vector<vector<int> > arrayTwo(3);
arrayTwo[1][2]=9; //Error,原因就是你没有指定向量的大小。
arrayTwo[1].push_back(9);	//正确，但是好象不太爽。就不能用operator[]吗？
for(int i=0;i<3;i++) 		//这样，你就定义了一个3X3的数组了（另一个3在声明时定义的）。而且你可以随时改变它的大小。
    array2[i].resize(3);    

例子：

#include <iostream>
#include <vector>
using namespace std;
void main()
{
	vector<vector<int> > array(3);
    for(int i=0;i<3;i++)
        array[i].resize(3);//设置数组的大小3X3
	//现在你可以和使用数组一样使用这个vector
    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)
            array[i][j]=(i*j);
    //输出
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++)
            cout<<array[i][j]<<" ";
        cout<<endl;
    }
    array.resize(5);
    arry[3].resize(3);
    arry[4].resize(3);
    //现在是5X3的数组了
    for(int i=0;i<5;i++)
        for(int j=0;j <3;j++)
            array[i][j]=(i*j);
    for(int i=0;i <5;i++){
        for(int j=0;j <3;j++)
            cout<<array[i][j]<<" ";
            cout<<endl;
    }
}