Vector的使用方法

1.添加头文件

# include <iostream>
# include <vector>
using namespace std;

2.定义vector的对象

vector<int> name;
vector<double> name;//双精度型
vector <float> name;//浮点数型
vector <char> name;//字符型
vector<vector<int>> name;//类似二维数组

3.访问vector内部元素

1)通过下标访问元素

//通过下标来访问
vector<typename> v;
cout<<v[0]<<endl;

2)通过迭代器来访问

迭代器可以理解为类似指针的东西，定义其的方法。

vector<typename> ::iterator it;
vector<int>::iterator it;
vector<float>::iterator it;

vetctor的定义

//第一种：不传参数
vector<int> vint;
vector<char> vchar;
vector<string> vstring;

//第二种：传一个参数 相当于开辟了一个数组
vector<int> vint2(5);
vector<char> vchar2(5);
vector<string> vstring2(5);

//第三种：参数一 n个元素，每个元素的初值 开辟数组并进行初始化
vector<int> vint3(5,0);
vector<char> vchar3(5,'a');
vector<string> vstring3(5,"a");

//第四种：传一段迭代器区间
vector<int> vint4(vint3.begin(),vint3.end());
vector<char> vchar4(vchar3.begin(),vchar3.end());                      
vector<string> vstring4(vstring3.begin(),vstring3.end());

//第五种：传一个对象，既拷贝函数
vector<int> vint5(vint3);
vector<char> vchar5(vchar3);
vector<string> vstring5(vstring3);

//第六种：赋值运算符的重载
vector<int> vint6;
vector<char> vchar6;
vector<string> vstring6;
vint6=vint5;
vchar6=vchar5;
vstring6=vstring5;

vector迭代器定义

//迭代器定义
//begin() end() rbegin() rend() 正向和反向迭代器
std::vector<int>::iterator itint=vint6.begin();                                                                                                        
std::vector<char>::iterator itchar=vchar6.begin();
std::vector<string>::iterator itstring=vstring.end();
itint =vint6.end();
itchar = vchar.end();
itstring=vstring.end();
std::vector<int>::reverse_iterator ritint =vint6.rbegin();
std::vector<char>::reverse_iterator ritchar = vchar.rbegin();
std::vector<string>::reverse_iterator ritstring=vstring.rbegin();
ritint = vint6.rend();
ritchar = vchar6.rend();
ritstring=vstring.rend();

//cbegin() cend() crbegin() crend() const正向和反向迭代器
std::vector<int>::const_iterator citint=vint6.cbegin();
std::vector<char>::const_iterator citchar=vchar6.cbegin();
std::vector<string>::const_iterator citstring=vstring6.cbegin();
citint=vint6.cend();
citchar=vchar6.cend();
citstring=vstring.cend();

std::vector<int>::const_reverse_iterator critint;
std::vector<char>::const_reverse_iterator critchar;
std::vector<string>::const_reverse_iterator critstring;
critint=vint6.crbegin();
critchar=vchar6.crbegin();
critstring=vstring6.crbegin();
critint=vint6.crend();
critchar=vchar6.crend();
critstring=vstring6.crend();

vector的大小

//用来描述大小的一系列函数
vector<int> test(5,1);
cout<<test.size()<<endl;//表示顺序表的元素个数
cout<<test.capacity()<<endl;//表示顺序表的容量
cout<<test.max_size()<<endl;//表示容器的最大存储，但实际到不了
test.resize(1);//设置大小，可以开辟出更多的空间，当参数小于时就销毁空间
test.resize(10,2);//当大于时就开辟并初始化
cout<<test.size()<<endl;
test.empty();//用来检查是否为空
test.reserve(10);//用来设置容器大小但是并不初始化，元素个数也没变，变化不可见
test.shrink_to_fit();//将容器的大小收缩至于元素个数相同的大小

vector的数据操作

//关于元素存取的函数
//operator[] 既重载[]使其类似于数组元素的操纵，实现随机访问
cout<<test.at(1)<<endl;//类似于[]的作用，只是是一个函数行形式
cout<<test.front()<<endl;//显示存在的第一个元素
cout<<test.back()<<endl;//显示存在的最后一个元素
int* p = test.data();//取到了一个指向顺序表的一个指针
cout<<test.front()<<endl;//显示存在的第一个元素

//修改动作函数
test.assign(arr,arr+3);//assign替换函数可以替换一个对象的区间或者一个同类型的数组
test.push_back(4);//尾插，并没有头插
test.pop_back();//尾删                                                                                                                                        
test.insert(it,5);//插入指定位置
test.erase(it);//删除指定位置
test.swap(test1);//交换函数，将两个对象进行交换
test.clear();//清空整个顺序表
vector<int>::iterator it2=test.emplace(it,5);//类似于insert但是会返回新插入元的迭代器
test.emplace_back(10);//类似于尾插

关于vector的介绍可以分为成员类型、迭代器、元素访问、构造函数、堆栈操作、表操作、大小和容量、协助函数、以及vector等许多方面，但是本次主要写的是关于如何使用vector。

简单介绍

1

每次使用vector时需要包含vector的头文件，在定义一个vector时我们会传一个参数类型，
如int、char等内部类型，也可以是自定义类型，但是我们需要知道的是其实vector的模板是有
两个参数的，如图：

可以发现vector模板有两个参数，只是第二个是缺省参数。

2

vector的本质上就是一个可以动态增容的数组，所以其中最为常用的就是对[]的重载，这样
为了弥补这种缺陷。并且还有一些函数辅助使用，如front(),back(),data()，分别是返

3

每一个容器都存在迭代器，vector也支持，vector的迭代器可以说是非常的简单，其中就包含 
begin(),end()两个最常见的迭代器函数，还有静态的cbegin()和cend()函数和两个反向操 

4

因为vector是一个有序的容器，所以在某种特定时间也可以作 
为堆栈甚至是表来操作，所以为了更接近堆栈的特征，vector也包push_back(),pop_back() 
等函数，还有关于表操作的insert(),erase()的函数，还有clear(),swap()两个函数，可以 
说vector是非常全面的一个容器。 

5

关于大小和容量的问题，vector也有许多成员函数，size(),capacity(),empty()等常见函 
数还有两个比较容易混淆的两个函数resize()和reserver(),两个函数最本质的区别就是前者 

6

最后就是关于赋值运算符的重载，并且还有一系列比较运算符的重载。

完整代码

#include<iostream>
#include<vector>
using namespace std;

void printvector(vector<int> v){
    vector<int>::iterator it=v.begin();
    for(it;it!=v.end();++it){
        cout<<*it<<" ";
    }
    cout<<endl;
}


int main(){
    //第一种：不传参数
    vector<int> vint;
    vector<char> vchar;
    vector<string> vstring;

    //第二种：传一个参数 相当于开辟了一个数组
    vector<int> vint2(5);
    vector<char> vchar2(5);
    vector<string> vstring2(5);

    //第三种：参数一 n个元素，每个元素的初值 开辟数组并进行初始化
    vector<int> vint3(5,0);
    vector<char> vchar3(5,'a');
    vector<string> vstring3(5,"a");

    //第四种：传一段迭代器区间
    vector<int> vint4(vint3.begin(),vint3.end());
    vector<char> vchar4(vchar3.begin(),vchar3.end());
    vector<string> vstring4(vstring3.begin(),vstring3.end());


    //第五种：传一个对象，既拷贝函数
    vector<int> vint5(vint3);
    vector<char> vchar5(vchar3);
    vector<string> vstring5(vstring3);

    //第六种：赋值运算符的重载
    vector<int> vint6;
    vector<char> vchar6;
    vector<string> vstring6;
    vint6=vint5;
    vchar6=vchar5;
    vstring6=vstring5;

    //迭代器定义
    //begin() end() rbegin() rend() 正向和反向迭代器
    std::vector<int>::iterator itint=vint6.begin();
    std::vector<char>::iterator itchar=vchar6.begin();
    std::vector<string>::iterator itstring=vstring.end();
    itint =vint6.end();
    itchar = vchar.end();
    itstring=vstring.end();
    std::vector<int>::reverse_iterator ritint =vint6.rbegin();
    std::vector<char>::reverse_iterator ritchar = vchar.rbegin();
    std::vector<string>::reverse_iterator ritstring=vstring.rbegin();
    ritint = vint6.rend();
    ritchar = vchar6.rend();
    ritstring=vstring.rend();

    //cbegin() cend() crbegin() crend() const正向和反向迭代器
    std::vector<int>::const_iterator citint=vint6.cbegin();
    std::vector<char>::const_iterator citchar=vchar6.cbegin();
    std::vector<string>::const_iterator citstring=vstring6.cbegin();
    citint=vint6.cend();
    citchar=vchar6.cend();
    citstring=vstring.cend();

    std::vector<int>::const_reverse_iterator critint;
    std::vector<char>::const_reverse_iterator critchar;
    std::vector<string>::const_reverse_iterator critstring;
    critint=vint6.crbegin();
    critchar=vchar6.crbegin();
    critstring=vstring6.crbegin();
    critint=vint6.crend();
    critchar=vchar6.crend();
    critstring=vstring6.crend();

    //用来描述大小的一系列函数
    vector<int> test(5,1);
    cout<<test.size()<<endl;//表示顺序表的元素个数
    cout<<test.capacity()<<endl;//表示顺序表的容量
    cout<<test.max_size()<<endl;//表示容器的最大存储，但实际到不了
    test.resize(1);//设置大小，可以开辟出更多的空间，当参数小于时就销毁空间
    test.resize(10,2);//当大于时就开辟并初始化
    cout<<test.size()<<endl;
    test.empty();//用来检查是否为空
    test.reserve(10);//用来设置容器大小但是并不初始化，元素个数也没变，变化不可见
    test.shrink_to_fit();//将容器的大小收缩至于元素个数相同的大小

    //关于元素存取的函数
    //operator[] 既重载[]使其类似于数组元素的操纵，实现随机访问
    cout<<test[1]<<endl;
    cout<<test.at(1)<<endl;//类似于[]的作用，只是是一个函数行形式
    cout<<test.front()<<endl;//显示存在的第一个元素
    cout<<test.back()<<endl;//显示存在的最后一个元素
    int* p = test.data();//取到了一个指向顺序表的一个指针
    *p =10; 
    cout<<test.front()<<endl;//显示存在的第一个元素

    //修改动作函数
    cout<<"==============================="<<endl;
    test.assign(vint6.begin(),vint6.end()-1);
    printvector(test);
    int arr[]={1,2,3};
    test.assign(arr,arr+3);//assign替换函数可以替换一个对象的区间或者一个同类型的数组
    printvector(test);
    test.push_back(4);//尾插，并没有头插
    printvector(test);
    test.pop_back();//尾删
    printvector(test);
    vector<int>::iterator it = test.begin();
    it++;
    test.insert(it,5);//插入指定位置
    printvector(test);
    test.erase(it);//删除指定位置
    printvector(test);
    vector<int> test1(5,200);
    cout<<"===============交换============"<<endl;
    printvector(test);
    printvector(test1);
    test.swap(test1);//交换函数，将两个对象进行交换
    printvector(test);
    printvector(test1);
    cout<<"===============交换结束========"<<endl;
    cout<<"===============清空============"<<endl;
    printvector(test1);
    test.clear();//清空整个顺序表
    printvector(test1);
    cout<<"===============清空结束========"<<endl;
    printvector(test);
    vector<int>::iterator it2=test.emplace(it,5);//类似于insert但是会返回新插入元素的迭代器
    printvector(test);
    test.emplace_back(10);//类似于尾插
    printvector(test);
    return 0;
}

举例

# include <iostream>
# include <vector>
using namespace std;
int main(void)
{
    vector<int> vi;
    for(int i=1;i<=5;i++)
    {
        vi.push_back(i);
    }
    //vi.begin()是取vi的首地址，it指向该地址
    vector<int>::iterator it=vi.begin();
    for(int i=0;i<5;i++)
    {
        cout<<*(it+i)<<endl;
    }
}

结果

注意begin()函数返回的是vector数组的首地址，而end()并不是返回尾地址，而是末尾元素的下一个元素的地址。除此之外迭代器还实现了两种自增操作it++和++it

因此使用迭代器遍历的第二种方法。

# include <iostream>
# include <vector>
using namespace std;
int main(void)
{
    vector<int> vi;
    for(int i=0;i<5;i++)
    {
        vi.push_back(i);
    }
　　//不支持it<vi.end()的写法
    for(vector<int>::iterator it=vi.begin();it!=vi.end();it++)
    {
        cout<<*it<<' '<<endl;
    }
    return 0;
}

4.常用函数的使用

1)push_back()

功能:在vector的末尾后面添加一个元素

# include <iostream>
# include <vector>
using namespace std;
int main(void)
{
    vector<int> vi;
    for(int i=0;i<5;i++)
    {
        vi.push_back(i);
    }
    for(int i=0;i<5;i++)
    {
        cout<<vi[i]<<' ';
    }
    return 0;
}

2)pop_back()

vector<int> vi;
for(int i=0;i<3;i++)
{
     vi.push_back(i);        
}
//0,1,2
vi.pop_back();//0,1
for(int i=0;i<vi.size();i++)
{
    cout<<vi[i]<<' ';//0,1
}

3)size()

vector<int> vi;
int size=vi.size();//返回当前元素数目

4)clear()

vector<int> vi;
for(int i=0;i<5;i++)
    vi.push_back(i);//依次加入0,1,2,3,4
vi.clear();//清空所有元素，size=0

5)insert()

vector<int> vi;
for(int i=0;i<5;i++)
{
     vi.push_back(i);  
}
vi.insert(vi.begin()+2,-1);//-1插入vi[2]的位置

6)erase()

vector<int> vi;
vi.erase(vi.beigin()+3);//删除单个元素，删除vi[3]
vi.erase(vi.beigin()+1,vi.begin()+4);//删除多个元素，删除【first,end】之间的所有元素