【C++】Vector的简易模拟与探索

💞💞 前言

hello hello~ ，这里是大耳朵土土垚~💖💖 ，欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹

💥个人主页 ：大耳朵土土垚的博客

💥 所属专栏 ：C++入门至进阶

这里将会不定期更新有关C++的内容，希望大家多多点赞关注收藏💖💖

vector模拟实现完整代码

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>
#define _CRT_SECURE_NO_WARNINGS 1
namespace tutu
{
	template<class T>
	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;
		}


		//构造函数
		//拷贝构造,深拷贝
		vector(const vector<T>& v)
		{
			//提前预留空间
			reserve(v.capacity());
			for (auto i : v)
			{
				push_back(i);
			}
		}

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

		}
		//赋值运算符重载
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		//默认构造
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
		}

		//迭代器区间初始化
		//函数模板
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{

			while (first != last)
			{
				push_back(*first);
				++first;
			}

		}

		//n个val构造
		vector(size_t n, const T& val = T())//缺省值不能给0，因为T可能是string，所以给匿名对象
		{
			reserve(n);
			while (n--)
			{
				push_back(val);
			}
		}

		//n个val构造重载，第一个参数为int类型
		vector(int n, const T& val = T())//缺省值不能给0，因为T可能是string，所以给匿名对象
		{
			reserve(n);
			while (n--)
			{
				push_back(val);
			}
		}


		//initializer_list构造
		vector(initializer_list<T> il)
		{
			reserve(il.size());
			for (auto i : il)
			{
				push_back(i);
			}
		}


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



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

		//数据个数
		size_t size()	const
		{
			return _finish - _start;
		}


		//扩容
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t oldsize = _finish - _start;
				T* tmp = new T[n];
				//memcpy(tmp, _start, oldsize * sizeof(T));	//拷贝数据,浅拷贝对于string类等不适用
		
				if (_start)//如果_start为空就不需要拷贝数据
				{
					for (size_t i = 0; i < oldsize; i++)
					{
						tmp[i] = _start[i];//使用赋值来实现深拷贝
					}
				}
				delete[] _start;	//释放旧的空间
				_start = tmp;
				_finish = _start + oldsize;
				_end_of_storage = _start + n;
			}
		}


		//尾插
		void push_back(const T& x)
		{
			/*if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}
			*_finish = x;
			++_finish;*/
			insert(end(), x);
		}

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

		//const对象使用
		const T& operator[](size_t pos) const
		{
			assert(pos < size());
			return _start[pos];
		}


		//尾删
		void pop_back()
		{
			if (_finish != _start)//判断是否为空
			{
				--_finish;
			}
		}


		//插入
		iterator insert(iterator pos, const T& x)
		{
			//防止迭代器因为后面的扩容失效，所以要提前记录pos位置
			size_t pos_size = pos - _start;

			//断言防止越界
			assert(pos_size <= size());
			assert(pos_size >= 0);

			//看是否扩容
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}

			//如果扩容，pos可能会失效，所以要更新pos
			pos = begin() + pos_size;
			//往后挪动数据
			iterator cur = _finish;
			while (cur != pos)
			{
				*cur = *(cur - 1);
				cur--;
			}

			//插入数据
			*pos = x;
			_finish++;

			return pos;
		}


		//删除
		iterator erase(iterator pos)
		{
			size_t pos_size = pos - _start;
			//断言防止越界
			assert(pos >= _start);
			assert(pos < _finish);

			//往前挪动数据
			iterator cur = pos;
			while (cur != _finish - 1)
			{
				*cur = *(cur + 1);
				cur++;
			}
			_finish--;
			//更新pos
			pos = _start + pos_size;
			return pos;
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};

	//测试代码尾插和[]
	void vectortest1()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(4);
		v1.push_back(4);
		v1.push_back(4);


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

	//迭代器测试
	void vectortest2()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);

		int* it = v1.begin();//指定类域 //int* it  = v1.begin();//也可以
		while (it != v1.end())
		{
			cout << *it << " ";
			it++;
		}
	}

	//范围for测试
	void vectortest3()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);

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


	//插入删除数据测试
	void vectortest4()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);

		v1.insert(v1.begin(), 0);

		v1.erase(v1.begin());
		v1.erase(v1.end() - 1);

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



	//n个val测试代码1
	void vectortest5()
	{
		vector<string> s1(10);//使用缺省值
		vector<string> s2(10, "hello");

		for (auto i : s1)
		{
			cout << i << " ";
		}
		cout << endl;
		for (auto i : s2)
		{
			cout << i << " ";
		}
	}
	//n个val测试代码2
	void vectortest6()
	{

		vector<int> v1(4, 2);

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

	//initializer_list构造测试
	void vectortest7()
	{
		vector<int> v1({ 1,2,3,4,5 });
		vector<int> v2 = { 6,7,8,9,10 };
		for (auto i : v1)
		{
			cout << i << " ";
		}
		cout << endl;
		for (auto i : v2)
		{
			cout << i << " ";
		}
	}

	//扩容测试代码
	void vectortest8()
	{
		vector<string> s1;
		s1.push_back("1111111111111");
		s1.push_back("1111111111111");
		s1.push_back("1111111111111");
		s1.push_back("1111111111111");
		s1.push_back("1111111111111");
		s1.push_back("1111111111111");

		for (auto i : s1)
		{
			cout << i << " ";
		}
	}
}

1.vector成员变量

在查看STL库里面vector的实现时，我们发现它是一个类模板并且定义了三个成员变量，分别是iterator start、iterator finish、 iterator end_of_storage用来标记开始，结束，以及总容量，对于vector来说其迭代器iterator就是T*，例如我们之前学习过的顺序表插入的是int类型的数据，所以对存放int类型的vector来说T*就是int*

如下图所示：

假设vector里已经插入了6个数据

#include<iostream>
using namespace std;

namespace tutu
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;	//将T*typedef成iterator
	private:
		iterator _start = nullptr;	//这里给缺省值
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	}
};

因为还没有写构造函数，所以成员变量那里先给缺省值，方便使用
这里将vector的实现都放在一个头文件下，放置多个文件可能会出现链接错误；并设置自己的命名空间tutu

2.尾插push_back()

void push_back(const T& x)
{
	//判断容量是否够用
	if (_finish == _end_of_storage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		//扩容
		reserve(newcapacity);
	}
	//插入数据
	*_finish = x;
	_finish++;
}

插入数据首先都应该判断一下容量是否够用，不够用就需要扩容，这里使用reserve()函数扩容，该函数将在后面实现，此外插入数据后_finish要往后偏移一位

🥳🥳有关容量和数据个数的函数：

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

//数据个数
size_t size()	const
{
	return _finish - _start;
}

3.扩容reserve()

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t oldsize = _finish - _start;	//记录大小
		T* tmp = new T[n];
		memcpy(tmp, _start, oldsize*sizeof(T));	//拷贝数据
		delete[] _start;	//释放旧的空间
		_start = tmp;
		_finish = _start + oldsize;
		_end_of_storage = _start + n;
	}
}

扩容时，因为我们使用的实现vector类的成员变量是指针(或者说迭代器)，所以改变空间后不仅仅_start改变，_finish指向的空间会被销毁，所以这时候如果再使用扩容后的_finish-_start来找到容量size来确定现在_finish指向的空间肯定是不对的，所以我们要提前记录好oldsize
这里拷贝数据使用的是memcpy，一个字节一个字节拷贝

4.operate[]

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

这里返回的是T的引用，也就是vector里面存储的数据

//const对象使用
const T& operator[](size_t pos) const
{
	assert(pos < size());
	return _start[pos];
}

5.析构函数

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

✨测试代码

void vectortest1()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

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

结果如下：

可以看到尾插成功，并且可以使用[]来访问vector v1里面的元素

6.迭代器

//迭代器
iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

在最开始vector成员变量那里我们将T*typedef成iterator，所以对于vector类来说其迭代器实质上就是T* ，是一个指针；但要注意不是所有的迭代器都是指针，例如list的迭代器就不是，我们后续再学习

const迭代器

提供给const对象使用的迭代器，指向的内容不可以被修改

const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}

✨迭代器测试代码

使用迭代器来遍历数据

//迭代器测试
void vectortest2()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	vector<int>::iterator it = v1.begin();//指定类域 //T* it  = v1.begin();//也可以
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
}

结果如下：

因为我们这里的迭代器实质上就是T*，所以vector<int>::iterator it = v1.begin();也可以写成这样：int* it = v1.begin();，但是最好还是使用第一个，因为这个是在所有的地方通用的，屏蔽了底层实现，体现了C++的封装的思想

此外范围for其实质上就是通过迭代器来实现的，所以我们写完了迭代器就可以使用范围for来遍历数据了，代码如下：

//范围for
void vectortest3()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

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

7.插入insert()

//插入
iterator insert(iterator pos,const T& x)
{
	//防止迭代器因为后面的扩容失效，所以要提前记录pos位置
	size_t pos_size = pos - _start;

	//断言防止越界
	assert(pos_size <= size());
	assert(pos_size >= 0);

	//看是否扩容
	if (_finish == _end_of_storage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);
	}

	//如果扩容，pos可能会失效，所以要更新pos
	pos = begin() + pos_size;
	//往后挪动数据
	iterator cur = _finish;
	while (cur != pos)
	{
		*cur = *(cur - 1);
		cur--;
	}

	//插入数据
	*pos = x;
	_finish++;
	return pos;//返回更新后的迭代器
}

这里要注意迭代器因为扩容导致pos失效 的问题(野指针)，所以要提前规避，记录好pos相对位置，然后再即时更新pos迭代器，否则就会出现随机值;
此外，insert的参数pos是对实参的拷贝，形参的改变不会影响实参，所以外部的实参也会失效，但是我们也不能通过引用传参，因为其迭代器返回的是临时拷贝具有常性不能通过引用传参，所以这里我们就可以通过控制insert函数的返回值来解决，我们会返回更新后的迭代器，这样就可以访问该位置了

🥳🥳有了插入函数之后尾插push_back()就可以使用insert()来实现啦，代码如下：

//尾插
void push_back(const T& x)
{
	insert(end(), x);
}

8.删除erase()

//删除
iterator erase(iterator pos)
{
	size_t pos_size = pos - _start;
	//断言防止越界
	assert(pos >= _start);
	assert(pos < _finish);

	//往前挪动数据
	iterator cur = pos;
	while (cur != _finish - 1)
	{
		*cur = *(cur + 1);
		cur++;
	}
	_finish--;
	//更新pos
	pos = _start + pos_size;
	return pos;
}

erase()之后迭代器失效问题

• 有可能删除之后缩容
• 删除最后一个位置会导致越界访问

所以我们认为删除操作之后迭代器也会失效，和插入函数一样通过返回迭代器来更新迭代器使用才行

✨插入删除测试代码

//插入删除数据
void vectortest4()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	v1.insert(v1.begin(), 0);

	v1.erase(v1.begin());
	v1.erase(v1.end()-1);

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

结果如下：

9.构造函数

✨拷贝构造

//拷贝构造,深拷贝
vector(const vector<T>& v)
{
	//提前预留空间
	reserve(v.capacity());
	for (auto i : v)
	{
		push_back(i);
	}
}

拷贝构造测试代码

void vectortest5()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

	vector<int> v2(v1);//用v1拷贝构造v2

	for (auto i : v2)
	{
		cout << i << " ";
	}
}

结果如下：

✨默认构造

//默认构造
vector()
	:_start(nullptr)
	,_finish(nullptr)
	,_end_of_storage(nullptr)
{

}

✨迭代器区间初始化

//迭代器区间初始化
//函数模板
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
 
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
   
}

这里使用了函数模板用来匹配不同类型的迭代器，因为vector可以存储不同类型的数据，相应的迭代器也会有所不同，所以使用函数模板

✨n个val构造

//n个val构造
vector(size_t n, const T& val=T())//缺省值不能给0，因为T可能是string，所以给匿名对象
{
	reserve(n);
	while (n--)
	{
		push_back(val);
	}
}

注意这里给的缺省参数是匿名对象T()，而不是0，因为vector除了能存储int类型外还可以存储其他类型的数据比如string等

n个val构造测试代码

void vectortest5()
{
	vector<string> s1(10);//使用缺省值
	vector<string> s2(10, "hello");

	for (auto i : s1)
	{
		cout << i << " ";
	}
	cout << endl;
	for (auto i : s2)
	{
		cout << i << " ";
	}
}

结果如下：

上述代码s1使用的是缺省值匿名对象string()也就是'\0'，所以什么都没打印，第一行是空的，第二行打印s2的10个"hello"

但是当我们使用下面的代码测试的时候就会发现：

//n个val测试代码
void vectortest6()
{

	vector<int> v1(4, 2);

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

运行后：

出现了非法的间接寻址，并且报错在vector(InputIterator first, InputIterator last)迭代器区间初始化这里
这是因为编译器在匹配函数时vector<int> v1(4, 2);4和2都是int类型恰好和vector(InputIterator first, InputIterator last)这两个函数模板的参数匹配上了，而我们写的n个val初始化vector(size_t n, const T& val=T())第一个参数类型是size_t,第二个才可以隐式类型转换为int类型，没有迭代器区间初始化的函数匹配
所以编译器会选择使用迭代器区间来初始化v2，但是迭代器区间初始化函数里面写了解引用，对于int类型来说是行不通的，所以出现了错误

这时我们只需要在初始化v2时将第一个参数给为unsigned int就行：vector<int> v1(4u, 2);

或者可以在重载一个n个val构造的函数，第一个参数给为int类型：

//n个val构造重载，第一个参数为int类型
vector(int n, const T& val = T())//缺省值不能给0，因为T可能是string，所以给匿名对象
{
	reserve(n);
	while (n--)
	{
		push_back(val);
	}
}

这样上述代码的结果就如下：

✨initializer_list构造

initializer_list是C++新增的一个类型，方便初始化，支持将花括号括起来的值给initializer_list，initializer_list对象里面有两个指针，指向花括号里面值开始和结尾的下一个，并支持迭代器，所以可以使用范围for来遍历，当然这个要编译器支持将花括号传给它

//initializer_list构造
vector(initializer_list<T> il)
{
	reserve(il.size());//size表示数据个数
	for (auto i : il)
	{
		push_back(i);
	}
}

initializer_list构造测试代码

C++11引入

//initializer_list构造测试
void vectortest7()
{
	隐式类型转换
	vector<int> v1({ 1,2,3,4,5 });	
	vector<int> v2={ 6,7,8,9,10 };	
	for (auto i : v1)
	{
		cout << i << " ";
	}
	cout << endl;
	for (auto i : v2)
	{
		cout << i << " ";
	}
}

结果如下：

10.赋值运算符重载

//赋值运算符重载
vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}

这里使用传值传参，是实参的拷贝，所以我们将它与被赋值的对象交换后返回即可完成赋值，并且交换后形参生命周期结束就会自动调用析构函数释放原来的空间

🥳🥳swap函数

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

}

11.reserve()扩容存在的问题

✨测试代码

//扩容测试代码
void vectortest8()
{
	vector<string> s1;
	s1.push_back("1111111111111");
	s1.push_back("1111111111111");
	s1.push_back("1111111111111");
	s1.push_back("1111111111111");
	s1.push_back("1111111111111");
	s1.push_back("1111111111111");

	for (auto i : s1)
	{
		cout << i << " ";
	}
}

结果如下：

可以看到程序异常退出，这是因为我们在使用reserve()扩容时，使用的是memcpy(tmp, _start, oldsize*sizeof(T));来拷贝数据，如果数据是int类型不会有什么问题，但如果是string类，memcpy进行的是一个字节一个字节拷贝，是浅拷贝，释放原来的空间后，就会存在野指针，访问已经释放的空间出现错误，所以reserve实现应该如下：

//扩容
void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t oldsize = _finish - _start;
		T* tmp = new T[n];
		//memcpy(tmp, _start, oldsize * sizeof(T));	//拷贝数据,浅拷贝对于string类等不适用

		if (_start)//如果_start为空就不需要拷贝数据
		{
			for (size_t i = 0; i < oldsize; i++)
			{
				tmp[i] = _start[i];//使用赋值来实现深拷贝
			}
		}
		delete[] _start;	//释放旧的空间
		_start = tmp;
		_finish = _start + oldsize;
		_end_of_storage = _start + n;
	}
}

上述代码拷贝使用赋值，如果是类类型会调用赋值运算符重载实现你想要的拷贝，这样上述测试代码就可以测试成功啦🥳🥳

结果如下：

结语

以上就是C++STL标准库中vector的模拟实现了，在实现过程中，我们使用了动态内存分配来实现vector的大小动态调整，并通过指针来管理内存。我们还实现了一些常用的成员函数，如push_back、pop_back、at等，以及一些运算符重载，如[]、=等。

通过实现这个简单的vector类，我们不仅加深了对vector容器的理解，还学习了一些C++的底层原理和技巧。同时我们也遇见并解决了一些问题比如迭代器失效，深浅拷贝...以上就是今天所有的内容啦~ 完结撒花 ~🥳🎉🎉