目录

• 一、什么是vector？
• 二、容器特性
• • 1.顺序序列
  • 2.动态数组
  • 3.能够感知内存分配器的（Allocator-aware）
• 三、基本函数实现
• • 1.构造函数
  • 2.增加函数
  • 3.删除函数
  • 4.遍历函数
  • 5.判断函数
  • 6.大小函数
  • 7.其他函数
  • 8.看着清楚
• 四、基本用法
• 五、简单介绍
• 六、案例
• • 案例1：pop_back()&push_back(elem)实例在容器最后移除和插入数据
  • 案例2：clear()清除容器中所有数据
  • 案例3：向量排序算法sort
  • 案例4：访问（直接数组访问&迭代器访问）
  • 案例5：初始化、迭代、插入、擦除遍历
  • 案例6：二维数组两种定义方法
  • • 方法1：vector

一、什么是vector？

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

参考来源：https://www.runoob.com/w3cnote/cpp-vector-container-analysis.html

二、容器特性

1.顺序序列

顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。

2.动态数组

支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。提供了在序列末尾相对快速地添加/删除元素的操作。

3.能够感知内存分配器的（Allocator-aware）

容器使用一个内存分配器对象来动态地处理它的存储需求。

三、基本函数实现

1.构造函数

vector():创建一个空vector
vector(int nSize):创建一个vector,元素个数为nSize
vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
vector(const vector&):复制构造函数
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

2.增加函数

void push_back(const T& x):向量尾部增加一个元素X
iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

3.删除函数

iterator erase(iterator it):删除向量中迭代器指向元素
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
void pop_back():删除向量中最后一个元素
void clear():清空向量中所有元素

4.遍历函数

reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

5.判断函数

bool empty() const:判断向量是否为空，若为空，则向量中无元素

6.大小函数

int size() const:返回向量中元素的个数
int capacity() const:返回当前向量所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值

7.其他函数

void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):设置向量中前n个元素的值为x
void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素

8.看着清楚

1.push_back 在数组的最后添加一个数据

2.pop_back 去掉数组的最后一个数据

3.at 得到编号位置的数据

4.begin 得到数组头的指针

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

6．front 得到数组头的引用

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

8.max_size 得到vector最大可以是多大

9.capacity 当前vector分配的大小

10.size 当前使用数据的大小

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

12.reserve 改变当前vecotr所分配空间的大小

13.erase 删除指针指向的数据项

14.clear 清空当前的vector

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

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

17.empty 判断vector是否为空

18.swap 与另一个vector交换数据

四、基本用法

#include < vector> 
using namespace std;

五、简单介绍

Vector<类型>标识符
Vector<类型>标识符(最大容量)
Vector<类型>标识符(最大容量,初始所有值)
Int i[5]={1,2,3,4,5}
Vector<类型>vi(I,i+2);//得到i索引值为3以后的值
Vector< vector< int> >v; 二维向量//这里最外的<>要有空格。否则在比较旧的编译器下无法通过

六、案例

案例1：pop_back()&push_back(elem)实例在容器最后移除和插入数据

obj[1].push_back(23);   //插入列元素
obj.push_back(obj);     //插入一行

# include <string.h>
# include <vector>
# include <iostream>

using namespace std;
 
int main()
{
    vector<int>obj;//创建一个向量存储容器 int
    for(int i=0;i<10;i++) // push_back(elem)在数组最后添加数据 
    {
        obj.push_back(i);
        cout<<obj[i]<<"，";    
    }
    cout<<"\n"<<endl;

    for(int i=0;i<5;i++)//去掉数组最后一个数据 
    {
        obj.pop_back();
    }
 
    cout<<"\n"<<endl;
 
    for(int i=0;i<obj.size();i++)//size()容器中实际上述的数据个数 
    {
        cout<<obj[i]<<"...,";
    }
    cout<<"\n"<<endl;
 
    return 0;
}

执行结果：

0，1，2，3，4，5，6，7，8，9，



0...,1...,2...,3...,4...,

案例2：clear()清除容器中所有数据

#include <string.h>
#include <vector>
#include <iostream>
using namespace std;
 
int main()
{
    vector<int>obj;
    for(int i=0;i<10;i++)//push_back(elem)在数组最后添加数据 
    {
        obj.push_back(i);
        cout<<obj[i]<<",";
        cout<<"清除前\n"<<endl;
    }
    cout<<"\n"<<endl;
    obj.clear();//清除容器中所以数据
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<endl;
        cout<<"清除后\n"<<endl;
    }
    cout<<"\n"<<endl;
    return 0;
}

执行结果：

0,清除前

1,清除前

2,清除前

3,清除前

4,清除前

5,清除前

6,清除前

7,清除前

8,清除前

9,清除前

案例3：向量排序算法sort

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
int main()
{
    vector<int>obj;
    
    int arr[4] = {1,8,-5,3};
    for (int i = 0; i < 4; i++)
    {
        obj.push_back(arr[i]);
    }
    
    //添加4个数
    // obj.push_back(1);
    // obj.push_back(3);
    // obj.push_back(0);
    // obj.push_back(-5);
 
    sort(obj.begin(),obj.end());//从小到大
 
    cout<<"从小到大:"<<endl;
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<",";  
    } 
 
    cout<<"\n"<<endl;
 
    cout<<"从大到小:"<<endl;
    reverse(obj.begin(),obj.end());//从大到小 
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<",";
    }
    cout<<"\n"<<endl;
    return 0;
}

执行结果：

从小到大:
-5,1,3,8,

从大到小:
8,3,1,-5,

案例4：访问（直接数组访问&迭代器访问）

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
int main()
{
    //顺序访问
    vector<int>obj;
    for(int i=0;i<10;i++)
    {
        obj.push_back(i);   
    } 
 
    cout<<"直接利用数组："; 
    for(int i=0;i<10;i++)//方法一 
    {
        cout<<obj[i]<<" ";
    }
 
    cout<<endl; 

    cout<<"利用迭代器：" ;
    //方法二，使用迭代器将容器中数据输出 
    vector<int>::iterator it;
    //声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素 
    for(it=obj.begin();it!=obj.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;
}

执行结果：

直接利用数组：0 1 2 3 4 5 6 7 8 9 
利用迭代器：0 1 2 3 4 5 6 7 8 9 

案例5：初始化、迭代、插入、擦除遍历

#include<stdio.h>
#include<vector>
#include<iostream>
using namespace std;
int main()
{
    int i=0;
    vector<int> vec;
    for(i=0; i<10; i++)
    {
            vec.push_back(i);//10个元素依次进入，结果为10
    }


    for(unsigned int i=0; i<vec.size(); i++)
    {
    cout<<"初始化遍历："<<vec[i]<<endl;
    }
    //结果为：０，１，２，３，４，５，６，７，８，９
    vector<int>::iterator it;

    for(it = vec.begin(); it!=vec.end(); it++)
    {
    cout<<"迭代遍历："<<*it<<endl;
    }

    //结果为：０，１，２，３，４，５，６，７，８，９
    vec.insert(vec.begin()+4,0);
    //结果为:11
    for(unsigned int i=0; i<vec.size(); i++)
    {
    cout<<"插入遍历："<<vec[i]<<endl;
    }
    //结果为：０，１，２，３，０，４，５，６，７，８，９
    vec.erase(vec.begin()+2);
    for(unsigned int i=0; i<vec.size(); i++)
    {
    cout<<"擦除遍历："<<vec[i]<<endl;
    }
    //结果为：０，１，３，０，４，５，６，７，８，９

    vec.erase(vec.begin()+3,vec.begin()+5);
    for(vector<int>::iterator it = vec.begin(); it!=vec.end(); it++)
    {
    cout<<"重新迭代遍历："<<*it<<endl;
    }
    return 0;
}
 
 

执行结果：

初始化遍历：0
初始化遍历：1
初始化遍历：2
初始化遍历：3
初始化遍历：4
初始化遍历：5
初始化遍历：6
初始化遍历：7
初始化遍历：8
初始化遍历：9
迭代遍历：0
迭代遍历：1
迭代遍历：2
迭代遍历：3
迭代遍历：4
迭代遍历：5
迭代遍历：6
迭代遍历：7
迭代遍历：8
迭代遍历：9
插入遍历：0
插入遍历：1
插入遍历：2
插入遍历：3
插入遍历：0
插入遍历：4
插入遍历：5
插入遍历：6
插入遍历：7
插入遍历：8
插入遍历：9
擦除遍历：0
擦除遍历：1
擦除遍历：3
擦除遍历：0
擦除遍历：4
擦除遍历：5
擦除遍历：6
擦除遍历：7
擦除遍历：8
擦除遍历：9
重新迭代遍历：0
重新迭代遍历：1
重新迭代遍历：3
重新迭代遍历：5
重新迭代遍历：6
重新迭代遍历：7
重新迭代遍历：8
重新迭代遍历：9

案例6：二维数组两种定义方法

方法1：vector<vector > obj(N)

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
 
int main()
{
    int N=5, M=6; 
    int arr[N][M]={{-1,1,2,3,4,5},{-2,1,2,3,4,5},{-3,1,2,3,4,5},{-4,1,2,3,4,5},{-5,1,2,3,4,5}};

    vector<vector<int> > obj(N); //定义二维动态数组大小5行 

    //初始化N.M的零矩阵
    for(int i =0; i< obj.size(); i++)//动态二维数组为5行6列，值全为0 
    { 
        // printf("%d\n",obj[i]);
        obj[i].resize(M); //resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
    } 


    //给一维向量赋值
    // vector<int> vec_int;
    // int num = sizeof(arr)/sizeof(int);
    // // printf("sizeof(arr)[%d]=%d\n",sizeof(arr),sizeof(int));
    // for (int i = 0; i < num; i++)
    // {
    //     // printf("arr[%d]=%d\n",i,arr[i]);
    //     vec_int.push_back(arr[i]);

    // }
    // obj.push_back(vec_int);//添加元素

    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            obj[i][j] = arr[i][j];

            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

/**
 * 输出结果是:
-1 1 2 3 4 5 
-2 1 2 3 4 5 
-3 1 2 3 4 5 
-4 1 2 3 4 5 
-5 1 2 3 4 5**/

方法2：vector<vector > obj(N, vector(M)

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
 
int main()
{
    int N=5, M=6; 
    int arr[N][M]={{-1,1,2,3,4,5},{-2,1,2,3,4,5},{-3,1,2,3,4,5},{-4,1,2,3,4,5},{-5,1,2,3,4,5}};
    vector<vector<int> > obj(N, vector<int>(M)); //定义二维动态数组5行6列 
 
    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            obj[i][j]=arr[i][j];
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

备注：auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型，类似的关键字还有decltype。举个例子：

int a = 10;
auto au_a = a;//自动类型推断，au_a为int类型
cout << typeid(au_a).name() << endl;

案例7：二维数组的四种方法

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

int rows=2,columns=3;

int main(int argc, char const *argv[])
{
    // 方法1：使用一维数组模型二维数组
    int a0[] = {1,2,3,4,5,6};
    for(int i=0;i<rows;i++){
        for(int j=0;j<columns;j++){
            // cout<<a0[i*columns+j]<<" ";//a0[i*columns+j]等价于a0[i][j]
            printf("a0[%d][%d]=%d\n",i,j,a0[i*columns+j]);
        }
        cout<<endl;
    }

    //方法2 静态二维数组
    int a1[2][3] = {1,2,3,4,5,6};

    //方法3：动态二维数组
    //申请空间
    int** a2 = new int*[rows];
    for(int i=0;i<rows;i++)
    {
        a2[i] = new int[columns];
        // cout<<*a2[i]<<" ";
    }
    //释放空间
    for(int i=0;i<rows;i++)
        delete []a2[i];
    delete []a2;

    // 方法4：利用vector创建二维数组
    vector<vector<int> > a3(rows,vector<int>(columns));
    for(int i=0;i<rows;i++){//初始化
         for(int j=0;j<columns;j++){
            a3[i][j] = a1[i][j];
            printf("a3[%d][%d]=%d\n",i,j,a3[i][j]);
            
         }
    }
    cout<<"\n";


    return 0;
}

执行结果：

a0[0][0]=1
a0[0][1]=2
a0[0][2]=3

a0[1][0]=4
a0[1][1]=5
a0[1][2]=6

a3[0][0]=1
a3[0][1]=2
a3[0][2]=3
a3[1][0]=4
a3[1][1]=5
a3[1][2]=6

统一上述部分方法：

#include <iostream>
#include <array>
#include <vector>
#include <cstring>
 
using namespace std;
 
void Print(vector<vector<int>> a)
{
	vector<vector<int> >::iterator p1;
	vector<int>::iterator p2;
	for (p1 = a.begin(); p1 != a.end(); p1++)
	{
		for (p2 = p1->begin(); p2 != p1->end(); p2++)
		{
			cout << "[" << *p2 << "]";
		}
		cout <<endl;
	}
	cout <<endl;
}
 
int main()
{
	int i = 0;
	vector <int> asd(4,2); //将含有4个数据的一维动态数组初始为2
	vector<std::vector<int> > asd1(4,vector<int>(4,0)); //初始化row*column二维动态数组，初始化值为0
 
	vector<std::vector<int> >::iterator p1;
	vector <int>::iterator p2;
 
 
	//简单初始化
	for (p1 = asd1.begin(); p1 != asd1.end(); p1++)
	{
		for (p2 = p1->begin(); p2 != p1->end(); p2++)
		{
			*p2 = i++;
		}
	}
 
	cout << "Init:" <<endl;
	Print(asd1);
 
	//插入列元素用push_back
	asd1[1].push_back(23);
	asd1.push_back(asd);
	
	/*
	//设置行列数
	int size_row = asd1.size();             //获取行数
	cout << "size_row:" << size_row <<endl;
	asd1.resize(10);                        //设置行数
	size_row = asd1.size();                 //获取行数
	cout << "size_row:" << size_row <<endl;
	int size_col = asd1[0].size();
	cout << "size_col:" << size_col <<endl;
	asd1[1].resize(10);                     //设置列数
	size_col = asd1[1].size();
	cout << "size_col:" << size_col <<endl;
	*/
	
	cout << "Push_back:" <<endl;
	Print(asd1);
 
	cout << "Erase:" <<endl;
	auto test1 = asd1.begin();
	test1 = test1 + 3;
	asd1.erase(test1);
	Print(asd1);
 
	return 0;
}

执行结果：

Init:
[0][1][2][3]
[4][5][6][7]
[8][9][10][11]
[12][13][14][15]

Push_back:
[0][1][2][3]
[4][5][6][7][23]
[8][9][10][11]
[12][13][14][15]
[2][2][2][2]

Erase:
[0][1][2][3]
[4][5][6][7][23]
[8][9][10][11]
[2][2][2][2]

其他方法：malloc

1 int len=100;
2 
3 int **dp=(int **)malloc(sizeof(int) *(len+1));for(int i=0;i<=len;++i){
4 　　dp[i]=new int[4];
5 }

参考

https://www.cnblogs.com/Nonono-nw/p/3462183.html