【C++】vector的模拟实现【完整版】

【C++】vector的模拟实现【完整版】_第1张图片

目录

一、vector的默认成员函数 

1、vector类的大体结构 

  2、无参构造函数

 3、拷贝构造函数

  4、Swap(operator=需要用)

 5、赋值重载operator=

 6、析构函数 

二、vector的三种遍历方式

 1、size和capacity(大小和容量)

2、 operator[]遍历 

 3、迭代器iterator遍历和范围for

三、vector相关的增容和删除

 1、reserve (指定容量)

2、resize(指定大小) 

 3、push_back(尾插)

 4、pop_back(尾删)

5、insert 

6、erase 

四、完整代码 

vector.h: 

test.cpp:


一、vector的默认成员函数 

1、vector类的大体结构 

vector的成员变量本质是由三个T类型(模板)的指针变量组成的,T是因为用了模板,因为vector具体存储什么类型的需要指定

【C++】vector的模拟实现【完整版】_第2张图片

namespace mz
{
using std::cout;
using std::endl;
using std::string;

	template
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
    private:
	    iterator _start;
	    iterator _finish;
	    iterator _endofstorage;
    }
}

 ①、为什么要在新的命名空间中模拟实现vector?

防止与库里面的vector冲突,因为我们要自己模拟实现一个

②、iterator为什么要用两个版本(const和非const)?

因为迭代器遍历时我们要有只读又能读又能写的状态,所以要有个const版本的


  2、无参构造函数

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

 3、拷贝构造函数

注:此函数最好放最后面看,因为其内部调用了下文才讲的成员函数

①、正常版本

首先我们不自己实现,就是浅拷贝,会出现问题,故需我们自己实现深拷贝,v2(v1),即只要让v2拷贝一份新的数据即可(使v2和v1不是指向同一份数据)

②、现代版本

v2(v1),先让v2 reserve和v1一样的容量大小,防止频繁增容降低效率,再把v1中的每个数据尾插到v2中即可

问题:为什么要const auto&e?

其是一种用于迭代容器元素的引用方式。它表示在循环过程中,我们用一个常量引用来访问容器中的元素。好处是不会对容器进行修改,并不会产生拷贝操作,可提高代码的效率。

在用范围for循环时,如果我们只是想读取容器中的元素而不对其进行修改,可以使用const auto&来声明循环变量。例如,当我们遍历一个vector或者数组时,可以使用const auto&来避免对容器进行修改操作。

例如,当我们遍历一个数组时,如果使用const auto&来声明循环变量,则不能修改数组中的元素。例如,对于以下代码:

int arr = {0, 1, 2, 3, 4};
for (const auto& a : arr) {
a = 1; // 错误,不能修改
cout << a << “\t”;
}

由于使用了const auto&声明循环变量a,所以对a进行修改会导致编译错误。

//v2(v1) 正常版本的实现
/*vector(const vector& v)
{
	_start = new T[v.capacity()];
	_finish = _start;
	_endofstorage = _start + v.capacity();

	for (size_t i = 0; i < v.size(); ++i)
	{
		*_finish = v[i];
		++_finish;
	}
}*/

//v2(v1) 现代版本的实现(更推荐)
vector(const vector& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(v.capacity());

	for (const auto& e : v)
		push_back(e);
}

  4、Swap(operator=需要用)

为什么需要自己提供swap,而不调用里提供的?

因为库里面提供的对于自定义类型代价极大,因为需要深拷贝,但对于内置类型用库函数里面的还好,所以应该自己写一个成员函数swap

【C++】vector的模拟实现【完整版】_第3张图片

void swap(vector& v)
{
	//调用全局的swap,交换指针,其为内置类型,无需深拷贝
	//代价相比于直接调用库里面函数交换比较小
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}

 5、赋值重载operator=

①、正常版本

先要避免自己给自己赋值,先要用tmp拷贝空间,再释放旧空间,再使_start指向一份自己新开辟的新空间,再把需要赋值的数据拷过去即可(为什么要用tmp?因为new动态开辟可能会出错,若先释放旧空间,再直接用_start开辟空间且开辟失败,_str也被销毁了,赔礼夫人又折兵)

②、现代版本(更推荐)

v是v3的临时拷贝,然后v会与v1交换,出了函数v就被销毁了,不用我们自己再销毁了,省力

//v1 = v3 正常版本的实现
/*vector& operator=(const vector& v)
{
	if (this != &v)
	{
		delete[] _start;
		_start = new T[v.capacity()];

		memcpy(_start, v._start, sizeof(T) * v.size());
	}

	return *this;
}*/

//v1 = v3 现代版本
vector& operator=(vector v)
{
	swap(v);//this->swap(v);

	return *this;
}

 

 6、析构函数 

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

 

二、vector的三种遍历方式

 1、size和capacity(大小和容量)

原理:指针相减就是指针间的元素个数

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

①、为什么要加const?

成员函数只要不改变成员变量的,最好都要加上const  


2、 operator[]遍历 

T& operator[](size_t i)
{
	//确保范围的合法性
	assert(i < size());//记得引头文件assert.h

	return _start[i];
}

const T& operator[](size_t i)const
{
	assert(i < size());

	return _start[i];
}

①、为什么要实现两个版本的operator[]?

直接把非const的operator[]加上const不行吗?不可以,因为operator[]访问完后,有两种状态:1、只读 2、可读可写  你直接加上const就只读了,万一我想改数据又不行了,故写两个版本的(const和非const版本) 


 3、迭代器iterator遍历和范围for

迭代器有只读的和可读可写的,故也要写两个版本

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

const_iterator begin()const
{
	return _start;
}

const_iterator end()const
{
	return _finish;
}

只要把迭代器写出来了,迭代器遍历和范围for遍历就都可以用了

测试operator[]迭代器范围for三种遍历

void test1()
{
	vectorv;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	cout << v.size() << endl;
	cout << v.capacity() << endl;
	
	vector::iterator it = v.begin();
	while (it != v.end())
	{
		*it += 1;
		cout << *it << " ";
		++it;
	}
	cout << endl; 

	for (auto& e : v)
	{
		e -= 1;
		cout << e << " ";
	}
	cout << endl;

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

运行结果:

【C++】vector的模拟实现【完整版】_第4张图片


 

三、vector相关的增容和删除

 1、reserve (指定容量)

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t sz = size();//大小要在增容前就算好
		T* tmp = new T[n];
		if (_start)
		{
			//memcpy(tmp, _start, sizeof(T) * sz);//按字节拷贝,浅拷贝
			//作深拷贝,使新旧空间指向自己对应的数据
			for (size_t i = 0; i < sz; ++i)
			{
				tmp[i] = _start[i];//调用的是T的operator=,深拷贝
			}
			delete[]_start;
		}
		_start = tmp;
		_finish = tmp + sz;//不能写为=tmp + size()
		_endofstorage = tmp + n;
	}
}

①、为什么要在增容前就算出大小?

因为增容涉及新和旧空间的问题,比如_finish = tmp + size(),而size的求法是用_finish - _start,但_start已指向新空间,可_finish还是指向旧空间,两块不连续的空间相减就是随机值了,故要在增容之前就把大小算出来,不然增容之后的大小就是随机值了

【C++】vector的模拟实现【完整版】_第5张图片

②、为什么reserve要更新_finish?

reserve不是只改变容量吗,跟大小有什么关系,因为_finish是指针,如果一个对象它上来就reserve保存一定容量,然后直接扩容,这个操作没问题吧,但是插入数据肯定涉及*_finish操作,若不更新_finish,_finish初始为nullptr就非法访问内存了,故reserve中也要更改_finish

③、为什么不能用memcpy拷贝数据?

测试时,当用string作为vector存储的类型时,程序崩溃了,为什么?

本质原因是因为增容中用了memcpy,memcpy导致了问题的出现,因为memcpy是按字节拷贝的,它本质上造成了浅拷贝问题, memcpy使新旧空间都指向了一份数据,旧空间释放后,它指向的对应数据也被释放,而新空间指针还是指向这份旧空间,这就造成非法访问,所以新空间与旧空间不应指向同一份数据,应该不用memcpy,写成深拷贝

【C++】vector的模拟实现【完整版】_第6张图片

解决(reserve的实现不用memcpy): 

把旧空间的每个值赋值给新空间对应的每个值就好了,就能实现深拷贝了,指向不同的数据


2、resize(指定大小) 

void resize(size_t n, const T& val = T())//因为不知道T的类型,故给T类型的缺省值
{
	if (n < size())
	{
		_finish = _start + n;
	}
	else
	{
		if (n > capacity())
		{
			reserve(n);
		}
		//填数据不能用memset

		//填数据
		while (_finish < _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
}

①、填数据为什么不能用memset?

【C++】vector的模拟实现【完整版】_第7张图片

当对于a数组,设置为0时,没问题,但各设置为1和2时,就出现随机值了 ,因为memset只适合把所有值初始化为0,当初始化为1时,是把每个字节初始化为1 

即00000001 00000001 00000001 00000001,这就不是整形的1了(2也同理,就初始化0可以)!memset连内置类型都处理不好,别说自定义类型了,问题会更大,本质上就是因为memxxx类函数都是按字节处理的,

即慎用memxxx,因为其按字节进行操作

②、const T& val = T()中的T()使什么意思?

因为不知道T的类型,故用T的缺省值

C++中内置类型也可以像自定义类型那样调用构造函数,严格来说,内置类型是没有构造函数的,但C++强行赋予了这个构造函数概念,是为了更好地支持模板


    int i = int();//0
    int j = int(1);//1
    double d = double();//0.0000000000
    double e = double(1.1);//1.100000000

 3、push_back(尾插)

void push_back(const T& x) 
{
	//方法一
	if (_finish == _endofstorage)
	{
		size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
		reserve(newcapacity);
	}
	*_finish = x;
	++_finish;

	//方法二、调用insert
	//insert(_finish, x);
}

 4、pop_back(尾删)

void pop_back()
{
	//方法一
	assert(_start < _finish);
	--_finish;
	//方法二、复用erase
	//erase(_finish - 1);
}

5、insert 

void insert(iterator pos, const T& x)
{
	assert(pos <= _finish);//pos == _finish时,相当于尾插

	//满了需要扩容
	if (_finish == _endofstorage)
	{
		size_t n = pos - _start;//算出原pos距离
		size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
		reserve(newcapacity);
		//增完容后要更新pos的位置,因为增容后原来的pos就失效了
		pos = _start + n;//新的_start + n
	}
	//插入之前需要往后挪动1个数据
	iterator end = _finish;
	while (end > pos)
	{
		*end = *(end - 1);
		--end;
	}
	//插入数据
	*pos = x;
	++_finish;
}

为什么需要提前算出n?

有迭代器失效的问题,因为pos是迭代器类型,扩容前指向旧空间的某一位置,而reserve调用后会扩容,而我们是扩容完才插入数据的,此时pos无效,因为旧空间已经释放了,它这个迭代器还指向那里就失效了,故我们要更新pos位置,使它指向新空间,所以要先算n,即原pos的位置


6、erase 

iterator erase(iterator pos)
{
	assert(pos < _finish);

	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;

	return pos;//返回被删除数据的下一位置,那就还是原位置,因为那个数据被删除了
}

 注意:erase是返回被删除数据的下一位置,当要被删除的数据被删除了,erase原地不动的话,就已自动指向了下一位置,因为那个数据被删除了


最后一个问题

如果T是字符串的话代码逻辑会不会忘掉'\0'?

不会,vector末尾没有'\0',string才有,这也是他们的差别

四、完整代码 

总共分为两个文件:vector.h和test.cpp

vector.h: 

#pragma once
#include
#include

namespace mz
{
using std::cout;
using std::endl;
using std::string;

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

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

		//v2(v1) 正常版本的实现
		/*vector(const vector& v)
		{
			_start = new T[v.capacity()];
			_finish = _start;
			_endofstorage = _start + v.capacity();

			for (size_t i = 0; i < v.size(); ++i)
			{
				*_finish = v[i];
				++_finish;
			}
		}*/

		//v2(v1) 现代版本的实现(更推荐)
		vector(const vector& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());

			for (const auto& e : v)
				push_back(e);
		}

		//v1 = v3 正常版本的实现
		/*vector& operator=(const vector& v)
		{
			if (this != &v)
			{
				delete[] _start;
				_start = new T[v.capacity()];

				memcpy(_start, v._start, sizeof(T) * v.size());
			}

			return *this;
		}*/

		//v1 = v3 现代版本
		vector& operator=(vector v)
		{
			swap(v);//this->swap(v);

			return *this;
		}

		void swap(vector& v)
		{
			//调用全局的swap,交换指针,其为内置类型,无需深拷贝
			//代价相比于直接调用库里面函数交换比较小
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}
		

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin()const
		{
			return _start;
		}

		const_iterator end()const
		{
			return _finish;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();//大小要在增容前就算好
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);//按字节拷贝,浅拷贝
					//作深拷贝,使新旧空间指向自己对应的数据
					for (size_t i = 0; i < sz; ++i)
					{
						tmp[i] = _start[i];//调用的是T的operator=,深拷贝
					}
					delete[]_start;
				}
				_start = tmp;
				_finish = tmp + sz;//不能写为=tmp + size()
				_endofstorage = tmp + n;
			}
		}

		void resize(size_t n, const T& val = T())//因为不知道T的类型,故给T类型的缺省值
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
				{
					reserve(n);
				}
				//填数据不能用memset

				//填数据
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

		void push_back(const T& x)
		{
			//方法一
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			++_finish;

			//方法二、调用insert
			//insert(_finish, x);
		}

		void pop_back()
		{
			//方法一
			assert(_start < _finish);
			--_finish;
			//方法二、复用erase
			//erase(_finish - 1);
		}

		void insert(iterator pos, const T& x)
		{
			assert(pos <= _finish);//pos == _finish时,相当于尾插

			//满了需要扩容
			if (_finish == _endofstorage)
			{
				size_t n = pos - _start;//算出原pos距离
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);
				//增完容后要更新pos的位置,因为增容后原来的pos就失效了
				pos = _start + n;//新的_start + n
			}
			//插入之前需要往后挪动1个数据
			iterator end = _finish;
			while (end > pos)
			{
				*end = *(end - 1);
				--end;
			}
			//插入数据
			*pos = x;
			++_finish;
		}

		iterator erase(iterator pos)
		{
			assert(pos < _finish);

			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;

			return pos;//返回被删除数据的下一位置,那就还是原位置,因为那个数据被删除了
		}

		T& operator[](size_t i)
		{
			//确保范围的合法性
			assert(i < size());//记得引头文件assert.h

			return _start[i];
		}

		const T& operator[](size_t i)const
		{
			assert(i < size());

			return _start[i];
		}

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

		size_t capacity()const
		{
			return _endofstorage - _start;
		}
		
		~vector()
		{
			if (_start)
			{
				delete[]_start;
				_start = _finish = _endofstorage = nullptr;
			}
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};


	void print_vector(const vector& v)
	{
		vector::const_iterator it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

	void test1()
	{
		vectorv;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);

		cout << v.size() << endl;
		cout << v.capacity() << endl;
		
		vector::iterator it = v.begin();
		while (it != v.end())
		{
			*it += 1;
			cout << *it << " ";
			++it;
		}
		cout << endl; 

		for (auto& e : v)
		{
			e -= 1;
			cout << e << " ";
		}
		cout << endl;

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

	void test2()
	{
		vectorv;
		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.insert(v.begin(), 0);//头插0
		print_vector(v);

		//删除偶数
		vector::iterator it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}
		print_vector(v);
	}

	void test3()
	{
		vectorv;
		v.reserve(10);
		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.resize(4);
		print_vector(v);
		cout << v.size() << endl;
		cout << v.capacity() << endl;

		v.resize(8);
		print_vector(v);
		cout << v.size() << endl;
		cout << v.capacity() << endl;

		v.resize(12,int());
		print_vector(v);
		cout << v.size() << endl;
		cout << v.capacity() << endl;

		int i = int();//0
		int j = int(1);//1
		double d = double();//0.0000000000
		double e = double(1.1);//1.100000000
	}

	void test4()
	{
		vectorv1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);

		vectorv2(v1);

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

		for (size_t i = 0; i < v2.size(); ++i)
		{
			cout << v2[i] << " ";
		}
		cout << endl;
	
		vectorv3;
		v3.push_back(10);
		v3.push_back(20);
		v3.push_back(30);
		v3.push_back(40);

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

	void test5()
	{
		vectorv;
		v.push_back("111111111111111111111");
		v.push_back("222222222222222222222");
		v.push_back("333333333333333333333");
		v.push_back("444444444444444444444");

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

test.cpp:

#include
#include"vector.h"

int main()
{
	mz::test1();
	//memxxx 按字节处理
	/*int a[10];
	memset(a, 0, sizeof(int) * 10);
	memset(a, 1, sizeof(int) * 10);
	memset(a, 2, sizeof(int) * 10);*/

	return 0;
}

你可能感兴趣的:(【C++】项目,c++,开发语言)