STL容器之＜vector＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

vector介绍

1. vector是封装的动态数组序列式容器。
2. 元素的在内存中的存储地址连续。
3. 通常vector所占用内存的大小比其中元素占用的实际内存要大。
4. 支持随机访问
5. 在尾部删除插入元素的时间复杂度为O(1)，在其他位置插入删除元素时间复杂度根据元素所在位置到结尾的距离O(n)。

头文件

#include <vector>

模块类定义

_Tp：表示存储的元素数据类型
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

template <typename _Tp, typename _Alloc = std::allocator<_Tp> > class vector {};

对象构造

/*默认构造函数,没有元素*/
std::vector<int> vctInt1;;  
/*构造指定长度的对象，含有10个元素默认为0*/
std::vector<int> vctInt2(10);
/*构造指定长度的指定值的对象，还有10个6*/
std::vector<int> vctInt3(10,6);
/*复制拷贝构造函数，含有10个6*/
std::vector<int> vctInt4(vctInt3);
/*使用vctInt3的前7个元素构造对象*/
std::vector<int> vctInt5(vctInt3.begin(),vctInt3.begin()+7);
/*移动构造函数，构造后vctInt5不可在使用*/
std::vector<int> vctInt6(std::move(vctInt5));

初始化

/*初始化列表初始化*/
vctInt1 = {1,2,3,4,5};
/*使用assign函数初始化,清空容器，并使用迭代器进行赋值*/
vctInt1.assign(vctInt6.cbegin(), vctInt6.cend());
/*赋值5个8*/
vctInt1.assign(5,8);
/*assign中使用初始化列表赋值*/
vctInt1.assign({8,7,6,5,4,3,2,1});

元素访问

函数名	返回值	功能
[]	指定元素的值	访问元素
at()	指定元素的引用	访问元素
front()	首元素的引用	获取首元素
back()	元素的引用	获取末尾元素
data()	首元素的地址	获取指向首元素的指针

/* 使用下标运算符访问元素并赋值 */
for (int i = 0; i < 10; i++)
{
	std::cout<< vctInt3[i] << " ";
}
/* 使用at访问元素并赋值 */
for (int i = 0; i < 10; i++)
{
	std::cout << vctInt3.at(i) << " ";
}
/* 访问对象第一个元素和最后一个元素 */
std::cout << vctInt3.front() << " " << vctInt3.back() << std::endl;
/* 获取指向首元素的指针 */
int *p = vctInt3.data();
std::cout<< *p << std::endl;

元素插入和删除

函数	返回值	功能
clear()	无	清空所有元素
erase()	迭代器	清除指定位置的一个元素或通过迭代器指定范围内的元素
emplace()	迭代器	在指定位置插入元素
emplace_back()	无	在末尾拆插入元素
insert()	迭代器或无	1）在指定位置插入1个元素。2）在指定位置插入指定数量的相同元素。3）通过指定迭代器范围在指定位置插入数据
pop_back()	无	删除末尾元素
push_back()	无	在末尾添加元素

/*在末尾插入元素*/
vctTest1.push_back(66);
/*指定位置插入元素*/
vctTest1.emplace(vctTest1.begin()+2, 20);
/*指定末尾构造并插入元素*/
vctTest1.emplace_back(20);
/*在指定位置插入元素*/
vctTest1.insert(vctTest1.begin(),66);
/*在指定位置插入指定数量的相同数据*/
vctTest1.insert(vctTest1.begin()+4,3,8);
/*在指定位置通过插入指定迭代器范围之间的数据*/
vctTest1.insert(vctTest1.begin(),  vctTest3.begin(), vctTest3.end());
/*删除末尾元素*/
vctTest1.pop_back();
/* 清除指定位置的一个元素 */
vctTest1.erase(vctTest1.begin());
/* 清除从指定位置范围内的元素 */
vctTest1.erase(vctTest1.begin(), vctTest1.begin()+3);
/*清空所有元素*/
vctInt2.clear();

说明：emplace和emplace_back两个接口相对于其他插入接口具有更高的效率，因为其调用时会减少对象在内存中的拷贝或者赋值，特别是vector占用的内存在系统中频繁更换时。建议优先考虑emplace和emplace_back接口的使用。

容器大小

函数	返回值	功能
capacity()	std::size_t	获取当前容器能容纳元素的最大数量（不重新分配内存的情况下）
size()	std::size_t	获取当前容器中的元素数量
empty()	bool	判断当前容器是否为空，为空返回true，否则返回false
max_size()	std::size_t	返回容器的最大容量
reserve()	无	设置容器最小可容纳的元素数量
resize()	无	重新指定容器可以容纳的元素数量，新大小大于原本大小时超出部分可使用指定元素填充，如果新大小小于指定大小时会删除容器原本末尾的数据。
shrink_to_fit()	无	丢弃容器中多余的容量。

/*判断容器是否为空*/
std::cout << std::boolalpha << vctTest1.empty() << std::endl;
/*设置容器最小可以容纳的元素数量*/
vctTest1.reserve(15);
/*获取容器未重新分配内存时的最大容量*/
std::cout << vctTest1.capacity() << std::endl;
/*重新设置容器的大小*/
vctTest1.resize(30);
/*获取容器未重新分配内存时的最大容量*/
std::cout << vctTest1.capacity() << std::endl;
/*删除容器中的多余容量*/
vctTest1.shrink_to_fit();
/*获取容器未重新分配内存时的最大容量*/
std::cout << vctTest1.capacity() << std::endl;
/*获取容器最大可分配的容量大小*/
std::cout << vctTest1.max_size() << std::endl;
/*获取当前容器中的元素数量*/
std::cout << vctTest1.size() << std::endl;

迭代器

类型	功能
iterator	正向随机访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向随机访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator	逆向随机访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator	常量逆向随机访问迭代器。从后向前访问元素，只能读取不能修改

函数	返回值	功能
begin()	正向随机访问迭代器	返回指向vector对象首元素所在位置的迭代器
end()	正向随机访问迭代器	返回指向vector对象末尾元素的下一个位置的迭代器
cbegin()	常量正向随机访问迭代器	返回指向vector对象首元素所在位置的常量迭代器
cend()	常量正向随机访问迭代器	返回指向vector对象末尾元素的下一个位置的迭代器
rbegin()	逆向随机访问迭代器	返回指向vector对象末尾元素位置的迭代器
rend()	逆向随机访问迭代器	返回指向vector对象首元素的前一个位置的迭代器
crbegin()	常量逆向随机访问迭代器	返回指向vector对象末尾元素位置的常量迭代器
crend()	常量逆向随机访问迭代器	返回指向vector对象首元素的前一个位置的常量迭代器

std::vector<int>vctTest1({10,11,12,13,14,15,16,17,18,19});
/*正向随机访问迭代器，每个元素+10，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::vector<int>::iterator itr;
for (itr = vctTest1.begin(); itr != vctTest1.end(); itr++)
{
   /* 修改元素值每个元素+10 */
   *itr += 10; 
   /* 访问元素 */
   std::cout << *itr << " ";
}
std::cout<<std::endl;
/*常量正向随机访问迭代器，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::vector<int>::const_iterator cItr;
for (cItr = vctTest1.begin(); cItr != vctTest1.end(); cItr++)
{
   /* 不允许修改值，编译报错 */
   //*cItr += 10; 
   /* 访问元素 */
   std::cout << *cItr << " ";
}
std::cout<<std::endl;
/*逆向随机访问迭代器，每个元素+100，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::vector<int>::reverse_iterator rItr;
for (rItr= vctTest1.rbegin(); rItr!= vctTest1.rend(); rItr++)
{
   /* 修改元素值 */
   *rItr += 100; 
   /* 访问元素 */
   std::cout << *rItr << " ";
}
std::cout<<std::endl;

/*常量逆向随机访问迭代器，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::vector<int>::const_reverse_iterator crItr;
for (crItr= vctTest1.crbegin(); crItr!= vctTest1.crend(); crItr++)
{
   /* 不允许修改元素值， 编译报错 */
   //*crItr += 100; 
   /* 访问元素 */
   std::cout << *crItr << " ";
}

其他函数

函数名	返回值	功能
swap()	无	交换两个容器的元素

/*交互两个容器元素的值,无返回值*/
std::vector<int> vctSwap1 = {6,6,6,6,6};
std::vector<int> vctSwap2 = {8,8,8,8,8};
/*方式1， vctSwap1={8,8,8,8,8}, vctSwap2={6,6,6,6,6}*/
vctSwap1.swap(vctSwap2);
/*方式2，vctSwap1={6,6,6,6,6}, vctSwap2={8,8,8,8,8}*/
std::swap(vctSwap1,vctSwap2);