[c++基础]-vector类

前言

作者：小蜗牛向前冲

名言：我可以接受失败，但我不能接受放弃

 如果觉的博主的文章还不错的话，还请点赞，收藏，关注支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。

目录

一、 vector类的基本用法

1、什么是vector

2、vector的基本使用 

3、reserve 和resize使用细节

​二、刨析迭代器失效

1、引起其底层空间改变导致失效

 2、指定位置元素的删除操作--erase导致失效

 三、模拟实现vector

1、模拟实现

2、模拟实现中深浅拷贝问题

---

本期学习目标: 了解vector类的基本用法，刨析迭代器失效问题，刨析深浅拷贝问题，模拟实现vector。

一、 vector类的基本用法

1、什么是vector

简单点来是其实就是一个数组，那这和我们在C语言学习的数组又有什么区别。

下面我们来看到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、vector的基本使用 

对于vector的来是他是一个类，他有自己的成员函数和成员变量，但是这次我们不在一一去为大家分析，大家有不理解的地方可以多多查询文档。(博主一般用cplusplus查询)

我对数据进行操作无法就是对数据进行增删查改，而数组也是要对数据进行处理的，下面我们就一起去见一见vector的增删查改。

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

简单举例：

int main()
{
	vector v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	//迭代器遍历
	vector::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

  上面那些增删查改的接口大家多用用就会使用了，但是大家都知道C++的语法是细节特别多的，

 下面我们了解一下在使用的时候要注意哪些细节：

3、reserve 和resize使用细节

大家可能会说reserve不就是提前开好空间吗？resize不就是开空间并初始化吗？这哪里有什么细节。下面大家看看一段代码：

void test()
{
	vector v;
	//开好100个元素的空间
	v.reserve(100);
	//用[]插入10个元素
	for (size_t i = 0;i < 10;++i)
	{
		v[i] = i;
	}
}

大家觉的上面代码可行吗？不少小伙伴可能会说没问题，我开好了100个元素的空间，存放10个元素肯定没问题，但事实真的是如此吗？

 但是实际上代码崩溃了，还是断错误，这是怎么回事呢?难道我们不能使用我开辟的空间吗？

 其实不然，我是可以使用，但是由于在重载[]的时候加了检测是否越界的断言，因为我们用reserve仅仅只是开辟了100个空间，但是size==0，而[]的检测正好是检测size在遍历的时候有没有超过，而刚刚开始数组中的元素为0，而我们却要输入到第10个元素这肯定是不被允许的。

那么当我们要为数组赋值元素怎么办了，就可以用resize初始化好元素个数在进行赋值。

void test3()
{
	vector v;
	//开好10个元素的空间
	v.resize(10);
	//用[]插入10个元素
	for (size_t i = 0;i < 10;++i)
	{
		v[i] = i;
	}
	for (auto ret : v)
	{
		cout << ret << " ";
	}
	cout << endl;
}

二、刨析迭代器失效

在很多种情况下vector的迭代器会失效，为什么会失效呢？

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

1、引起其底层空间改变导致失效

      当我们对数组进行增删查改时，会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、 push_back等。

void test4()
{
	vector v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	auto it = v.begin();
	v.resize(100, 2);//扩间
}

扩容前 

扩容后

      这里我们可看到当v进行扩容后，他的空间不在是原来的空间进行扩容的而是，进行异地扩容的。但是这时候it他任何指向原来的空间，而原来的空间已经释放，所以他会失效。也就是说当用vector开辟出来的数组在扩容后，有可能会导致迭代器失效。

 2、指定位置元素的删除操作--erase导致失效

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

下面继续举个例子：

#include 
#include 
using namespace std;

int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	vector::iterator pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据，导致pos迭代器失效。
	v.erase(pos);
	cout << *pos << endl; // 此处会导致非法访问
	return 0;
}

 当我们进行调试的时候发现程序会崩溃，大家可能会想我这不删除的是3吗?这时pos的应该指向4啊？没问题，但是由于C++的检测机制的原因，这里我们仍然认为pos是失效的。

所以是：只要我们进行了erase操作次迭代器就会失效。

那我们在后面又要用到迭代器怎么办？

其实很简单，我们只要在迭代器失效后在更新一下迭代器就可以了。

 三、模拟实现vector

1、模拟实现

为了更好的理解vector的底层实现，下面要模拟实现vector:

这里我们写二个文件，test.cpp用来测试，而vector.h用来实现cector各种功能

#define  _CRT_SECURE_NO_WARNINGS

#include
#include
#include
#include
using namespace std;
#include"vector.h"

int main()
{
	pjb::test2();
	return 0;
}

test.cpp 

#pragma once


namespace pjb
{
	template
	class vector
	{
	public:
		//二种版本的迭代器
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish ;
		}
		const_iterator begin()const
		{
			return _start;
		}

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

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

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

		T& operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];//这里可理解_strart是一个指针
		}

		T& operator[](size_t pos)const
		{
			assert(pos < size());
			return _start[pos];//这里可理解_strart是一个指针
		}

		//析构函数
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{}
		//拷贝构造v2(v1)
		vector(size_t n,const T& val =T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < n;++i)
			{
				push_back(val);
			}
		}
		//这里是为了解决类型不匹配的问题
		//vector v(10,1);
		//vectorv(10,'A');
		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
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(const vector& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector tmp(v.begin(), v.end());
			swap(tmp);
		}

		//析构函数
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

		//开内存
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * oldSize);//用memcop会出现浅拷贝的问题
					for (size_t i = 0;i < oldSize;++i)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;//释放原来的空间
				}
				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}
		//开内存并初始化
		void resize(size_t n,T val = T ())
		{
			if (n > capacity())
			{
				reserve(n);
			}
			if (n > size())
			{
				//进行初始化，size后面的空间
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			//删除数据
			else
			{
				_finish = _start + n;
			}
		}
		//重载=
		//v1==v2
		vector& operator=(vector v)
		{
			swap(v);
			return *this;
		}

		//尾插
		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;
		}
		//插入
		//迭代器失效
		void insert(iterator pos, const T& val)
		{
			assert(pos < _finish);
			assert(pos >= _start);
			if (_finish == _endofstorage)
			{
				//提前算好pos距离_start的距离，好进行更新
				size_t  len = pos - _start;
				size_t  newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
				//这里由于扩容回导致迭代器失效，需要跟更新pos
				pos = _start + len;
			}
			//挪动数据,从后向前挪动
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = val;
			++_finish;
		}
		//交换
		void swap(vector& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}
		//清理
		void clear()
		{
			_finish = _start;
		}
	private:
		iterator _start;//指向数组的第1个数据
		iterator _finish;//指向数组最后1个元素的下个位置
		iterator _endofstorage;//指向容量的位置
	};

vector.h

2、模拟实现中深浅拷贝问题

其实我们在模拟实现中要考虑很多问题，其中最为重要的是迭代器失效和深浅拷贝问题，迭代器失效的问题前面已经说过了这里就不在多说了，下面我们一起来研究一下深浅拷贝问题。

这里我们来看上面我们模拟实现reserve:

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				T* tmp = new T[n];
				if (_start)
				{
					memcpy(tmp, _start, sizeof(T) * oldSize);
					delete[]_start;//释放原来的空间
				}
				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}

分析: 

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

测试代码：

	void test3()
	{
		vector> vv;
		vector v(5, 1);
		vv.push_back(v);
		vv.push_back(v);
		vv.push_back(v);
		vv.push_back(v);
		vv.push_back(v);//这里多了这里插入就要扩容

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

 

不需要扩容 

要扩容 

 这里我们用的是一个二维数组，也就是vector的类型又是一个vector，这里为什么会崩溃，其原来是这里进行了扩容，就要进行空间的拷贝，但这里进行的是浅拷贝，所以就崩溃了。

 没扩容前的空间指向

 

 扩容后

这里结合上图我们一起了分析一下为什么一扩容就会崩溃呢？

在扩容前vector*的数组他指向一个空间，这个空间存放了多个vector。

但是当扩容后，vtmp就扩容8空间存放多个vector这是没问题的；但是这里每个vector由于用的是memcpy拷贝的，就会出现浅拷贝现象，也就是tmp中的vector的仍然指向原来的空间，但是当拷贝完后vector的原空间是要被释放的。使用这里程序自然就崩溃了。

那我们怎么解决呢？

其实也很简单，我们只要保证进行二次深拷贝就可以了。

		//开内存
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldSize = size();
				T* tmp = new T[n];
				if (_start)
				{
/*					memcpy(tmp, _start, sizeof(T) * oldSize);*///用memcop会出现浅拷贝的问题
					for (size_t i = 0;i < oldSize;++i)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;//释放原来的空间
				}
				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}

这里我们调用对象的赋值就可以解决了。