【C++】探索STL中的高效容器：vector

💞💞 前言

hello hello~ ，这里是大耳朵土土垚~💖💖 ，欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹

💥个人主页：大耳朵土土垚的博客
💥 所属专栏：C++入门至进阶
这里将会不定期更新有关C++的内容，希望大家多多点赞关注收藏💖💖

1.什么是STL

C++标准模板库（Standard Template Library，简称STL）是C++的一个库，提供了一组通用的模板类和函数，实现了常用的数据结构和算法。C++中的vector就是是标准模板库（STL）提供的一种容器。

STL由六个组件组成：

其中：
✨容器（Containers）：提供了不同类型的数据结构，如vector、list、deque、set、map等。容器可以存储不同类型的元素，并提供了一系列操作元素的函数，如插入、删除、查找、排序等。容器是STL最常使用的部分。

✨迭代器（Iterators）：用于遍历容器中的元素，类似于指针的概念。迭代器可以指向容器中的一个或多个元素，并提供了访问和修改元素的方式。迭代器可以在容器中前进、后退、比较和解引用等。

✨算法（Algorithms）：提供了一系列通用算法，如排序、查找、比较、复制、转换等。算法可以用于不同类型的容器，并且可以通过迭代器来操作容器中的元素。

STL的设计思想是泛型编程（Generic Programming），即通过模板实现通用的数据结构和算法，以提高代码的重用性和可扩展性。STL提供了大量的模板类和函数，可以在不同的应用中被复用，减少了开发者编写重复代码的工作量。

2.vector介绍

C++中的vector是标准模板库（STL）提供的一种容器，用于存储和操作动态数组。功能类似于我们之前学习的顺序表，它可以在运行时动态调整大小，与C++内置的数组相比，提供了更多的功能和便利性。

✨vector特点

1. vector是表示可变大小数组的序列容器。vector可以根据需要自动调整大小，可以在运行时添加或删除元素，而不需要手动管理内存。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，如果空间不够，这个数组需要被重新分配大小，其做法是，分配一个新的数组，然后将全部元素移到这个数组。
4. vector内部分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大，不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何在末尾插入一个元素的时候都应该是在常数时间的复杂度内完成的。
5. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。
6. 元素类型：vector可以存储任何类型的元素，包括基本类型、自定义类型和STL容器等。
7. 包含头文件：在使用vector之前，需要包含<vector>头文件。

3.vector使用

✨构造函数

①无参构造vector():

vector<int> v1; //构造int类型的空容器

②拷贝构造vector (const vector& x):

vector<int> v2(v1); //用v1拷贝构造int类型的v2容器

③ 使用n个val构造vector（size_type n, const value_type& val = value_type()）:

	vector<int> v3(4, 0);//用4个0构造int类型的容器v3

④使用迭代器进行初始化构造vector (InputIterator first, InputIterator last):

	vector<int> v4(v3.begin(), v3.end());//使用v3的迭代器来初始化并构造v4

注意这里是InputIterator表示除了vector的迭代器，其他容器的迭代器也可以构造，例如string、list…，代码如下：

string s("hello world");
vector<int> v5(s.begin(), s.end());

✨vector iterator迭代器

迭代器的接口	使用说明
begin	获取第一个数据位置的iterator/const_iterator
end	获取最后一个数据的下一个位置的iterator/const_iterator
rbegin	获取最后一个数据位置的reverse_iterator
rend	获取第一个数据前一个位置的reverse_iterator

begin()和end()函数通过访问容器的第一个和最后一个的下一位来实现正向迭代器遍历：

代码如下：

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


int main()
{
	vector<int> v1{ 1,2,3,4 };	//多个数据构造也可以直接这么写
	//使用正向迭代器遍历
	vector<int>::iterator it = v1.begin(); //先获取第一个的位置
	while (it != v1.end())
	{
		cout << *it <<" ";
		it++;
	}
	return 0;
}

结果如下：

rbegin()和rend()函数通过访问容器的最后一个和第一个的前一位来实现反向迭代器遍历：

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

int main()
{
	vector<int> v1{ 1,2,3,4 };	//多个数据构造也可以直接这么写
	//使用反向迭代器遍历
	vector<int>::reverse_iterator it = v1.rbegin(); //先获取最后一个的位置
	while (it != v1.rend())
	{
		cout << *it << " ";
		it++;
	}
	return 0;
}

这里注意使用的是反向迭代器vector<int>::reverse_iterator it = v1.rbegin();

结果如下：

✨空间操作

接口	说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize	改变vector的size
reserve	改变vector的capacity

1. capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。
2. reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
3. resize在开空间的同时还会进行初始化，影响size。

代码如下：

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

int main()
{
	vector<int> v1{ 1,2,3,4,5 };	//多个数据构造也可以直接这么写
	cout << v1.size() << endl;	//有效数据个数
	cout << v1.capacity() << endl;	//v1容量大小
	cout << v1.empty() << endl;  //v1是否为空
	return 0;
}

结果如下：

对于reserve()函数与resize()函数与之前学习过的string类类似：

• reserve(size_t n)

当n>capacity时，进行扩容到n；当n<=capacity时不做处理

测试代码如下：

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

int main()
{
	vector<int> v1(20, 0);
	cout << "v1(20, 0)" << endl;
	cout << "size:" << v1.size() << endl;	
	cout << "capacity:" << v1.capacity() << endl;
	cout << endl;

	v1.reserve(30);
	cout << "v1.reserve(30):" << endl;
	cout << "size:" << v1.size() << endl;	//size不变
	cout << "capacity:" << v1.capacity() << endl;//capacity改变
	cout << endl;



	v1.reserve(10);
	cout << "v1.reserve(10):" << endl;
	cout << "size:" << v1.size() << endl; //size不变
	cout << "capacity:" << v1.capacity() << endl;	//capacity不变
	return 0;
}

结果如下：

• resize(size_t n,const T& value = T())

✨当n>capacity时，进行扩容到n，size也改为n，并将新增的有效数据初始化为value（如果没给value则对于vector容器，默认为0）；
✨对于n<=capacity时，不改变底层空间大小，只是将有效数据个数设为n，并将没有初始化的初始化为value；
✨无论如何都会将容器的size设为n。

测试代码如下：

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

int main()
{
	vector<int> v1(20,0);	//多个数据构造也可以直接这么写
	cout << "v1(20, 1):" << endl;
	cout << "size:"<<v1.size() << endl;	//有效数据个数
	cout << "capacity:" << v1.capacity() << endl;	//v1容量大小
	//遍历v1
	vector<int>::iterator it = v1.begin(); //先获取第一个的位置
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl << endl;


	//resize有效数据个数为10,n<capacity
	cout << "v1.resize(10):" << endl;
	v1.resize(10);
	cout << "size:" << v1.size() << endl;	//有效数据个数改变
	cout << "capacity:" << v1.capacity() << endl;	//v1容量大小不变
	//遍历v1
	 it = v1.begin(); //先获取第一个的位置
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl<<endl;



	//resize有效数据个数为20,n>=capacity
	cout << "v1.resize(20,1):" << endl;
	v1.resize(20,1);
	cout << "size:" << v1.size() << endl;	//有效数据个数改变，并将新增的初始化为1
	cout << "capacity:" << v1.capacity() << endl;	//v1容量大小改变
	//遍历v1
	it = v1.begin(); //先获取第一个的位置
		while (it != v1.end())
		{
			cout << *it <<" ";
			it++;
		}
		cout << endl;

	return 0;
}

结果如下：

当n<capacity时，reserve和resize都不会改变底层空间大小

✨ vector 增删查改

vector增删查改	接口说明
push_back	尾插
pop_back	尾删
find	查找（注意这个是算法模块实现，不是vector的成员接口）
insert	在pos之前插入val
erase	删除pos位置的数据
swap	交换两个vector的数据空间
operator[]	像数组一样访问

☑️operator[]：

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

int main()
{
	vector<int> v1{ 1,2,3,4 };
	//使用[]遍历
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	return 0;
}

结果如下：

☑️尾插和尾删：

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

int main()
{
	vector<int> v1;
	//尾插
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	
	//使用[]遍历
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	//尾删
	v1.pop_back();

	//使用[]遍历
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}

	return 0;
}

☑️查找：

using namespace std;
#include<vector>
#include<iostream>
#include<algorithm>	//包算法头文件

int main()
{
	vector<int> v1{ 1,2,3,4 };
	vector<int>::iterator it = find(v1.begin(), v1.end(), 3);
	return 0;
	
}

因为查找是算法模块实现，不是vector的成员接口，所以使用时要包含算法头文件#include<algorithm>；
find()，传查找开始和结束的迭代器并返回找到位置的迭代器

☑️在pos位置插入删除：
insert：

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

int main()
{
	vector<int> v1{ 1,2,3,4 };
	vector<int>::iterator it = find(v1.begin(), v1.end(), 3);
	//在it位置插入5
	v1.insert(it,5);	//第一个参数是迭代器

	//使用[]遍历
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	return 0;

}

结果如下：

erase：

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

int main()
{
	vector<int> v1{ 1,2,3,4 };
	vector<int>::iterator it = find(v1.begin(), v1.end(), 3);
	//删除it位置的值
	v1.erase(it);	//参数是迭代器

	//使用[]遍历
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	return 0;

}

结果如下：

注意在pos位置插入删除不再使用整数来定位，而是传入迭代器

☑️swap：

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

int main()
{
	vector<int> v1{ 1,2,3,4 };
	vector<int> v2(5, 1);

	v1.swap(v2);	//交换v1和v2


	//使用[]遍历
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;

	//使用[]遍历
	for (int i = 0; i < v2.size(); i++)
	{
		cout << v2[i] << " ";
	}
	return 0;
}

结果如下：

4.vector 迭代器失效问题

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。
因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。

在使用迭代器遍历容器时，如果容器发生结构上的变化，例如元素的插入、删除操作，那么迭代器就可能会失效。

对于vector可能会导致其迭代器失效的操作有：

1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。

测试代码如下：

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

int main()
{
	vector<int> v{ 1,2,3,4,5,6 };

	auto it = v.begin();

	// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
	v.resize(100, 8);

	// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
	// v.reserve(100);

	// 插入元素期间，可能会引起扩容，而导致原空间被释放
	// v.insert(v.begin(), 0);
	// v.push_back(8);
	cout << *it << endl;
	return 0;
}

结果如下：

出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。

2. 指定位置元素的删除操作–erase

erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

测试代码如下：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据，导致pos迭代器失效。
	v.erase(pos);
	cout << *pos << endl; // 此处会导致非法访问
	return 0;
}

✨迭代器失效解决办法

在每次使用前，对迭代器重新赋值即可。

例如上述失效的例子：

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

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据，导致pos迭代器失效。
	v.erase(pos);
	
	//迭代器失效后，再次更新迭代器即可
	pos = find(v.begin(), v.end(), 4);
	cout << *pos << endl; 
	return 0;
}

结果如下：

5.结语

vector容器提供了许多有用的方法和操作符，使得对元素进行插入、删除和访问变得方便和高效。以上就是STL中vector的有关内容啦~ 完结撒花~ 🥳🎉🎉