[C++知识库]【C++】STL常用容器：vector（详解及模拟实现）

前言：
本篇内容主要介绍vector的使用，以及vector的深度剖析及模拟实现。
上篇博客：【C++】STL常用容器：string类（详解及模拟实现）

1. vector的介绍及使用

1.1 vector的介绍

学习工具：C++官方文档 -> 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统一的迭代器和引用更好

学习vector，实际上还是按照SLT学习的三个境界：能用，明理，能扩展

1.2 vector的使用

学习vector必须要学会查看文档：vector的文档介绍，这里面有许多它的接口，在往后的学习过程中，要时常查阅该文档，增加对常用接口的理解与记忆。下面主要介绍常用的接口：

1.2.1 vector的定义（构造函数）

下面是一段演示代码：（vs2019底下）

//	vector的构造
int TestVector1()
{
	// constructors used in the same order as described above:
	vector<int> v1;                                // empty vector of ints
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v2(4, 100);                       // four ints with value 100
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v3(v2.begin(), v2.end());  // iterating through v2
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v4(v3);                       // a copy of v3
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;

	// 下面是迭代器初始化的部分
	// the iterator constructor can also be used to construct from arrays:
	int ints[] = { 16,2,77,29 };
	vector<int> v5(ints, ints + sizeof(ints) / sizeof(int));
	//迭代器区间可以是其他容器，比如string、list等都可以传递进行构造

	cout << "The contents of v5 are:";
	for (vector<int>::iterator it = v5.begin(); it != v5.end(); ++it)
		cout << *it << " ";
	cout << endl;

	return 0;
}

运行结果：

1.2.2 vector iterator的使用

下面是一段演示代码：

//  vector的迭代器
void PrintVector(const vector<int>& v)
{
	// const对象使用const迭代器进行遍历打印
	vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void TestVector2()
{
	// 使用push_back插入4个数据
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	// 使用迭代器进行遍历打印
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 使用迭代器进行修改
	it = v.begin();
	while (it != v.end())
	{
		*it *= 2;
		++it;
	}

	// 使用反向迭代器进行遍历再打印
	// vector<int>::reverse_iterator rit = v.rbegin();
	auto rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	//范围for
	for (const auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	PrintVector(v);
}

运行结果：

1.2.3 vector空间增长增长问题

下面是一段演示代码：

//  vector的resize 和 reserve
// reisze(size_t n, const T& val = T())
// 将有效元素个数设置为n个，如果时增多时，增多的元素使用val进行填充
// 注意：resize在增多元素个数时可能会扩容
void TestVector3()
{
	vector<int> v;

	// set some initial content:
	for (int i = 1; i < 10; i++)
		v.push_back(i);

	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;

	v.resize(5);
	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;

	v.resize(8, 100);
	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;

	v.resize(12);
	cout << "v contains:";
	for (size_t i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;
}

// 往vecotr中插入元素时，如果大概已经知道要存放多少个元素
// 可以通过reserve方法提前将容量设置好，避免边插入边扩容效率低
void TestVectorExpandOP()
{
	vector<int> v;
	size_t sz = v.capacity();
	v.reserve(100);   // 提前将容量设置好，可以避免插入过程中多次扩容的消耗
	cout << "making bar grow:" << endl;
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
}

运行结果：

关于vector的扩容机制：

• capacity()的代码在vs和g++下分别运行会发现，vs下的capacity是按1.5倍增长，g++是按2倍增长。这个问题在面试中会经常出现，此时不要简单的认为vector的增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本的STL，而g++是SGI版本的STL，他们的capacity实现上有所差异！
• reserve只是负责开辟空间，如果确定知道要用多少空间，reserve可以缓解vector多次增容的代价缺陷。
• resize在开辟空间的同时，还会进行初始化，最终可影响size,甚至是影响capacity。

下面是一段测试扩容机制的代码，可于不同编译环境底下运行查看结果：

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

运行结果：

1. vs运行结果：vs底下使用的STL基本是用1.5倍方式扩容

making v grow:
capacity changed: 1
capacity changed: 2
capacity changed: 3
capacity changed: 4
capacity changed: 6
capacity changed: 9
capacity changed: 13
capacity changed: 19
capacity changed: 28
capacity changed: 42
capacity changed: 63
capacity changed: 94
capacity changed: 141

2. g++运行结果：linux底下使用的STL基本是用2倍方式扩容

making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128

1.2.4 vector的增删查改

下面是一段演示代码：

// vector的增删改查
// 尾插和尾删：push_back/pop_back
void TestVector4()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	auto it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	v.pop_back();
	v.pop_back();

	it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

// 任意位置插入：insert和erase，以及查找find
// 注意find不是vector自身提供的方法，是STL提供的算法,定义在algorithm头文件中
void TestVector5()
{
	// 使用列表方式初始化，C++11新语法
	vector<int> v{ 1, 2, 3, 4 };

	// 在指定位置前插入值为val的元素，比如：3之前插入30,如果没有则不插入
	// 1. 先使用find查找3所在位置
	// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
	auto pos = find(v.begin(), v.end(), 3);
	if (pos != v.end())
	{
		// 2. 在pos位置之前插入30
		v.insert(pos, 30);
	}

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

	pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据
	v.erase(pos);

	it = v.begin();
	while (it != v.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

// operator[]+index 和 C++11中vector的新式for+auto的遍历
// vector使用这两种遍历方式是比较便捷的。
void TestVector6()
{
	vector<int> v{ 1, 2, 3, 4 };

	// 通过[]读写第0个位置。
	v[0] = 10;
	cout << v[0] << endl;

	// 1. 使用for+[]下标方式遍历
	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;

	vector<int> swapv;
	swapv.swap(v);

	cout << "v data:";
	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;

	// 2. 使用迭代器遍历
	cout << "swapv data:";
	auto it = swapv.begin();
	while (it != swapv.end())
	{
		cout << *it << " ";
		++it;
	}

	// 3. 使用范围for遍历
	for (auto x : v)
		cout << x << " ";
	cout << endl;
}

运行结果：

1.2.5 vector迭代器失效问题（重点）

迭代器的主要作用是让算法能够不关心底层数据结构，实际上迭代器的底层就是一个指针，或者是对指针进行了封装，比如：vector采用连续存储空间来存储元素，所以vector的迭代器就是原生指针T*。因此迭代器失效，实际上就是迭代器底层对应的指针所指向的空间被销毁了，该指针仍继续指向一块已经被释放的空间，若此时继续使用该迭代器，造成的后果就是程序崩溃。

对于vector来说，可能会导致其迭代器失效的操作有以下几种：

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

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

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);
	
	// 给vector重新赋值，可能会引起底层容量改变
	v.assign(100, 8);

	while (it != v.end())
	{
		cout << *it << " ";//直接崩溃，此时由于扩容，it指向的旧空间已经被释放，要重新更新it
		++it;
	}
	cout << endl;

	/*
	出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
	而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
	空间，而引起代码运行时崩溃。
	解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
	赋值即可。
	*/

	return 0;
}

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

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

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失效，再直接访问会崩溃，可以用pos接收erase的返回值！
	cout << *pos << endl; // 此处会导致非法访问

	return 0;
}

erase删除pos位置元素之后，pos位置之后的元素会往前移动，实际上没有导致底层空间的改变（没有空间释放），理论上迭代器不应该失效，但是：若pos刚好指向最后一个元素，删除之后pos刚好是end的位置，此时end位置是没有元素的，即pos失效了。因此在vs底下，不管pos是指向哪，只要删除vector中pos指向的元素后，vs就会认为pos失效了，若不更新，则不会再给用户使用，否则直接报错；而Linux底下，该代码案例pos不指向最后一个元素，有可能不会报错！

下面是一段连续删除的代码，可以分析哪一个才是正确的：

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

int main()//程序崩溃
{
	vector<int> v{ 1, 2, 3, 4 };
	auto it = v.begin();

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

	return 0;
}

int main()//正确
{
	vector<int> v{ 1, 2, 3, 4 };
	auto it = v.begin();

	while (it != v.end())
	{
		if (*it % 2 == 0)
			it = v.erase(it);//每次删除都更新了迭代器
		else
			++it;
	}

	return 0;
}

3. 需注意的是：Linux底下，g++编译器对迭代器失效的检测并不是很严格，处理也没有VS下极端。可以试着在这两个环境底下运行测试代码！
4. 与vector类似，string在插入、扩容、erase之后，迭代器也会出现失效的情况

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

int main()
{
	string s("hello");

	auto it = s.begin();

	// 放开下面代码的注释之后代码会崩溃，因为resize到20，string会进行扩容
	//s.resize(20, '！');

	// 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
	// 后序打印时，再访问it指向的空间程序就会崩溃
	while (it != s.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;

	it = s.begin();
	while (it != s.end())
	{
		// 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
		// it位置的迭代器就失效了
		// s.erase(it);
		//++it;

		//正确写法
		it = s.erase(it);
	}

	for (const auto& e : s)
	{
		cout << e;
	}
	cout << endl;

	return 0;
}

小结：迭代器失效的解决方法就是在每次使用前，都对迭代器进行重新赋值更新即可

2. vector深度剖析及模拟实现

关于vector的内存结构，在《STL源码剖析》中有这样一幅图，清晰地表示了vector成员变量的关系。

2.1 std::vector的核心框架接口的模拟实现

vector.h

#pragma once

#include <iostream>
using namespace std;
#include <assert.h>

// 定义命名空间lww与std中的vector做区分
namespace lww
{
	template<class T>
	class vector
	{
	public:
		// 连续存储空间 -> Vector的迭代器是一个原生指针
		typedef T* iterator;
		typedef const T* const_iterator;

		///
		// 构造和销毁
		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		vector(size_t n, const T& value = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}

		/*
		* 理论上将，提供了vector(size_t n, const T& value = T())之后
		* vector(int n, const T& value = T())就不需要提供了，但是对于：
		* vector<int> v(10, 5);
		* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型
		* 就不会走vector(size_t n, const T& value = T())这个构造方法，
		* 最终选择的是：vector(InputIterator first, InputIterator last)
		* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int
		* 但是10和5根本不是一个区间，编译时就报错了
		* 故需要增加该构造方法
		*/
		vector(int n, const T& value = T())
			: _start(new T[n])
			, _finish(_start + n)
			, _end_of_storage(_finish)
		{
			for (int i = 0; i < n; ++i)
			{
				_start[i] = value;
			}
		}

		// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器
		// 重新声明迭代器，此时迭代器区间[first,last)可以是任意容器的迭代器
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			iterator it = begin();
			const_iterator vit = v.cbegin();
			while (vit != v.cend())
			{
				*it++ = *vit++;
			}
			_finish = it;
		}

		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

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

		/
		// 迭代器相关
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator cbegin() const
		{
			return _start;
		}

		const_iterator cend() const
		{
			return _finish;
		}

		//
		// 容量相关
		size_t size() const
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		bool empty() const
		{
			return _start == _finish;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				// 1. 开辟新空间
				T* tmp = new T[n];

				// 2. 拷贝元素
				// 这里直接使用memcpy只是进行浅拷贝，对于一个若vector里面的元素是一个vector、string等，就会出现浅拷贝问题！！，此时只能使用逐个赋值去进行深拷贝！！
				//if (_start)
				//	memcpy(tmp, _start, sizeof(T)*size);

				if (_start)
				{
					for (size_t i = 0; i < oldSize; ++i)
						tmp[i] = _start[i];//逐个赋值

					// 3. 释放旧空间
					delete[] _start;
				}

				_start = tmp;
				_finish = _start + oldSize;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const T& value = T())
		{
			// 1.如果n小于当前的size，则数据个数缩小到n
			if (n <= size())
			{
				_finish = _start + n;
				return;
			}

			// 2.空间不够则增容
			if (n > capacity())
				reserve(n);

			// 3.将size扩大到n
			iterator it = _finish;
			_finish = _start + n;
			while (it != _finish)
			{
				*it = value;
				++it;
			}
		}

		///
		// 元素访问
		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}

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

		T& front()
		{
			return *_start;
		}

		const T& front()const
		{
			return *_start;
		}

		T& back()
		{
			return *(_finish - 1);
		}

		const T& back()const
		{
			return *(_finish - 1);
		}
		/
		// vector的修改操作
		void push_back(const T& x)
		{
			//if (_finish == _end_of_storage)
			//{
			//	reserve(capacity() == 0 ? 4 : capacity() * 2);
			//}

			//*_finish = x;
			//++_finish;

			insert(end(), x);
		}

		void pop_back()
		{
			//assert(_finish > _start);
			//--_finish;

			erase(end() - 1);
		}

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

		iterator insert(iterator pos, const T& x)
		{
			assert(pos <= _finish);

			// 空间不够先进行增容
			if (_finish == _end_of_storage)
			{
				//size_t size = size();
				size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;
				reserve(newCapacity);

				// 如果发生了增容，需要重置pos
				pos = _start + size();
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			*pos = x;
			++_finish;
			return pos;
		}

		// 返回删除数据的下一个数据
		// 可以解决:一边遍历一边删除的迭代器失效问题
		iterator erase(iterator pos)
		{
			// 挪动数据进行删除
			iterator begin = pos + 1;
			while (begin != _finish) {
				*(begin - 1) = *begin;
				++begin;
			}

			--_finish;
			return pos;
		}

	private:
		iterator _start;		// 指向数据块的开始
		iterator _finish;		// 指向有效数据的尾
		iterator _end_of_storage;  // 指向存储容量的尾
	};
}

test.c

/// 对模拟实现的vector进行严格测试
void TestVector1()
{
	lww::vector<int> v1;
	lww::vector<int> v2(10, 5);

	int array[] = { 1,2,3,4,5 };
	lww::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));

	lww::vector<int> v4(v3);

	for (size_t i = 0; i < v2.size(); ++i)
	{
		cout << v2[i] << " ";
	}
	cout << endl;

	auto it = v3.begin();
	while (it != v3.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

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

void TestVector2()
{
	lww::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	cout << v.front() << endl;
	cout << v.back() << endl;
	cout << v[0] << endl;
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

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

	v.insert(v.begin(), 0);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.erase(v.begin() + 1);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

2.2 使用memcpy导致的浅拷贝问题

若模拟实现的vector中reserve接口中，使用的是memcpy进行的拷贝，试分析以下代码会出现的问题：

#include "vector.h"

int main()
{
	lww::vector<std::string> v;
	v.push_back("1111");
	v.push_back("2222");
	v.push_back("3333");
	return 0;
}

结论：如果对象中涉及到资源管理时，不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。此时，这种情况只能用赋值！