文章篇幅较长，越3万余字，建议电脑端访问

一、前言

大家好，在上一文中，我们重点介绍了 STL中的string类，明白了如何去操作字符串。本文我们将要来介绍的是STL中的vector类

二、vector的介绍及使用

1、vector的介绍

vector的文档介绍

1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好

2、常用接口细述

1）vector类对象的默认成员函数

构造函数声明	接口说明
vector()（重点）	构造函数
vector（size_type n, const value_type& val = value_type()）)	构造并初始化n个val
vector (InputIterator first, InputIterator last))	使用迭代器进行初始化构造
vector (const vector& x); （重点）	拷贝构造
vector& operator= (const vector& x);	赋值重载

① 构造函数

• 首先的话我们来看构造函数，一共是有三种形式
  • 无参进行构造
  • 放入n个相同数据
  • 根据迭代器区间进行构造

其中的 allocator 是空间配置器，只是用于分配空间，目的为增加申请释放空间的效率

可以看到对于【vector】来说其为一个 模版类，所以我们在实例化的时候要声明其内置类型

template < class T, class Alloc = allocator<T> > class vector;

接下去，我们就到VS中来测试一下

void test_vector1()
{
	vector<int> v1;
	vector<int> v2(3, 2);

	string s("abcd");
	vector<int> v3(s.begin(), s.end());
}

• 以下是调试后的结果。重点我们可以来说一说最后一种迭代器的方式，有同学看到我们存入进去的明明是a b c d四个字符，但是在调试的时候看到的为什么是97 98 99 100呢，原因就在于我们对于【v3】声明的内置类型为int，但是我们传递进去的却是char，所以在这中间产生了一个 隐式类型转换

• 如果想要看到字符的话正确的形式应该改成下面这样

vector<char> v3;

💬 那有同学就说了，这个vector<char> v是不是和string s一样呢，存放的都是字符char

• 这个呢是不可以的，对于前者来说默认是不存在\0的，需要我们去进行添加，但是对于后者来说是一个字符串，而对于字符串来说结尾是存在\0的

vector<char> v;
string s;

💬 此时有同学又问，既然【vector】中可以存放char的话，那可不可以存放string呢

• 这个呢肯定是可以滴，因为【vector】是一个模版类，其会根据所传入的类型去做一个自动类型的推导

vector<string> v;

💬 最后的话再来讲一种初始化的方式，那就是利用我们在C语言阶段所学习过的 指针，虽然表面上利用的是指针的一个偏移量来做的一个初始化工作，但是呢它在底层利用的还是 迭代器 的思维

void test_vector2()
{
	// 利用天然的迭代器 —— 指针进行初始化
	int a[] = { 1, 2, 3, 4 };
	vector<int> v2(a, a + 4);
}

• 一样通过调试来观察一下

② 拷贝构造

然后我们再来聊聊拷贝构造

拷贝方式如下：

vector<int> v1(3, 2);
vector<int> v2(v1);

③ 赋值重载

讲完拷贝构造，那赋值重载一定不能少

• 赋值重载用于对已存在的两个 vector 之间进行赋值，就是值之间的拷贝

v2 = v1;

• 因此呢对于不同类型的数据就无法进行赋值

void test_vector3()
{
	vector<int> v1(3, 2);

	vector<char> v2;
	v2 = v1;
}

2）vector类对象的访问及遍历操作

① operator[]

首先对于访问元素来说的话，最常见的还是 下标 + [ ] 的形式

• 下面是官方文档中的形式，虽然看起来很复杂，但是读者完全不用理会，会用就可以了

reference operator[] (size_type n);const_reference operator[] (size_type n) const;

• 由于我在 string 中对这一块已经讲解得很详细了，它们在使用的时候很类似，此处就不细说了

void test_vector4()
{
	vector<int> v({ 1,2,3,4,5 });
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}

既然降到了这个operator[]的话，就顺带地提一下at()这个接口吧

• 虽然这个接口并不是很常用，但是呢读者可以了解一下

• 我们可以看到，使用at(下标)也是可以访问到对应元素的

for (size_t i = 0; i < v.size(); i++)
{
	cout << v.at(i) << " ";
}

【温馨提示】：对于下标 + [] 的形式，出现问题会报断言错误；但是对于at(下标)来说，如果出现问题的话则会抛出异常

② 迭代器【⭐】

对于【vector】来说的话还是迭代器重要一些

迭代器作为 STL 六大组件，必然是绕不开的话题。库中也准备了多种的迭代器供使用者选择

💬 首先的话来讲讲begin()和end()

• 和【string】中一样，每个迭代器也是具有两种形式，第一个呢是具有 读写 的，第二个则是 只读 的const迭代器

• 使用的方式还是一样，相信读者并不陌生

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

💬 然后的话再来讲讲rbegin()和rend()

• 那对应反向迭代器也是类似

• 反向迭代器呢顾名思义就是从反方向进行遍历

vector<int>::reverse_iterator rit = v.rbegin();
while (rit != v.rend())
{
	cout << *rit << " ";
	rit++;
}

③ 范围for

那么支持迭代器的话，一定支持范围for

• 马上来看看吧

for (auto e : v)
{
	cout << e << " ";
}

---

这里的话再补充一点，说到这个迭代器的话我们还会想到的一点就是算法头文件 algorithm 中的一个库函数叫做【sort】

• 可以先到官方文档中来看看，它有两个重载形式

• 首先来用用第一个，传入一个迭代器的区间即可

sort(v.begin(), v.end());

• 通过运行结果来看，排序出来的结果是默认升序的，这里就要涉及到【sort】函数的第二个重载形式，其最后一个参数其实是STL六大组件中的 ==仿函数==，这一块我会在后面的 STL之优先级队列 中讲解到

• 不过的话这里可以先提一嘴，这个重载形式，默认传入的仿函数对象为less<int>()，这是一个小堆，代表升序；如果我们要进行升序排序的话，需要传入的仿函数对象为greater<int>()，其为一个大堆，代表降序

sort(v.begin(), v.end(), greater<int>());

• 通过运行结果我们就可以观察到确实是进行了降序排序

💬 那有同学说：除了正向迭代器以外，反向迭代器可不可以进行传递呢？

• 这个当然是可以的，看到我在下面传递了反向迭代器，并且默认按照升序来进行排序，那么从后往前进行升序排序即为 从前往后进行降序排序

sort(v.rbegin(), v.rend());

3）vector类对象的常见容量操作

接下去我们来看看vector类对象的常见容量操作

容量空间	接口说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
reverse	改变vector的capacity
resize	将有效字符的个数该成n个，多出的空间用字符c填充

① size

• 首先的话来讲讲size()，其表示为当前容器中的数据个数

void test_vector6()
{
	vector<int> v(10, 1);
	cout << v.size() << endl;
}

• 我们来看到这个执行结果，初始化时我们为容器中放入了10个1，那么其size即为10

② capacity

• 对于【capacity】来说，就是容量大小，这里可以看到其与capacity是一同增长的，也为10

• 我们也可以到 Linux平台 下来进行观察，发现也是一样的结果

---

以上这一点设计到【vector】的默认扩容机制

下面是我们的测试代码

// 测试vector的默认扩容机制
void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	sz = v.capacity();
	cout << "making v grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

• 通过运行结果我们可以发现，在VS下的扩容机制是呈现 1.5 进行增长的，其STL是【P.J.版本】

• 但是呢，在 Linux 下却始终是呈现的一个2倍的扩容机制，其STL是【SGI版本】

③ empty

• 再来看看【empty】接口，当一开始进在初始化后是为空，但是在插入数据后就不为空了

下面两个接口比较重要一点，我会着重讲解

④ reserve

• 首先的话是【reserve】，它的主要功能是 ==开空间，避免频繁扩容==

void TestVectorExpandOP()
{
	vector<int> v;
	size_t sz = v.capacity();
	v.reserve(100); // 提前将容量设置好，可以避免一遍插入一遍扩容
	cout << "making bar grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

• 通过测试我们可以看到，当提前开好空间后，就可以避免频繁地去扩容了

⑤ resize

【resize】的功能则是 ==开空间 + 初始化，并且填上默认值==

• 这一块我们要通过调试来进行观察，首先看到没有resize的样子

• 然后我们传递一个值进去看看，看到调试窗口中的size发生了变化，而且新增了3个为0的数据值

v.resize(3);

---

对于【reserve】和【resize】，我这里还要再讲一个同学们日常中容易犯的错误

• 接下去请读者观察一下下面这段代码，然后看看其中有什么问题？

void test_vector8()
{
    vector<int> v1;
    v1.reserve(10);		
    for (size_t i = 0; i < 10; i++)
    {
        v1[i] = i;	
    }
}

然后我将程序运行起来，发现报出了错误❌

💬 有同学说：感觉这代码也没什么错呀？怎么会有错误呢？

• 大家要关注前面的reserve(10)，我们在上面说到对于【reserve】而言只是做的扩容而已，即只变化capacity，而不会变化size
• 另一点，对于v1[i]我们上面在讲元素访问的时候有说到过，这是下标 + []的访问形式，在出现问题的时候会直接给出断言错误。因为这里我们在【reserve】的时候只是开出了指定的空间，但size还是为0，此时去访问的时候肯定就出错了

正确的改进方法应该是像下面这样的

• 如果我们要使用下标 + [] 的形式去访问元素的话，就需要开出合适的size大小，才能在访问的时候不会造成越界问题

vector<int> v2;
v2.resize(10);
for (size_t i = 0; i < 10; i++)
{
    v2[i] = i;
}

• 我们通过调试来观察一下吧

• 或者呢，我们也可以写成下面这种形式。如果有同学还是要使用【reserve】的话就不要使用下标 + [] 的形式了，而是使用【push_back】的方式去不断尾插数据，因为在不断尾插的过程中就会去做一个扩容，这一点马上就会讲到

vector<int> v3;
v3.reserve(10);		// 提前开好空间，减少扩容，提高效率
for (size_t i = 0; i < 10; i++)
{
    v3.push_back(i);
}

• 同样，我们通过调试来看看

4）vector类对象的修改操作

接下去呢，我们来说说有关vector类对象的修改操作

函数名称	接口说明
push_back（重点）	在字符串后尾插字符c
pop_back（重点）	尾删
insert	在position之前插入val
erase	删除position位置的数据
find	查找。（注意这个是算法模块实现，不是vector的成员接口）

① push_back

这个接口的功能很明确，就是在尾部插入数据

• 假设，我们这里采取string类作为【vector】的内置类型，然后通过三种形式往里面插入数据：第一种是构造出具体的对象，第二种采取的是匿名对象，第三种采取的则是单参数的构造函数所引发的 ==隐式类型转换==

void test_vector9()
{
	vector<string> v;

	string name1("张三");
	v.push_back(name1);

	v.push_back(string("李四"));

	v.push_back("王五");		// 单参数的构造函数支持隐式类型转换
}

• 一样，通过调试来看看

② pop_back

对于【pop_back】来说，很明显就是去尾删最后一个元素

• 以下是代码及其运行结果

v.pop_back();

③ insert

对于【insert】这个接口来说，重载的方法有很多，读者可以自己下去都试试看，我这里只讲解部分

• 还是延续上面的，我们在begin()这个位置插入一个数据，也就相当于是头插

v.insert(v.begin(), "刘琦");

④ erase

有插入，那一定有删除，我们来看看【erase】

• 这里看到有两个重载形式，一个是传递迭代器，另一个则是传递迭代器区间

• 这里我们试试传递一个迭代器，但是呢不是头删，而是删除头部的后一个元素

v.erase(v.begin() + 1);

💬 就上面这样没有难度，但是现在我若是想要删除这个容器内指定的数据呢？该如何去进行操作

• 对于这个操作而言，确实没有实际可用的方法而言是无法做到的，还记得我们在 string中所学习的find()接口 吗？其可以帮助我们去找到指定的内容。但是呢？在【vector】的修改操作中，我们并没有发现 find 这个接口

⑤ find

其实对于这个接口而言，是封装在了 <algorithm> 这个头文件中，称作是一种算法

• 我们一起来看看具体的文档是怎么说的

• 有了它相助后，我们要去删除一个指定的数据就容易多了，传入指定的搜索区间和要查找的值，若是返回的迭代器位置没有到达末尾的话，代表找到了这个值，我们去删除这个迭代器即可

vector<int>::iterator pos = find(v.begin(), v.end(), 1);
if (pos != v.end())
{
	v.erase(pos);
}

• 来看一下执行结果

💬 那我这个时候再拔高一下难度，说我要删除这个容器中所有的【3】，该怎么去完成呢？

• 那既然是一直找的话，我们就需要通过循环来实现，不断地去更新这个pos值，然后找到一个就去删除一个

auto pos = find(v.begin(), v.end(), 3);
while (pos != v.end())
{
	v.erase(pos);
	pos = find(pos + 1, v.end(), 3);
}

• 但是运行起来呢却发现程序崩溃了，这里就涉及到一个 ==迭代器失效的问题==。我们在后面模拟实现的时候再去介绍

三、总结与提炼

最后来总结一下本文所学习的内容

• 本文我们重点讲到的是STL中的 vector类，首先我们初步认识了这个类，逐个地去了解了它的一些接口函数，包括【默认成员函数】、【访问及遍历操作】、【常见容量操作】、【修改操作】这些，对于 vector 来说它不像 string 那样有一百来个接口，而是只有几十个，我又精简地挑了一些比较重要的来进行详述，我所讲到的希望读者都可以学会使用并且搞懂

上就是本文要介绍的所有内容，感谢您的阅读🌹🌹🌹