C++之Vector

不是我衰

已于 2023-09-24 17:19:36 修改

阅读量193

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-09-23 19:59:26 首次发布

本文链接：https://blog.csdn.net/ZZY5707/article/details/132938868

版权

C++ 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

vector的介绍及使用

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的使用

vector提供的接口跟string是非常相似的。注意使用vector需要包对应的头文件。

vector是一个类模板，经过之前的学习我们知道：类模板实例化只能显式实例化，即需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可。类模板不是真正的类，其实例化的结果才是真正的类。这里我们想往vector里放什么类型的数据，直接指定就行了。

构造函数

1. 构造空vector

 explicit vector (const allocator_type& alloc = allocator_type());
只有一个参数，而且有缺省值，是用来传空间配置器的,认为这个就是无参的构造函数就行，即构造一个空的vector，而且配置器在类模板参数里也可以传。

2.用n个val去构造一个vector

explicit vector (size_type n, const value_type& val = value_type(),
                 const allocator_type& alloc = allocator_type());

3.用一段迭代器区间去构造vector

template <class InputIterator>
         vector (InputIterator first, InputIterator last,
                 const allocator_type& alloc = allocator_type());
注意到了它是一个模板：也就是说这里我们不仅可以传vector的迭代器，也可以传其它容器的迭代器，只要它们的数据类型能够匹配或者能进行一个转换。比如们传一个string类型的迭代器：

另外我们是可以控制传过去的这个迭代器区间的范围的，其实迭代器按使用属性可以分为正向反向，const迭代器，按特性属性还可以细分为单向迭代器，双向迭代器和随机迭代器，单向只能++不能- -，双向可以++也可以- -不能+-，那随机除了可以++和- -之外还可以+- 。

string和vector的迭代器是随机迭代器。
int main()
{
	string s("hello world");
	vector<char>v(s.begin()+3, --s.end());
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << v.size() << endl;
	cout << v.capacity() << endl;
	return 0;
}

4.拷贝构造

int main()
{
	vector<int>v1(10, 1);
	vector<int>v2(v1);
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << v2.size() << endl;
	cout << v2.capacity() << endl;
	return 0;
}

vector对象的遍历

1.for循环+[ ]：

int main()
{
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
	return 0;
}

2.vector可以用迭代器，那也就支持了范围for:

int main()
{
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	for (auto& e : v)
	{
		e++;
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

vector的迭代器

iterator的使用	接口说明
begin + end（重点）	获取第一个数据位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator
rbegin + rend	获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的reverse_iterator

int main()
{
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

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

	return 0;
}

如果是const的vector对象就去调const迭代器。

vector 空间增长问题

int main()
{
	// 测试VS下vector的默认扩容机制
	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';
		}
	}
	return 0;
}

VS:

g++:

我们看到和string一样，vector的扩容，在vs上基本上也是1.5倍扩容，在G++上也是二倍去扩。vs是PJ版本STL，g++是SGI版本STL。

reserve和resize

reserve:

int main()
{
// 如果已经确定vector中要存储元素大概个数，可以提前将空间设置足够
// 就可以避免边插入边扩容导致效率低下的问题了
	size_t sz;
	vector<int> v;
	v.reserve(100);// 提前将容量设置好，可以避免一遍插入一遍扩容
	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';
		}
	}
	return 0;
}

resize:

使用resize在这里无法避免多次扩容的问题，resize在开空间的同时还会进行初始化，影响size，后续插入会从size=101开始插入，依然需要扩容。

int main()
{
	// 测试vector的默认扩容机制
	size_t sz;
	vector<int> v;
	v.resize(100);
	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';
		}
	}
	return 0;
}

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。resize在开空间的同时还会进行初始化，影响size。当然如果传的n比size小，resize还会删除多余的数据。

总而言之：reserve改变capacity不改变size，resize即改变capacity又改变size。

vector 增删查改

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

push_back和pop_back

用法和stirng一样。

// 尾插和尾删：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

不像string，vector只支持我们去传迭代器和迭代器区间了。

关于find函数

这里可能会用到find函数。
vector里并没有提供find这个接口，那我们怎么获取目标位置的迭代器呢？虽然vector自己没有提供，不过算法库里面提供了一个find：

也是一个函数模板，可以传任意类型的迭代器，在指定的迭代器范围去寻找要查找的值，找到就返回该位置的迭代器，找不到就返回last（即我们传过来的迭代器区间的右边界）。(为什么返回last，因为任何一个迭代器区间都是左闭右开的。即[first,last))

// 任意位置插入：insert和erase，以及查找find
// 注意find不是vector自身提供的方法，是STL提供的算法
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位置的元素再删掉，可以这样吗？

void TestVector5()
{
	// 使用列表方式初始化，C++11新语法
	vector<int> v{ 1, 2, 3, 4 };

	// 在指定位置前插入值为val的元素，比如：3之前插入30,如果没有则不插入
	// 1. 先使用find查找3所在位置
	// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
	vector<int>::iterator 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位置的数据
	v.erase(pos);

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

这里会涉及迭代器失效,如果要删除pos位置的值，需要重新find一遍为pos赋值。迭代器失效在下面详细解释。

当然如果我们可以直接确定要insert或者erase的位置的迭代器，就没必要用find。

void TestVector5()
{
	// 使用列表方式初始化，C++11新语法
	vector<int> v{ 1, 2, 3, 4 };

	// 在指定位置前插入值为val的元素，比如：3之前插入30,如果没有则不插入
	// 1. 先使用find查找3所在位置
	// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
	vector<int>::iterator 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位置的数据
	pos = find(v.begin(), v.end(), 3);
	v.erase(pos);

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

vector模拟实现

STL_vector源码浏览

我们要了解一个类，首先应该要看一下它有哪些成员变量和成员函数，然后想了解哪一个函数，可以再去看它具体的实现。

首先我们可以找到这三个应该是它的成员变量，那跟之前顺序表的结构还有点差异，之前写的顺序表是一个指针指向动态数组，然后size有效长度，capacity容量。我们看到它们的类型都是iterator。那我们说了迭代器可以理解成一个像指针一样的东西，但不一定是指针，不过我们看到在当前的SGI版本中：迭代器的实现是用的原生指针。

它可以用原生指针实现，但不一定都是用原生指针，vs（采用的PJ版本）上就不是原生指针。

无参的构造函数它们都初始化成0 了。可以看到这里求size就是end() - begin()，求capacity是end_of_storage - begin()，这里的begin()是start，end()是finish。size_type是size_t的typedef。

了解了结构，我们就可以去实现了。

vector的结构

为了防止冲突，我们还是定义在自己的命名空间里。vector本质是一个类模板，那我们实例化时指定什么数据类型，vector里面就放什么类型的数据。

namespace test
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

构造函数与析构函数

构造函数

无参构造

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

有参构造，初始化n个T类型对象

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

value的缺省值是T()，调用默认构造函数产生一个匿名对象去作为这个缺省值，因为这里是模板，要针对所有类型。这里是用产生的这个匿名对象的引用去初始化对象，和临时变量一样，如果我们用匿名对象去初始化一个常引用的话，它的生命周期就会被延长至该引用被销毁。并且这里肯定都要加const的，因为临时变量和匿名对象都具有常性。

对于内置类型，理论上来说，内置类型是没有构造函数这一说的，构造函数是针对自定义类型的，但是有了模板以后，内置类型就也需要支持有构造函数了。

		vector(int 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)。因为函数调用根据参数去匹配的时候，会去找最合适，最匹配的那个，如果没实现迭代器区间构造，那它只有一个选择，但是有了迭代器区间构造之后，编译器觉得区间构造两个参数类型一致(这个例子中都是int)，因此编译器就会将InputIterator实例化为int，也就是选择了"最匹配"的这个，但是10和5根本不是一个区间，编译时就报错了，故需要增加该构造方法

源码中也是重载了多个版本来解决这个编译器匹配问题。

迭代器区间构造

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

拷贝构造

		vector(const vector<T>& v)
            :_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			for (auto e : v)
			{
				push_back(e);
			}
		}

构造都需要初始化成员变量为空指针，那么直接在声明处给初始值即可。

template <class T>
class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
public:

	vector()//默认构造不可缺少
	{}

	vector(size_t n, const T& value = T())
	{
		reserve(n);
		while (n--)
		{
			push_back(value);
		}
	}

	vector(int n, const T& value = T())
	{
		reserve(n);
		while (n--)
		{
			push_back(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)
	{
		reserve(v.capacity());
		for (auto e : v)
		{
			push_back(e);
		}
	}
private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _end_of_storage = nullptr;
}

这里的无参构造看似什么都没做，但不能不写，因为有了显示的构造函数编译器不会再生成默认构造函数，所以需要自己写一个默认构造函数。

析构函数

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

容量相关

size和capacity

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

reserve和resize

reserve

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T* tmp = new T[n];
				size_t sz = size();//提前将size存储起来
				if (_start)
				{
					memcpy(tmp, _start, sz * sizeof(T));
					delete[]_start;
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

注意再扩容前需要定义一个变量存储size(),如果在扩容后再调用size()求大小比如_finish=_start + size()会出问题，因为size()是用_finish - _start算出来的，但扩容后_start已经变化，不能在用原来的_finish-现在的_start，所以要先将size保存起来。

resize

		void resize(size_t n, const T & value = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = value;
					_finish++;
				}
			}
		}

和string的resize类似，如果n比size小缩容，否则剩余的空间填入value。

push_back

如果capacity为0，不能直接乘2，可以给个初始大小

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

operator[ ]

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

begin和end

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

有了迭代器也就支持范围for：

insert与erase

insert

		void insert(iterator pos, const T& value)
		{
			assert(pos <= _finish && pos >= _start);//pos等于_finish是尾插,等于_start是头插
			if (_finish == _end_of_storage)
			{
				reverse(0 == capacity() ? 4 : 2 * capacity());
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{ 
				*(end + 1) = *end;
                end--;
			}
			*pos = value;
			_finish++;
		}

这还没有结束，因为会涉及迭代器失效的问题。

迭代器失效问题

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

insert测试:

int main()
{
	test::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);

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

	v.insert(v.begin(), 8);

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

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

原因在于第二次insert的时候发生了扩容，那为什么发生了扩容就出问题了呢 ?

扩容是不是异地开一块新空间，然后拷贝数据，释放旧空间啊，那这样的话，扩容之后，_start和_finish是不是就变了啊，现在它们指向一块新空间，而pos呢，是不是还是原来的pos,那现在pos和end的大小关系是不是未知的啊，这里循环会走多少次我们也不知道。
此时pos指向的空间以及被释放了，即pos此时是一个野指针了，但我们又把val放到了pos指向的空间，但是对扩容后的新空间并没有影响，只是把_finish++了一次，所以打印出来是随机值。
那这里其实就是迭代器失效的一种情况，扩容之后pos位置的这个迭代器就失效了。
怎么解决？是不是如果扩容的话，我们得去更新一下pos啊。

void insert(iterator pos, const T& value)
{
	assert(pos <= _finish && pos >= _start);
	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;
		reserve(0 == capacity() ? 4 : 2 * capacity());
		//更新pos,解决pos失效问题
		pos = _start + len;
	}
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		end--;
	}
	*pos = value;
	_finish++;
}

可以看到打印结果是正确的。

迭代器失效的其他场景：

先在3的位置前插入一个100:

int main()
{
	test::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

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

	auto pos = find(v.begin(), v.end(), 3);
	v.insert(pos,100);

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

	return 0;
}

现在想用pos改变3位置的值:

int main()
{
	test::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

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

	auto pos = find(v.begin(), v.end(), 3);
	v.insert(pos,100);

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

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

	return 0;
}

看到是100变成了101,也就是pos此时还在原来的3的位置。

如果还涉及了扩容:

int main()
{
	test::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	v.push_back(8);


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

	auto pos = find(v.begin(), v.end(), 3);
	v.insert(pos,100);

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

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

	return 0;
}

此时的pos在扩容之后仍指向原来被释放了的空间，所以pos还是会失效，我们(*pos)++没有对当前操作的vector的任何元素产生影响。

刚才上面这两种情况，第一次虽然insert之后pos还能用，好像没失效（因为没扩容），但是可能已经不是我们想要的位置了，就像上面我们find的是3的位置，但后面++的并不是3 了。
第二种情况由于发生了扩容，pos这个位置的迭代器就是一个野指针了，彻底失效了。

解决方法：

库里面的insert是有返回值的，返回更新后的pos。

		iterator insert(iterator pos, const T& value)
		{
			assert(pos <= _finish && pos >= _start);
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(0 == capacity() ? 4 : 2 * capacity());
				//更新pos,解决pos失效问题
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = value;
			_finish++;
			return pos;
		}

所以迭代器失效的解决方法:重新去find为pos赋值，或者pos接收insert的返回值。

int main()
{
	test::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	v.push_back(8);


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

	auto pos = find(v.begin(), v.end(), 3);
	pos = v.insert(pos,100);

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

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

	return 0;
}

erase

		iterator erase(iterator pos)
		{
			assert(pos <= _finish && pos >= _start);
			iterator start = pos + 1;
			while (start != _finish)
			{
				*(start - 1) = *start;
				start++;
			}
			_finish--;
            return pos;
		}

erase测试:

int main()
{
	test::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	v.push_back(7);
	v.push_back(8);


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

	auto pos = find(v.begin(), v.end(), 3);
	pos = v.erase(pos);

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

	return 0;
}

erase迭代器失效测试:

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

VS中，删除vector中任意位置上元素时，就认为该位置迭代器失效了。

重新接收一下pos就可以：

Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

上面那段代码如果我们在G++环境下面运行会发现结果跟我们自己模拟实现的是一样的，因为我们就是按照SGI版本实现的嘛，g++就是采用的SGI，底层是原生指针。
SGI的STL中，erase导致迭代器失效后，程序不一定会崩溃，但运行结果可能是不对的；如果迭代器位置不在begin和end范围内，肯定会崩溃的。

另外:string存在迭代器失效的问题吗？

当然也是存在的，但是为什么讲string的时候并没有提迭代器失效的问题呢？
因为string的insert和erase提供了下标的版本，用下标的版本是不是就不存在迭代器失效的版本啊，但是它也提供了迭代器的版本，那当然如果用迭代器就跟vector一样了，要考虑迭代器失效的问题。

迭代器失效总结：

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

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

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);
/*
出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
*/
    while(it != v.end())
    {
        cout<< *it << " " ;
        ++it;
    }
    cout<<endl;
    return 0;
}

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

#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;
}

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

3. 注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
    vector<int> v{1,2,3,4,5};
    for(size_t i = 0; i < v.size(); ++i)
        cout << v[i] << " ";
    cout << endl;
    auto it = v.begin();
    cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
// 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效
    v.reserve(100);
    cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
// 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会
// 虽然可能运行，但是输出的结果是不对的
    while(it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}
程序输出：
1 2 3 4 5
扩容之前，vector的容量为: 5
扩容之后，vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5

// 2. erase删除任意位置代码后，linux下迭代器并没有失效
// 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include <vector>
#include <algorithm>
int main()
{
    vector<int> v{1,2,3,4,5};
    vector<int>::iterator it = find(v.begin(), v.end(), 3);
    v.erase(it);
    cout << *it << endl;
    while(it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}
程序可以正常运行，并打印：
4
4 5

// 3: erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
// 此时迭代器是无效的，++it导致程序崩溃
int main()
{
    vector<int> v{1,2,3,4,5};
// vector<int> v{1,2,3,4,5,6};
    auto it = v.begin();
    while(it != v.end())
    {
        if(*it % 2 == 0)
            v.erase(it);
        ++it;
    }
    for(auto e : v)
    cout << e << " ";
    cout << endl;
    return 0;
}
========================================================
// 使用第一组数据时，程序可以运行
[sly@VM-0-3-centos 20220114]$ g++ testVector.cpp -std=c++11
[sly@VM-0-3-centos 20220114]$ ./a.out
1 3 5
=========================================================
// 使用第二组数据时，程序最终会崩溃
[sly@VM-0-3-centos 20220114]$ vim testVector.cpp
[sly@VM-0-3-centos 20220114]$ g++ testVector.cpp -std=c++11
[sly@VM-0-3-centos 20220114]$ ./a.out
Segmentation fault
//正确写法
int main()
{
    //vector<int> v{ 1,2,3,4,5 };
    vector<int> v{1,2,3,4,5,6};
    auto it = v.begin();
    while (it != v.end())
    {
        if (*it % 2 == 0)
        {
            it = v.erase(it);
        }
        else
        {
            ++it;
        }
    }
    for (auto e : v)
        cout << e << " ";
    cout << endl;
    return 0;
}

从上述三个例子中可以看到：SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。

迭代器失效解决办法：在使用前，对迭代器重新赋值即可。

使用memcpy拷贝的问题

向vector里插入一些字符串:

void test_vector6()
{
    test::vector<string> v1;
    v1.push_back("111111111111111111111");
    v1.push_back("111111111111111111111");
    v1.push_back("111111111111111111111");
    v1.push_back("111111111111111111111");
    v1.push_back("111111111111111111111");

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

}
int main()
{
    test_vector6();
}

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。
2. 如果拷贝的是内置类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

采用一个个赋值的方式，内置类型直接赋值，如果是涉及资源管理的自定义类型，利用赋值重载调用深拷贝的拷贝构造就可以解决了。

void reserve(size_t n)
{
	if (n > capacity())
	{
		T* tmp = new T[n];
		size_t sz = size();
		if (_start)
		{
			//memcpy(tmp, _start, sz * sizeof(T));
			for (size_t i = 0; i < sz; i++)
			{
				tmp[i] = _start[i];
			}
			delete[]_start;
		}
		_start = tmp;
		_finish = _start + sz;
		_end_of_storage = _start + n;
	}
}

总结：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

完整版

namespace test
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	public:
///
///构造与析构函数
		vector()
		{}

		vector(size_t n, const T& value = T())
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}

		vector(int n, const T& value = T())
		{
			reserve(n);
			while (n--)
			{
				push_back(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)
		{
			reserve(v.capacity());
			for (auto e : v)
			{
				push_back(e);
			}
		}

		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}
///
///容量相关
		size_t size() const
		{
			return _finish - _start;
		}

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T* tmp = new T[n];
				size_t sz = size();
				if (_start)
				{
					//memcpy(tmp, _start, sz * sizeof(T));
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const T & value = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = value;
					_finish++;
				}
			}
		}

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

		iterator insert(iterator pos, const T& value)
		{
			assert(pos <= _finish && pos >= _start);
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(0 == capacity() ? 4 : 2 * capacity());
				//更新pos,解决pos失效问题
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = value;
			_finish++;
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos <= _finish && pos >= _start);
			iterator start = pos + 1;
			while (start != _finish)
			{
				*(start - 1) = *start;
				start++;
			}
			_finish--;
			return pos;
		}

		T& operator[](size_t pos)
		{
			assert(pos < size());
			return *(_start + pos);
		}
///
///迭代器相关
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}