在这里插入图片描述

文章目录

1.vector的介绍及使用
2. vector的模拟实现
- 2.1 SGI版vector实现示意图
- 2.2 具体实现代码

1.vector的介绍及使用

vector的文档介绍（包含函数接口使用）

1.1 vector基本概念

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

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

功能：

vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：

不同之处在于数组是静态空间，而vector可以动态扩展

1.2 vector的使用

vector学习时一定要学会查看文档：>vector的文档介绍<
vector在实际中非常的重要，在实际中我们熟悉常
见的接口就可以，下面列出了哪些接口是要重点掌握的。

1.2.1 vector的定义 (构造函数)

(constructor)构造函数声明	接口说明
vector()（重点）	无参构造
vector（size_type n, const value_type& val = value_type()）	构造并初始化n个val
vector (const vector& x); （重点）	拷贝构造
vector (InputIterator first, InputIterator last);	使用迭代器进行初始化构造

#include <vector>

void printVector(vector<int>& v) {
    
    

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

	vector<int> v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
    
    
		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2(v1.begin(), v1.end());//使用迭代器进行初始化构造
	printVector(v2);

	vector<int> v3(10, 100); //构造并初始化10个100
	printVector(v3);

	vector<int> v4(v3);//拷贝构造
	printVector(v4);
	return 0;
}

小提醒：vector的多种构造方式比较多，灵活运用即可

1.2.2 vector的迭代器使用

在上面的构造函数中，我们可以看到其中有一个接口是用迭代器构造的，这里有一个新的概念，什么是迭代器？

简单来讲，迭代器和 C++ 的指针非常类似，它可以是需要的任意类型，通过迭代器可以指向容器中的某个元素，如果需要，还可以对该元素进行读/写操作。

注意：迭代器的行为像指针，也就是说可以像用指针一样使用迭代器，但它不一定是指针（比如list的迭代器），具体是什么，后续学习其他容器模拟实现即可理解！！！

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

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    
    
	vector<int> v(10, 1);//构造10个1
	std::vector<int>::iterator it = v.begin();//获取v的开始的迭代器，类型是std::vector<int>::iterator
	//auto it1 = v.begin();//类型太长，可以使用auto
	std::vector<int>::iterator end = v.end();//获取v的结尾的迭代器
	while (it != end)
	{
    
    
		cout << *it << " "; //*解引用之后，就可以拿到数据，跟指针*p的操作一样
		++it;//让迭代器往后移一位，跟指针的++p类似
	}
	cout << endl;
	return 0;
}

小提醒：迭代器在STL中非常好用，它屏蔽了底层的细节，保证了用户使用的一致性，而且在后续学习更多容器的时候，迭代器的用法几乎一样

1.2.3 vector 增删查改

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

插入和删除示例：

#include <vector>
void printVector(vector<int>& v) {
    
    

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

int main() {
    
    
	//插入和删除
	vector<int> v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	printVector(v1);
	//尾删
	v1.pop_back();
	printVector(v1);
	//插入
	v1.insert(v1.begin(), 100);
	printVector(v1);

	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);

	//删除
	v1.erase(v1.begin());
	printVector(v1);

	//清空
	v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
	return 0;
}

总结：

尾插 — push_back
尾删 — pop_back
插入 — insert (位置迭代器)
删除 — erase （位置迭代器）
清空 — clear

数据存取示例：

#include <vector>
int main()
{
    
    
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
    
    
		v1.push_back(i);
	}

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

	for (int i = 0; i < v1.size(); i++)
	{
    
    
		cout << v1.at(i) << " ";
	}
	cout << endl;

	cout << "v1的第一个元素为： " << v1.front() << endl;
	cout << "v1的最后一个元素为： " << v1.back() << endl;
	return 0;
}

总结：

除了用迭代器获取vector容器中元素，[ ]和at也可以
front返回容器第一个元素
back返回容器最后一个元素

赋值重载示例：

#include <vector>

void printVector(vector<int>& v) {
    
    

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

int main()
{
    
    
	vector<int> v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
    
    
		v1.push_back(i);
	}
	printVector(v1);

	vector<int>v2;
	v2 = v1;//赋值重载
	printVector(v2);
	vector<int>v3;
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	vector<int>v4;
	v4.assign(10, 100);
	printVector(v4);
	return 0;
}

总结： vector赋值方式比较简单，使用operator=或者assign都可以

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

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

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

会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、
push_back等。
指定位置元素的删除操作--erase

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

示例1

下面的程序运行会崩溃，原因就是因为底层空间发生改变导致迭代器失效

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

示例2

#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就认为该位置迭代器失效了。

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

erase删除任意位置代码后，linux下迭代器并没有失效
因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的 ,但是如果是删除最后一个元素Linux下也同样会失效

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

1.2.5 vector 空间增长问题

容量空间	接口说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize（重点）	改变vector的size
reserve （重点）	改变vector的capacity

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。
这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义
的。vs是PJ版本STL，g++是SGI版本STL。
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问
题。
resize在开空间的同时还会进行初始化，影响size

// 测试vector的默认扩容机制
void TestVectorExpand()
{
    
    
	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';
		}
	}
}
vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
making foo 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

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

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

总结：

判断是否为空 — empty
返回元素个数 — size
返回容器容量 — capacity
重新指定大小 — resize（减少vector在动态扩展容量时的扩展次数）

动态扩展：

并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

2. vector的模拟实现

2.1 SGI版vector实现示意图

vector的实现版本也有不少，我们这次实现的对象是相对来说比较简单的SGI 版的vector

SGI版实现vector的示意图

2.2 具体实现代码

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

//为了和标准库里的vector不冲突，建议用命名空间封装起来
namespace hdm
{
    
    
	template <class T>
	class vector
	{
    
    
	public:
		// vector的迭代器是一个原生指针
		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;
		}

		//无参构造
		vector()
			: _start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
    
    }

		vector(size_t n,const T& val=T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
    
    
			reserve(n);
			while (n--)
			{
    
    
				push_back(val);
			}
		}
		/*
		* 理论上将，提供了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& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
    
    
			reserve(n);
			while (n--)
			{
    
    
				push_back(val);
			}
		}

		// 若使用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());
		//	auto it = v.begin();
		//	auto it1 = begin();
		//	while (it != v.end())
		//	{
    
    
		//		*it1++ = *it++;
		//	}
		//	_finish = it1;
		//}

		//拷贝构造
		//现代写法
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
    
    
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

		//赋值重载
		//现代写法
		vector& operator=(vector<T> tmp)
		{
    
    
			swap(tmp);
			return *this;
		}

		
		/
		// vector的修改操作
		void push_back(const T& val)
		{
    
    
			if (_finish == _end_of_storage)
			{
    
    
				//空间满了就2倍扩容，
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			++_finish;
		}
		void pop_back()
		{
    
    
			erase(end() - 1);
		}

		iterator insert(iterator pos,const T& x)
		{
    
    
			assert(pos >= _start &&pos <= _finish);
			if (_finish == _end_of_storage)
			{
    
    
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			auto cur = end();
			while (cur>pos)
			{
    
    
				*cur = *(cur - 1);
				--cur;
			}
			*pos = x;
			++_finish;
			return pos;
		}

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

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

		//
		// 容量相关
		void reserve(size_t n)
		{
    
    
			if (n > capacity())
			{
    
    
				size_t oldsize = size();
				T* tmp = new T[n];
				if (size() != 0)
				{
    
    
					for (size_t i = 0; i < oldsize; i++)
					{
    
    
						tmp[i] = _start[i];//这种赋值，即使在vector<vector>这样的深拷贝中也不会出现问题
					}					   //因为它在这种情况下它会调用赋值重载

					//这种写法在深一层的拷贝就会出错，比如vector<vector>二维数组
					/*memcpy(tmp, _start, size()*sizeof(T));*/

					delete[] _start;
				}
				_start = tmp;
				_finish = _start + oldsize;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n,const T& x=T())
		{
    
    
			//容量不够先扩容
			if (n > capacity())
			{
    
    
				reserve(n);
			}
			for (size_t i = size(); i < n; ++i)
			{
    
    
				_start[i] = x;
			}
			_finish = _start + n;
		}

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

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

		bool empty()
		{
    
    
			return _finish == _start;
		}
		///
		// 元素访问
		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()
		{
    
    
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}

	private:
		T* _start; //容量空间的首地址
		T* _finish;  // 指向有效数据的尾
		T* _end_of_storage;  //容量空间的尾地址
	};

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

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

		hdm::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()
	{
    
    
		hdm::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;
	}
}

测试示例一

测试示例二

【C++】vector用法&&简单模拟实现