【C++】深入浅出STL之vector类

文章篇幅较长，越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类对象的默认成员函数

① 构造函数

• 首先的话我们来看构造函数，一共是有三种形式
  • 无参进行构造
  • 放入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

• 首先的话来讲讲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

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

• 假设，我们这里采取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);
}

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

三、vector深度剖析及模拟实现【✔】

在介绍完了【vector】的基本接口后，我们就透过源码来深入理解一下

1、源码引入

• 以下我所介绍的都是基于【SGI】版本的STL，对源码有兴趣的同学可以去看看 侯捷老师的《STL源码剖析》

• 然后呢我们就去调出【vector】的一些核心源码，这里我们主要关注的就是这个使用原生指针value_type*所定义出来的迭代器 iterator
• 然后我们又看到了保护成员：[start]、[finish]、[end_of_stroage]。看到它们你是否有想起我们在 模拟string 的时候写到过的 [a]、[size]、[capacity]；没错，它们就存在着一定的对应关系

• 但是呢，只看上面这些成员变量还不够，我们要将其带入到具体的场景中，例如下面有两个接口分别为【尾插】和【扩容】，对于push_back()封装得没有那么厉害，读者结合下面的图应该就能看得懂，分别就是 未满追加的逻辑和已满扩容的逻辑
• 那对于reserve()来说，就是一个扩容的逻辑，【allocate_and_copy】是开辟和拷贝空间，那【deallocate】就是释放空间。在扩完容之后不要忘了去对三个成员变量做更新，这一块的模拟实现我在下面马上就会讲到

• 最后的话我们再来看看 构造函数construct和析构函数destroy，光看代码，不知你是否回忆起了我们曾经在 C/C++内存管理 中有讲到【定位new】这个概念，而且提到了 内存池 这个概念
• 其实我们在调用构造函数的时候，都是通过【空间适配器】在 内存池 中开出空间；那在出了作用域之后这些所开的空间都要销毁了，所以就会去调用析构函数完成释放

💬 对于上面的这些源码呢，读者可以在学习了STL一段时间后，配合侯捷老师的《STL源码剖析》再去展开阅读，因为考虑到读者的基础，就不在继续深入讲解了~

2、模拟实现

然后我们就来模拟实现一下【vector】中的各种接口

• 还是一下，我们先简述一下整体的架构。这个vector类还是包在【bit】这个命名空间中，而对于这个类而言，我要将其定义为一个 模版类，这一块如果还有同学不太熟悉的话可以去看看 C++模版
• 其他部分可以看到迭代器我定义的就是原生指针类型，然后将[_start]、[_finish]、[_end_of_storage]也定义为了三个迭代器类型，并且采用提前声明的形式将它们都初始化为nullptr，这样当我们后面在写 构造函数和析构函数 的时候就不需要再去做初始化了

namespace bit {
	template<class T>
	class vector {
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	// 主要接口函数
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

1）迭代器

• 首先的话简单一点，来实现一下迭代器，分为非const版本和const版本

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

const_iterator begin()  const
{
	return _start;
}

const_iterator end()	const
{
	return _finish;
}

2）容量

• 然后我们来讲讲容量相关的接口，首先的话就是【size】和【capacity】这两个接口

size_t size()
{
	return _finish - _start;
}

size_t capacity()
{
	return _end_of_storage - _start;
}

• 对于【size】而言指的是当前这个容器中的数据个数，那也就是我们在上面所讲的_start和_finish这两个迭代器之间的距离，我们之前有说到过迭代器它的底层其实就是指针，那要计算出两个指针之间的数据个数的话让它们做一个相减_finish - _start
• 那对于整个容器的容量【capacity】来说，即为_end_of_storage - _start。读者通过下图便可一目了然地看出来

• 然后呢再来说说扩容这一块的接口【reserve】，首先在一进来的时候我们要去做一个判断，只有当所传入的值要比原先的capacity()来得大的时候，我们才去执行一个扩容的逻辑，在内部的扩容逻辑中可以看到我们使用到了前面所定义的模版参数T，这样去写的话就可以根据不同的类型参数开出不同的空间
• 接下去我们所执行的就是拷贝的逻辑，采取到的是内存函数memcpy()，拷贝完后再去释放原空间，接下去把这些成员变量去做一个更新即可

看着逻辑很清晰，但是呢下面的代码存在着非常多的漏洞

void reserve(size_t n)
{
	if (n > capacity())
	{
		T* tmp = new T[n];		// 开一块新空间
		if (_start)
		{
			memcpy(tmp, _start, sizeof(T) * size());
			delete[] _start;
		}
		_start = tmp;
		_finish = _start + size();
		_end_of_storage = _start + n;
	}
}

• 我们这里再写一个push_back的接口（后面讲），让代码先跑起来

void push_back(const T& x)
{
	if (_finish == _end_of_storage)
	{
		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
	}
	*_finish = x;
	_finish++;
}

💻第一轮测试 — 空指针异常

下面是测试的代码

void test_vector1()
{
	bit::vector<int> v;

	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

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

• 但是呢在运行起来后却发现程序出现了崩溃，这是为什么呢？

• 按下【F5】以调试的方式运行起来就可以发现有地方出现了 空指针异常

• 进一步，我们通过【调试窗口】再来看看，很明显得就看到这个_finish的值为【0x00000000】

• 知道了问题所在，接下去我们就通过调试一步步地来看。虽然这个代码是崩在191，但是呢其实真正的问题还是出在【reserve】这个扩容的逻辑中，随着我们一步一步地去看，可以看到_start和_end_of_storage这两个都没什么问题，但是_finish就是没有什么变化，所以呢我们可以锁定到下面这句话

_finish = _start + size();

• 此时就需要去看看这个【size】了，之前我们使用的是_finish - _start来计算的 size()，在执行这句话时_start已经发生了改变，因为我们去开出了一块新的空间，但是这时_finish的值还是一开始的【nullptr】，那么这个 size() 最后计算出来的大小即为 -_start，此时再和_start去做一个结合的话即为 0

💬 所以，上述就是为什么这个_finish的值为【0x00000000】原因，那我们要如何去修改呢？

• 首先第一种解决方案，就是先去更新这个_finish，用开出空间的 tmp 去做一个更新，然后再用 tmp 去更新_start，这样就不会出现问题了

_finish = tmp + size();
_start = tmp;
_end_of_storage = _start + n;

• 通过调试来观察看看就发现确实不为空了

💬 但是呢上面这种方案的话可能你的徒弟在维护你的代码的时候就会觉得很奇怪，又给改回去了，导致原先的问题再度发生，所以我们可以采取下面这种策略

• 我们可以在每次没开始扩容之前我们都可以去事先保存一下这个 size()，后面的更新顺序就不需要发生变动了，在加的时候加上sz即可

if (n > capacity())
{
	// 先保存一下原先的size()
	size_t sz = size();
	T* tmp = new T[n];		// 开一块新空间
	if (_start)
	{
		memcpy(tmp, _start, sizeof(T) * size());
		delete[] _start;
	}
	_start = tmp;
	_finish = _start + sz;
	_end_of_storage = _start + n;
}

• 通过调试再来看到确实也可以起到同样的效果

👉 但是呢这还没完，【reserve】接口还是存在问题

💻第二轮测试 — memcpy的拷贝问题

• 下面是我们要进行第二轮测试的代码，内部类型使用的是 string类

void test_vector2()
{
	bit::vector<string> v;

	v.push_back("11111");
	v.push_back("22222");
	v.push_back("33333");
	v.push_back("44444");

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

• 运行起来看并没有什么问题

• 但是呢当我再去push_back("55555")的时候程序却出现了问题

💬 那此时有的同学脑子转得很快，感觉到一定是【reserve】扩容的地方出现了问题

• 于是经过我们的排查，先定位到了这一句，有同学就觉得是不是因为每次sizeof(T)的对象大小不一样了?

memcpy(tmp, _start, sizeof(T) * size());

我觉得上述这个老铁提出来的问题非常好，我们一起来看看。请读者思考一下下面的结果是多少

void test_vector3()
{
	string s1("11111");
	string s2;
	string s3("222222222222222222");

	cout << sizeof(s1) << endl;
	cout << sizeof(s2) << endl;
	cout << sizeof(s3) << endl;
}

• 如果有阅读过 深入浅出STL之string类 的同学一定可以知道在VS下对于每个string对象的大小都是固定死的，均为 28B，即使是通过不同的构造形式构造出来的对象也是一样的

接下去呢，就带读者好好地通过调试观察一下💻

v.push_back("1111111111111111");
v.push_back("2222222222222222");
v.push_back("3333333333333333");
v.push_back("4444444444444444");
v.push_back("5555555555555555");

• 如果对深浅拷贝这一块比较了解的同学一定可以知晓这里很明显地发生了一个 浅拷贝 的问题，所以导致在delete[] _start的时候发生了一个 并发修改 的问题

• 这就导致了我们在释放原本的这块空间时导致拷贝后的这块空间也造成了另一块空间的问题

可能有的读者还是不太理解这其中的原理，我们通过画图再来看看

• 可以看到，在扩容的时候我们去开出了一块新的空间，然后使用memcpy()将数据原封不动地拷贝到了另一块空间中，再去做了一个扩容，那在上面我们也看到过了，就是因为这个memcpy()原封不动拷贝的问题，就使得新空间和旧空间虽然是两块独立的空间，但是呢每个对象中的_str都和另一个对象指向了那一块同样的空间

• 那么在接下去在执行这句代码的时候就会先去调用当前对象的析构函数将每一块空间中的内容先清理掉，然后再去调用delete释放掉整块空间。因为每两个对象所指向的空间都是同一块的，所以在释放的时候就会造成同时修改的问题

delete[] _start;

【总结一下】：

vector是深拷贝，但是vector空间上存的对象是string的数组，使用memcpy()导致string对象的浅拷贝

那我们要如何去避免这一种问题呢？

• 很简单，我们去换一下这个拷贝的逻辑就可以了，不要使用memcpy()去进行浅拷贝，而是使用下面这种形式去进行拷贝
• 对于tmp[i] = _start[i]如果对代码比较敏感的同学应该可以很快地看出这会去调用 string类 的赋值重载，然后去做一个深拷贝，此时就不会造成两个_str指向同一块空间了

for (size_t i = 0; i < size(); i++)
{
	tmp[i] = _start[i];
}

• 最后通过调试再来观察一下👀

以下就是【reserve】这个接口的最终完整版实现逻辑

void reserve(size_t n)
{
	if (n > capacity())
	{
		// 先保存一下原先的size()
		size_t sz = size();
		T* tmp = new T[n];		// 开一块新空间
		if (_start)
		{
			//memcpy(tmp, _start, sizeof(T) * size());
			for (size_t i = 0; i < size(); i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = tmp;
		_finish = _start + sz;
		_end_of_storage = _start + n;
	}
}

接下去的话我们再来看看【resize】这个接口该如何去实现

• 还是一样分为三类来进行讨论：
  • 一个是n < _finish的情况；
  • 第二个是n > _finish && n <= _end_of_storage的情况；
  • 第三个是n >_end_of_storage的情况；
• 对于后两种情况我们可以做一个合并，使用上面【reserve】去做一个容量的检查

• 我们来看一下具体的代码，首先是第一种，直接让_finish = _start + n即可；如果是另一种情况的话，就先使用【reserve】去检查一下是否需要扩容，然后再去通过循环追加对应的数据即可

void resize(size_t n, const T& val = T())
{
	if (n < size())
	{
		_finish = _start + n;
	}
	else
	{
		// 先使用reserve()去检查一下是否需要扩容
		reserve(n);
		while (_finish != _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
}

• 可能有同学比较好奇这个T()是干嘛的，还记我们在 C++缺省参数 中所讲到的知识点吗。没错，这个T()就是给到的默认缺省参数，因为当前的形参【val】的类型使用的就是模版参数类型，采取自动推导的形式去进行自动识别
• 而T()就是我们在 类和对象小知识 中所学习过的【匿名对象】，切记这里不可以给0，因为当前的数据类型不一定就是 整型，我们就可以根据这个匿名对象去生成不同的默认值

const T& val = T()

简单地来测试一下

3）元素访问

• 对于元素访问的话我们最常用的就是下标 + []的形式，这里给出两种，一个是const版本和非const版本

T& operator[](size_t pos)
{
	assert(pos < size());
	return _start[pos];
}

T& operator[](size_t pos)	const
{
	assert(pos < size());
	return _start[pos];
}

4）修改操作

接下去的话我们来讲讲有关修改操作的一些接口

• 首先第一个的话就是push_back，这个我在上面讲【reserve】的时候给出过，现在仔细地再来讲一讲：首先的话我们要考虑的就是扩容的逻辑，上面我们有讲到在VS下是呈现 1.5倍 的增长趋势，但是在g++下呈现的则是 2倍 的扩容逻辑，这里的扩容的话我们就交给【reserve】来实现

void push_back(const T& x)
{
	if (_finish == _end_of_storage)
	{
		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
	}
	*_finish = x;
	_finish++;
}

然后的话我们来实现一下【insert】这个接口

void insert(iterator pos, const T& x)

这一块的话我们已经讲过很多遍了，要在某一个位置插入数据的话就需要先去挪动部分的数据，这里我们从后往前挪，防止造成覆盖的情况，当数据挪动完毕后，再在pos这个位置插入指定的数据即可

• 在一进入函数的时候大家可以去做一个断言的操作，不过很多同学可能会好奇这边的pos >= _start，为什么可以位于首部

assert(pos >= _start && pos <= _finish);

💬 在讲解 string类 的时候我们确实讲到了这种写法的缺陷，但是读者要看清楚了，这里pos的类型是 iterator，为一个迭代器。而我们在 string类 中所讲到的这个pos呢是一个无符号整数

• 位于首部的迭代器pos不可能是0，因为它是一段空间的地址，有效空间的地址不可能是0，

string& insert (size_t pos, const string& str);

• 不过呢，既然是插入数据的话就一定会存在容量不足的情况，此时就需要一个扩容逻辑，这里我们直接用上面在push_back()接口中所写的即可

// 1.首先考虑扩容逻辑
if (_finish == _end_of_storage)
{
	size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
	reserve(newCapacity);
}

以下是整体的代码

void insert(iterator pos, const T& x)
{
	assert(pos >= _start && pos <= _finish);
	// 1.首先考虑扩容逻辑
	if (_finish == _end_of_storage)
	{
		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
	}

	// 2.挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;
	++_finish;
}

• 那么对于push_back()这个接口我们就可以去复用一下【insert】这个接口了

void push_back(const T& x)
{
	/*if (_finish == _end_of_storage)
	{
		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);
	}
	*_finish = x;
	_finish++;*/
	insert(end(), x);
}

💻第三轮测试 — 迭代器失效问题

• 好，在写完【insert】接口后，我们再来做一个测试。可以发现程序崩溃了

马上，我们通过调试来观察一下

• 此时我们已经往【v】中插入了4个数据，马上使用insert(v.begin(), 100)去做一个头插，那么一进到函数中我们就可以知道这个当前对象的_start和pos所处的迭代器位置是相同的，也就是同一段空间的地址

• 那此时我们知道容器中的空间已经满了，所以会去走一个扩容的逻辑，此时可以看到当前对象this的_start已经发生了改变

• 可以看到，在扩完容之后，当前对象的_start和待插入位置的pos已经发生了变化，那么在此时我们再去挪动数据进行插入的时候就会出现问题了

💬 我们可以通过下面的图示来看看到底这个扩完容之后是怎样的

• 可以看到_start确实发生了一个变化，但是呢pos还是指向原来的那个地方。那读者可以自己去想象一下子在遍历挪动数据的时候究竟何时才是个头呢？

• 我们可以通过调试再来观察一下挪动数据这段逻辑，可以看到在挪动完几次数据后就出现了随机值，并且出现了死循环的问题

🔰 以上所出现的这个问题就被称作是 【迭代器失效的问题】

那我们要如何去解决呢？

💬 有同学说，内部外部无法一起修改的话参数部分加个引用不就行了

void insert(iterator& pos, const T& x)

• 这其实是不对的，因为有些时候我们所传递的迭代器位置是v.begin() + 3，在这中间会去产生一个临时对象，我们知道临时对象是具有常性的，那么传递进去的时候就会造成【权限放大】的问题

v.insert(v.begin() + 3, 6);

💬 那有同学又说，那防止一下权限放大不就好了，加个const

• 这肯定是不可以的，看到程序依旧会出现问题

• 首先大家要明白的一个点是出错的根本原因在于：_start的位置改变了但是pos的位置没有发生改变。
• 所以我们所要做的一个点就是：让pos的位置随着_start的变动而一起变动，这样就不会出现问题了。以下我们需要改进的代码部分，在进行扩容之前，我们可以先去计算一下从【_start】到【pos】的位置有多远；
• 然后呢我们在执行完扩容的逻辑之后，就要去更新一下这个【pos】迭代器的位置所在，就使用刚才计算出来的这段距离即可

// 1.首先考虑扩容逻辑
if (_finish == _end_of_storage)
{
	// 首先保存一下从_start到pos的距离
	size_t len = pos - _start;

	size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
	reserve(newCapacity);

	// 再扩完容之后更新一下pos, 解决迭代器失效问题
	pos = _start + len;
}

那代码做了更新之后迭代器失效的问题真的解决了呢，我们通过调试一起来看看

• 可以看到，通过我们的骚操作😛【pos】位置就随着【start】的变化而随着变化

• 但是呢就上面这样还不够，我们只解决了内部迭代器失效的问题，而外部迭代器失效的问题并没有很好地解决。
• 外部迭代器，那是什么东西？ 我们来看下这段代码

bit::vector<int>::iterator it = v.begin();
v.insert(it, 33);
bit::print(v);

cout << *it << endl;

bit::print(v);

可以看到，在使用完这个这个迭代器之后再去访问就出现了问题

如果直接其换成库里面的【vector】的话，就直接崩溃了

👉 所以，对于迭代器这一块我们在使用的时候一定要慎重，在使用完之后不要去轻易地修改它

it = v.insert(it, 33);

• 如何执意要进行修改的话也不是没有办法，我们只需要在【insert】之后去接受一下当前所操作的这个迭代器的位置即可，记住这个位置，下次在访问的时候也就不会出问题

具体代码如下：

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start && pos <= _finish);
	// 1.首先考虑扩容逻辑
	if (_finish == _end_of_storage)
	{
		// 首先保存一下从_start到pos的距离
		size_t len = pos - _start;

		size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newCapacity);

		// 再扩完容之后更新一下pos, 解决迭代器失效问题
		pos = _start + len;
	}

	// 2.挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;
	++_finish;

	return pos;
}

有【insert】，那一定少不了【erase】，我们继续来看看

• 对于【erase】来说，我们也是需要先去挪动数据的，但是在这里呢我们需要从前往后挪，也是防止造成覆盖的情况

具体代码如下：

void erase(iterator pos)
{
	assert(pos >= _start && pos < _finish);

	iterator end = pos + 1;
	// 移动覆盖
	while (end != _finish)
	{
		*(end - 1) = *end;
		++end;
	}
	--_finish;
}

立马来测试一下：

💬 对于【insert】来说会存在迭代器失效的问题，那对【erase】来说也会有吗？

• 我们立马通过下面的代码来测试一下

void test_vector8()
{
	bit::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	bit::print(v);

	auto it = v.begin();
	v.erase(it);

	cout << *it << endl;
	it++;
	cout << *it << endl;
	bit::print(v);
}

• 运行起来我们可以看到，并没有出现任何的问题，首先去删除了第一个元素，然后再访问到首个位置便是【2】，接下去再去执行it++并访问的话便是【3】

• 但若是我们将代码换成下面这样的话就会出现问题了

auto it = v.begin() + 3;

• 运行起来可以看到，当我们删除完最后一个元素后再让迭代器后移，就造成了访问越界的问题，出现了随机值的情况

不过呢，上面只是我们使用自己模拟的【vector】，来用用库里的会看会发生什么情况

• 但是呢我们可以看到如果使用库里面的话就会直接造成程序崩溃的问题

💬 上面呢是在VS下的运行结果，之前有说过VS在的STL是【PJ版】，而Linux下则是【SGI版】，所以我们都要去做一个对比

• 可以看到，神奇的事情发生了~ 在Linux下执行同样的两段代码，却没有发生像VS里面那样的报错，甚至在访问越界之后也没有出现随机值的问题，而是【0】

【小结】：

erase以后，迭代器失效了，不能访问。VS进行强制，访问会直接报错；Linux下则不会

然后我们再来看一个点

• 下面这个场景是通过迭代器的形式去删除其中的偶数

auto it = v.begin();
while(it != v.end())
{
    if(*it % 2 == 0)
    {
		v.erase(it);
    }
    ++it;
}

通过运行结果我们可以看出，确实所有的偶数都被删除了

换一个测试用例，我们加一个【2】，然后在删除的时候就发现【2】没有被删干净

再换一个测试用例，我在最后加了一个【6】，运行之后发现报出了Segmentation fault，这是Linux下的段错误问题

我们通过画图来分析一下

• 首先是对于第二种，根据代码来进行走读，当我们删除了第一个【2】后，后面的四个元素就往前移动了一个位置，接着迭代器++后移，就来到了【3】的位置，所以就错过了第2个【2】

• 那对于第三种测试案例，因为最后一个是 偶数 的原因，所以在删除之后迭代器进行了后移，此时呢它已经是越过了end()的位置，再去判断的话永远都到不了，所以就出现了【Segmentation fault】的问题

💬 那要如何去避免呢？

• 这其实很简单，我们不要让这个迭代器每次都后移就可以了

auto it = v.begin();
while(it != v.end())
{
    if(*it % 2 == 0)
    {
		v.erase(it);
    }
   	else
    {   
    	++it;
	}
}

再去打印看一下看看就发现没什么问题了

• 但是呢这段代码如果放到VS上去的话就不一样了，在Linux下确实是不会出现什么问题，但是在VS下还是一样会直接报错，因为VS会进行强制检查，在访问了一次迭代器之后就不可以再继续访问了

💬 此时我们需要去考虑一下【erase】这个接口的详情了

• 我们要看的是这个返回值，其返回值是一个迭代器，而且是刚刚被删除那个元素的下一个位置

iterator erase (const_iterator position);

• 那如果是这样的话我们就可以考虑在每次删除完一个位置的数据后拿返回值接收一下这个所删除元素的下一个位置，那么在下一次继续访问的时候就不会造成修改操作的问题了

it = v.erase(it);

最后【erase】接口的整体代码如下所示：

iterator erase(iterator pos)
{
	assert(pos >= _start && pos < _finish);

	iterator end = pos + 1;
	// 移动覆盖
	while (end != _finish)
	{
		*(end - 1) = *end;
		++end;
	}
	--_finish;
	return pos;
}

在有了【erase】之后，我们就可以让pop_back()去复用这个接口了，可以达到尾删的逻辑

void pop_back()
{
	// 复用erase
	erase(end() - 1);
}

• 最后的话再来讲讲【swap】这个接口，很简单，就是去调用库里面的这个模版函数swap，去一一交换两个对象中的三个成员变量即可。这个接口我下面在讲【赋值重载】时会使用到

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end_of_storage, v._end_of_storage);
}

5）默认成员函数

讲了这么多，终于能来讲讲默认的成员函数了

• 首先的话一定是构造函数，有参构造是一定要实现的，因为这里的逻辑和resize()是类似的，因此我们直接去做一个复用即可

// 有参构造
vector(size_t n, const T& val = T())
{
	resize(n, val);
}

• 那我们在构造的时候就可以去做一个初始化了，发现和v.resize(10, 0)是同样的效果

bit::vector<int> v(10, 0);

💬 那有同学可能会问，三个私有成员变量不需要去做初始化吗？

• 同学，难道你忘了我们在一开始的时候已经给到了它们初始值为nullptr吗？这个措施就是很好地避免编译器对内置类型不会去做初始化的问题

private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _end_of_storage = nullptr;

• 除了上面这种初始化，我再介绍一种方法：那就是使用 迭代器区间

• 这里我们可以去使用循环配合【push_back】接口去做一个初始化

// [first, last)
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

💻第四轮测试 — 双重构造引发调用歧义

接下去，我们马上对这个迭代器区间做的初始化操作去所一个测试

void test_vector6()
{
	bit::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	bit::vector<int> v2(v.begin(), v.end());

	string s("abcdef");
	bit::vector<int> v2(s.begin(), s.end());

	int a[] = { 1,2,3,4 };
	bit::vector<int> v2(a, a + 4);
}

可以看到，除了去初始化自己【vector】对象的迭代器区间，【string】对象也可以，而且指针也没问题

💬 但此时呢，如果我再去以下面的有参构造进行初始化的话就会出现一些问题

bit::vector<int> v5(10, 1);

可以看到，说是“非法的间接寻址”

• 这里对迭代器first去进行解引用目的就是为了获取这个位置上的数据，我们在 指针一文 有所提到 只有指针和迭代器可以解引用，基本数据类型不能解引用

💬 但是有同学一定会疑惑说：为什么这里不会去匹配有参构造，而是去匹配的迭代器区间构造呢？

• 在讲 C++模版 的时候，我们有说到过模版参数会去进行自动类型推导，从而匹配最合适函数模版。因为我们在这里所传入的【10】和【1】都是int类型，但是呢有参构造的第一个形参类型为size_t，并不是最匹配的
• 而迭代器区间初始化其参数类型都是模版参数，所以在匹配的时候它是最优先进行匹配的

那我们该如何去进行预防呢？

• 很简单，我们可以利用在 C++重载函数 中所学习的参数类型不同去另写一个有参构造的重载形式

vector(size_t n, const T& val = T())
{
	resize(n, val);
}

vector(int n, const T& val = T())
{
	resize(n, val);
}

通过调试我们可以看出这里在调用的时候就没有歧义了

💬 最后再补充一个小的知识点，作为拓展

• 那我们在写了这个重载函数后要如何去调用对应的无符号类型size_t呢，此时我们只需要在传递的参数后加上一个u即可，那么编译器在进行识别的时候就会自动将其识别成为无符号整数

bit::vector<int> v6(10u, 6);

一样通过调试来看就可以很清楚

讲完构造函数了，我们来看看拷贝构造

• 首先读者要明确为什么要写拷贝构造，这个我们通过调试来看一下就知道了：很明显可以看到这里只是做了一个浅拷贝，而不是去做了深拷贝

• 所以我们要自己去实现一个深拷贝，逻辑很简单，就不赘述

// 拷贝构造
vector(vector<int>& v)
{
	_start = new T[v.capacity()];
	memcpy(tmp, v._start, sizeof(T) * v.size());
	_finish = tmp + v.size();
	_end_of_storage = tmp + v.capacity();
}

• 但是看到上面这个memcpy()，你是否会有一种警惕的心理呢，因为我们上面讲到过 vector 对象中存放的是 string数组，在拷贝的过程中会产生浅拷贝的问题，那就不可以去使用这个memcpy()，具体问题间下图

• 所以拷贝构造的正确形式应该是下面这样的

// 拷贝构造
vector(vector<T>& v)
{
	_start = new T[v.capacity()];
	//memcpy(_start, v._start, sizeof(T) * v.size());
	for (size_t i = 0; i < v.size(); i++)
	{
		_start[i] = v._start[i];
	}
	_finish = _start + v.size();
	_end_of_storage = _start + v.capacity();
}

• 可以看到，在改成深拷贝后就不会出现类似的问题了

• 当然我们也可以去做一个投机取巧，复用当前已经实现过的接口【reserve】和【push_back】，首先根据所传递进来对象的容量去做一个扩容的逻辑，开出足够多的空间后再将这个对象中的数据一一尾插进当前对象即可

vector(vector<int>& v)
{
	// 根据v的capacity()去开出对应的空间
	reserve(v.capacity());
	for (size_t i = 0; i < v.size(); i++)
	{
		push_back(v[i]);
	}
}

有了拷贝构造，【赋值重载】也少不了

• 还记得我们在上面所实现过的【swap】接口吗，在进行 string模拟 的时候，我们又使用到这么一个巧计，那就是使用 传值传参，首先会去调用一个拷贝构造构造一个临时对象，但是临时对象出了作用域之后肯定是要销毁的
• 此时我们就可以使用【swap】和当前对象去做一个交换，我呢获取到了你里面的内容，你帮我释放了不需要的内容，简直一举两得（还记得PUA弟弟的故事吗😆）

// 赋值重载
const vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}

• 好，我们来调试观察一下。看到在调用赋值重载前就会去 调用拷贝构造

最后的舞台，给到【析构函数】，再怎么花里胡哨，最后最后空间都是要还给操作系统的

~vector()
{
	delete[] _start;
	_start = _finish = _end_of_storage = nullptr;
}

四、总结与提炼

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

• 本文我们重点讲到的是STL中的 vector类，首先我们初步认识了这个类，逐个地去了解了它的一些接口函数，包括【默认成员函数】、【访问及遍历操作】、【常见容量操作】、【修改操作】这些，对于 vector 来说它不像 string 那样有一百来个接口，而是只有几十个，我又精简地挑了一些比较重要的来进行详述，我所讲到的希望读者都可以学会使用并且搞懂
• 但是呢，光简单地了解这些接口还不行，我们要 “知其然，知其所以然”，带着读者把常用的接口都模拟实现了一遍，加强了我们对底层的了解，读者也可以试着在阅读完本文后试着自己去实现一遍，加深印象

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

文章来源地址https://www.toymoban.com/news/detail-638230.html

到了这里，关于【C++】深入浅出STL之vector类的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！