一、介绍

1. vector是表示可变大小数组的序列容器。

2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。

使用STL的三个境界：能用，明理，能扩展，那么下面学习vector，我们也是按照这个方法去学习。

参考文章： vector - C++ Reference (cplusplus.com)

二、定义及其使用

1. 构造函数

vector的构造函数分成四种：

1、无参构造

2、n个val构造

3、迭代器区间构造

4、拷贝构造

我们可以看到，第二种方式的时候调用了val的构造函数。

这是因为val可能不光是内置类型，还可能是一个自定义类型。所以我们会去调用该自定义类型的默认构造来对其进行初始化。当val是一个内置类型的时候，同样也会调用其构造函数，是的，内置类型同样是有构造函数的，这是编译器为了解决上述的问题对内置类型进行的优化处理。

代码案例：

2、有关空间容量的函数接口

一般我们主要用到的两个函数是：resize和reserve。

reserve可以改变容器的容量capacity，但是不会改变有效内容size的大小。

resize因为需要改变size的大小从而可以间接改变capacity的大小。

但是上面两个函数都是不能缩减容器的容量的，只有shrink_to_fit 才能做到缩容。

shrink_to_fit是把容量capacity缩小到有效内容size的大小。因为开辟的内存并不能释放一部分，所以需要重新开辟一块size大小的空间，将内容拷贝过去。这是一种典型的时间换空间的做法。

3、元素访问方式

[ ] 和 at 其实用法是差不多的

但是如果出现越界问题，两者处理方式是不同的。

[ ] 是通过断言来处理的。

而at用的是抛异常的方式，需要捕获异常才行。

4、遍历的方式

vector的遍历和string是一样的，共有三种：

1、通过下标遍历

2、迭代器

3、范围for

代码案例：

注：范围for的底层原理其实也是迭代器。

三、迭代器失效问题

1. 扩容导致的迭代器失效

我们看下面这段代码

int main()
{
	vector<int> v1;
	vector<int>:: iterator it = v1.begin();
	v1.insert(it, 1);
	v1.insert(it, 1);
	v1.insert(it, 1);
	v1.insert(it, 1);
	v1.insert(it, 1);
	v1.insert(it, 1);
	return 0;
}

为什么我们运行的结果会崩呢？

这是因为迭代器失效了，导致的野指针问题。

it指向的是v1的头部，我们每次都往头部插入数据，但是如果发生了扩容，那么存储数据的空间就会发生改变，但是it还是指向原空间的位置，所以再次进行插入的操作时，就会报错。

2、删除导致的迭代器失效

通过前面的我们就能知道了，导致迭代器失效的原因是因为迭代器指向的空间在更改之后没有更新导致的。那么删除有时候空间没有变化会不会也失效呢？

int main()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	v1.push_back(7);
	vector<int>::iterator it = v1.begin();
	v1.erase(it);

	cout << *it << endl;
	return 0;
}

在VS2022下，可以看到，删除数据后就算是迭代器失效了。这是因为在VS上面迭代器不是一个指针，而是一个自定义类型。

但是在g++环境下，却还是可以跑。因为g++使用的迭代器是一个原生指针。

虽然有些环境下能跑，但是我们统一在这里认为失效了，因为不论怎么样，如果删除的是最后一个元素的话，这是后it一定指向的是未知的空间了，如果继续操作，那就会发生问题。

那么我们怎么解决这个问题呢？

办法也非常简单，既然是指向的问题，那么我们每次都更新一下迭代器就好了。

int main()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	v1.push_back(7);
	vector<int>::iterator it = v1.begin();
	it = v1.erase(it);

	cout << *it << endl;
	return 0;
}

四、模拟实现

1、主要框架

vector的成员是三个迭代器：start、finish、end_of_storage。

start指向vector的头部，finish指向有效内容的空间尾部，end_of_storage指向的是整个vector容器的尾部后面一个位置。

2、构造函数错误调用模板

vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}
template <class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

当我们用n给int类型的值来构造一个对象时，会发生错误。原因是编译器会错误的认为n和int是一个类型的，所以会调用下面的这个函数，在这个函数里面解引用last的时候，就会出现问题报错了。

因此，为了解决这个问题，我们有两种的解决方案：

1、调用构造函数的时候把第一个参数强转成size_t

但是这样给使用的人会造成很大的麻烦。

2、再重载一个int版本的构造函数

vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

STL的源码中采用的是第二种方法。

3、使用memcpy导致的浅拷贝问题

当我们实现的reserve函数中，拷贝数据使用的是memcpy时，就会导致浅拷贝问题。

vector中存储的是自定义类型的时候还没有问题，可一旦是自定义类型，那就会导致程序崩溃。

使用memcpy拷贝后，扩容后空间里面的内容还是会指向原空间，这样就导致了两次析构。

所以我们是不能直接用memcpy拷贝的。

代码：

void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* temp = new T[n];

				//非空需要拷贝内容
				if (_start)
				{
					//memcpy在T是自定义类型的时候会发生浅拷贝问题
					//memcpy(temp, _start, sizeof(T) * size());
					for (int i = 0; i < oldsize; ++i)
					{
						temp[i] = _start[i];
					}

					delete[] _start;
				}

				//更新迭代器指向内容
				_start = temp;
				_finish = temp + oldsize;
				_endofstorage = _start + n;
			}
		}

这里很巧秒的复用了 = 号来拷贝每一个自定义类型的内容。

完整代码：

#pragma once
#include <iostream>
#include <algorithm>
#include <assert.h>
using namespace std;
namespace qingshan
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		iterator begin() const
		{
			return _start;
		}

		iterator end() const
		{
			return _finish;
		}

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

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

		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}

		//vector<int> v1(10,1);
		//vector<char> v2(10,'A')
		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		//防止因为要强转而调用下面的类模板，所以重载一个int版本的
		vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector<T> temp(v.begin(), v.end());
			swap(temp);
		}

		//v1 = v2
		//不能v1 = v1
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

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

		size_t size() const
		{
			return _finish - _start;
		}

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* temp = new T[n];

				//非空需要拷贝内容
				if (_start)
				{
					//memcpy在T是自定义类型的时候会发生浅拷贝问题
					//memcpy(temp, _start, sizeof(T) * size());
					for (int i = 0; i < oldsize; ++i)
					{
						temp[i] = _start[i];
					}

					delete[] _start;
				}

				//更新迭代器指向内容
				_start = temp;
				_finish = temp + oldsize;
				_endofstorage = _start + n;
			}
		}

		//T必须要用构造，因为不一定是内置类型
		void resize(size_t n, T val = T())
		{
			if (n > capacity())
			{
				reserve(n);
			}

			if (n > size())
			{
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

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

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

			*(_finish) = x;
			++_finish;
		}

		void pop_back()
		{
			assert(!empty());

			--_finish;
		}

		iterator insert(iterator pos, const T& val)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			//检查容量
			if (_finish == _endofstorage)
			{
				//迭代器失效，需要重置一下pos
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + len;
			}


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

			*pos = val;
			++_finish;

			return pos;
		}

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

			iterator begin = pos + 1;
			while (begin < _finish)
			{
				*(begin - 1) = *begin;
				++begin;
			}

			--_finish;

			return pos;
		}

		//std库里的swap要三次深拷贝，效率太低
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

		void clear()
		{
			_finish = _start;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}