【1++的C++初阶】之vector

👍作者主页：进击的1++
🤩 专栏链接：【1++的C++初阶】

一，什么是vector?

vector是一种表示大小可变数组的容器。其本质就是动态数组，与我们前面写过的顺序表是大同小异的。与其他动态序列容器相比，vector的随机访问更加高效。但是，其插入与删除由于需要移动数据的原因，就显得效率较低。接下来我们将从其基本构成，各接口的实现原理以及易发生的问题等方面进行vector的学习！

二，构造与析构

与string不同的是，string一定是字符串,而vector中却可以存储多种类型的数据。这是模板就起了很大的作用。我们暂且将其数据类型叫做T。
vector采用的数据结构非常简单，线性连续空间，它以两个迭代器start,finish分别指向已经被使用了的空间。以end_of_storage来指向整块空间的尾端。
因此，其构造函数如下：

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

讲完了构造函数，我们再来讲讲拷贝构造。
先来传统写法的构造函数。

 vector(const vector<T>& v)
		{
			//深拷贝
			_start = new T[v.capacity()];
			//弊端：当有vector<vector<T>>这样的结构时，vector<T>进行的是浅拷贝。
		//	//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();

		}

这里需要注意的就是我们在注释中提到的，当vector中存储的数据是自定义类型涉及到空间时，如果仅仅使用memcpy，则将会出现两对象指向同一块空间。导致同一块空间被析构两次，就会报错。
在说明解决方法前，我们再补充一段代码

void swap(vector<T>& tmp)
		{
			std::swap(_start, tmp._start);
			std::swap(_finish, tmp._finish);
			std::swap(end_of_storage, tmp.end_of_storage);

		}
//赋值重载
vector<T>& operator=( vector<T> v)//在传参时就进行了深拷贝
		{
			swap(v);
			return *this;
		}

有了上述补充代码，我们就可以解决出现的问题了。

解决办法就是，让vector中存储的数据也进行深拷贝，便捷的方法就是利用遍历+其自己的赋值重载（自定义类型）。这样每个vector中的数据（自定义类型）都经过深拷贝，就不会发生同一空间被析构两次的情况。
我们再来学一种用迭代器进行初始化的构造构造。

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)
		{
			
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);

		}

其先是利用迭代器初始化构造出一个临时对象。然后将临时对象内的三个成员交换，由于其三个成员类型为迭代器（本质为T*）因此，交换就是原来tmp对象的空间，由*this维护，*this原来的空间则交给了tmp维护，并且，tmp是在函数内定义的，因此出了此函数，其生命周期结束，进行析构。**（要注意的是，在进行交换前，this对象要进行初始化，若不对其初始化，this中的成员是野指针，释放野指针指向的空间是错误的。)

最后，我们来讲一讲析构的实现----超简单的😎😎😎！
直接上代码😏😏😏

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

三，vector迭代器的实现

在第二小节我们就提到过其迭代器的本质为T*指针。
其迭代器主要作用就是进行遍历。
演示如下：

void test4()
	{
		vector<int> v;

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

除了上述遍历方法，还有一种范围for的遍历方法，其底层的实现就是用的迭代器。演示如下：

void test4()
	{
		vector<int> v;

		v.push_back(1);
		v.push_back(1);
		v.push_back(1);
		v.push_back(1);

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

四，vector部分重要接口的实现

reserve的实现

void reserve(size_t n)
		{
			size_t sz = size();
			if (n > capacity())
			{
				
				iterator tmp = new T[n];
				if (_start)
				{
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;					
				}
				_start = tmp;
				_finish = _start + sz;
				end_of_storage = _start + n;
			}
		}

在文章【1++的C++初阶】之内存管理中，我们有说过new，delete与malloc,free等的一个区别就是，前者能够自动调用构造与析构函数，因此我们在申请空间或者是扩容时，选择用new。当用new进行间接的扩容时，就涉及到了数据的拷贝，解决方法与拷贝构造相同。

resize的实现

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

resize是调整其容器的大小，当其大小大于开辟空间的大小时，就进行扩容；并且，其还具有初始的功能。

insert实现

iterator insert(iterator pos, T val)
		{
			size_t len = pos - _start;
			assert(pos >= begin() && pos <= end());
			//扩容
			if (end_of_storage == _finish)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			//更新pos
			pos = _start + len;
			//移动数据
			iterator end = _finish-1;
			while ( end>= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = val;
			_finish++;
			return pos;
		}

insert是将数据插入到pos位置，首先就要判断pos是否合法，然后要判断空间大小是否满足。**这里要注意的是当扩容后，pos就会失效，因为pos原来指向的空间已经不是我们要的空间了，因此，要更新pos。**在插入时，由于是连续的空间，因此要进行数据的移动。返回插入位置的迭代器。

erase的实现

iterator erase(iterator pos)
		{
			//不考虑缩容
			//移动数据
			assert(pos >= _start && pos < _finish);
			iterator begin = pos;
			while (begin < _finish)
			{
				*begin = *(begin + 1);
				begin++;
			}
			_finish--;
			return pos;
		}

在有些编译器下，会涉及到缩容，因此与insert一样，会面临迭代器失效的问题，因此要更新pos,但我们的实现不考虑缩容的情况。erase原理与insert相似，都要进行数据的挪动。