vector简单模拟实现

_F_y

已于 2025-05-18 19:58:09 修改

阅读量840

点赞数 24

分类专栏： c++ 数据结构文章标签：数据结构 c++

于 2025-05-14 00:18:08 首次发布

本文链接：https://blog.csdn.net/Fy10030629/article/details/147933539

版权

c++ 同时被 2 个专栏收录

14 篇文章

订阅专栏

数据结构

9 篇文章

订阅专栏

成员变量

namespace
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};
}

可以看到，我们的vector的迭代器实际上是一个指针。
主要成员变量有_start、_finish、_endofstorage。

push_back模拟实现

在实现push_back前，我们需要先实现size()、capacity()和operator等函数。

size

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

capacity

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

operator[]

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

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

}

错误示范

void push_back(const T& val)
{
	if (_finish == _endofstorage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2; 
		T* tmp = new T[newcapacity];
		memcpy(tmp, _start, size() * sizeof(T));
		delete[] _start;
		
		_start = tmp;
		_finish = tmp + size();
		_endofstorage = tmp + newcapacity;
	}
	*_finish = val;
	++_finish;
}

注意到我们push_back的参数是引用传参，而非传值传参。
原因也很简单，就是为了节省空间。
这是由于我们的T参数为模板，对应的实例有可能占用空间非常大，如果使用传值传参就会消耗过多的空间。

实现中的if语句是做一个容量判断，扩容幅度为2倍扩容。

这个实现看似没什么问题，实际上如果运行的话会直接返回错误。
细心的读者已经发现了问题所在，就是 _finish = tmp + size(); 这句有bug。回想下我们的size（）实现，是不是return _finish - _start？那也就是说我们的size实际上还没更新，所以会导致_finish还是一个空指针。

因此我们只需先简单记录size_t ole_size =size();

更正

void push_back(const T& val)
{
	if (_finish == _endofstorage)
	{
		size_t ole_size = size();
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2; 
		T* tmp = new T[newcapacity];
		memcpy(tmp, _start, ole_size * sizeof(T));
		delete[] _start;
		
		_start = tmp;
		_finish = tmp + ole_size;
		_endofstorage = tmp + newcapacity;
	}
	*_finish = val;
	++_finish;
}

这个问题看似很小，但实际上他却很容易犯，后面的实现中也会出现类似的问题。

迭代器

begin

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

end

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

打印数组测试

有了begin和end，那么我们就可以实现范围for和迭代器等遍历方式：

void print_vector(const vector<T>& v)
{
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << ' ';
	}
	cout << endl;
	for (auto& e : v)cout << e << ' ';
	cout << endl;
	//vector<T>::const_iterator it = v.begin();错误的
	//typename vector<T>::const_iterator it = v.begin();正确的
	auto it = v.begin();
	while (it != v.end())
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;
	while (it != v.end())
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;
}

注意到取迭代器it的时候，我用了三种取法其中vector<T>::const_iterator it = v.begin();是错误的。
这是由于我们的vector<T>本质上是一个模板，还没有实例化，因此其内部成员未知。vector<T>::这个语句本身还可以代表取vector<T>的静态成员变量，因此就会有歧义二导致编译错误。
更正方法为用关键字typename声明这是一个内部成员变量：typename vector<T>::const_iterator it = v.begin();

测试代码：

void test_1()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	print_vector(v);
}

运行结果：
在这里插入图片描述

empty

bool empty()
{
	return _finish == _start;
}

pop_back

void pop_back()
{
	assert(!empty);
	--_finish;
}

reserver(错误)

void reserve(size_t n)
{
	if (n <= capacity())return;
	size_t ole_size = size();
	T* tmp = new T[n];
	memcpy(tmp, _start, ole_size * sizeof(T));
	delete[] _start;

	_start = tmp;
	_finish = tmp + ole_size;
	_endofstorage = tmp + n;

}

insert模拟实现

错误示范

void insert(iterator pos,const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _endofstorage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}
	iterator it = _finish - 1;
	while (it >= pos)
	{
		*(it + 1) = *it;
		--it;
	}
	*pos = val;
	++_finish;
}

我们这个insert和以往写的insert类似，看着没什么问题，那来些代码测试一下啊如何。

void test_2()
{
	vector<double> v;
	v.push_back(4.4);
	v.insert(v.begin(),1.1);
	v.insert(v.begin(),2.2);
	v.insert(v.begin(),3.3);
	print_vector(v);
	v.insert(v.begin(), 4.4);
	print_vector(v);
}

运行结果：
在这里插入图片描述
注意到，我们前三次insert都没有任何问题。第四次insert却出现了错误。这实际上是由于迭代器失效导致的。

迭代器失效1

既然是第四次insert出现的问题，那么不难注意到就是扩容发生的bug。
第四次insert时发生了扩容，那么我们的_start、_finish、_endofstorage等位置都发生了改变，原本的pos是在_start和_finish之间的，现在指向的是一个野指针。
因此我们如果发生了扩容，则还需要更新迭代器pos的位置。

更正

void insert(iterator pos,const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _endofstorage)
	{
		size_t len = pos - _start;//更正内容1
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
		pos = _start + len;//更正内容2
	}
	iterator it = _finish - 1;
	while (it >= pos)
	{
		*(it + 1) = *it;
		--it;
	}
	*pos = val;
	++_finish;
}

erase

void erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;
	}
	--_finish;
}

resize

void resize(size_t n,const T&val=T())
{
	if (n > size())
	{
		reserve(n);
		while (_finish < _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
	else
	{
		_finish = _start + n;
	}
}

注意到我们的resize里有个参数为const T&val=T()，其中T()就是调用T的默认构造函数的匿名对象。
这时候细心的读者就会有疑问了，咱们的自定义对象确实是有构造函数，但是内置类型没有啊！
实际上咱们的祖师爷也考虑到了这个问题，因此在C++中，内置对象也新增了构造函数。
如下：

void test_3()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.resize(10);
	print_vector(v);
}

运行结果：
在这里插入图片描述
也就是说int()实际上就是0。

拷贝构造

vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (auto& e : v)push_back(e);
}

拷贝构造的实现要注意是深拷贝。
复用已经实现的push_back，就可以使得我们的拷贝构造能够十分简洁的实现。
注意reserve应当在push_back之前，这是为了减少扩容的时间消耗。

赋值重构（现代实现）

void swap(vector<T> v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage,v._endofstorage);
}
vector<T>& operator=(vector<T>v)
{
	swap(v);
	return *this;
}

以往咱们实现赋值重构，由于要考虑深拷贝的问题，因而实现有些许繁琐。
而咱们这里只需两行就实现了重构。
需要注意operator=的参数不要用引用传参，这个传值传参实际上是调用了已经实现的拷贝构造。

区间构造

template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

注意我们这个区间构造的迭代器又用了一个模板，这样可以用别的数据结构的迭代器如string来构造vector。

构造重构

vector(size_t n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)push_back(val);
}

显然这也是我们常用的一个构造重构，但这里隐含一个bug，让我们来测试一下吧。

void test_4()
{
	vector<int>v1(10, 1);
	print_vector(v1);
}

然而我们却得到了一个错误： error C2100: 无法取消引用类型为“InputIterator”的操作数
实际上就是我们没有调用了刚实现的这个拷贝重构，而是调用了区间构造函数，而导致了bug。

解决方法也是出乎意料的简单，我们再多写一个更匹配的重构：

vector(int n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)push_back(val);
}

是不是觉得意料之外又在情理之中呢？

当然，我们常用的构造函数是不是还有这种：

vector<int>v={1,2,3};

为什么可以这样呢？先看下面代码：

void test_5()
{
	auto x = { 1,2,3 };
	cout << typeid(x).name() << endl;
	cout << sizeof(x) << endl;
}

在这里插入图片描述
也就是说{ 1,2,3 }的类型实际上是std::initializer_list。然后隐式类型转换，调用对应的构造函数，从而能够赋值给vector。
因此我们可以再写一个构造函数：

vector(initializer_list<T>il)
{
	reserve(il.size());
	for (auto& e : il)
	{
		push_back(e);
	}
}

测试一下：

void test_5()
{
	auto x = { 1,2,3 };
	cout << typeid(x).name() << endl;
	cout << sizeof(x) << endl;
	vector<int>v{1,2,3};//等价于vector<int>v={1,2,3};
	print_vector(v);
}

运行结果：
在这里插入图片描述

reserve更正

前面实现的reserve不是挺完美的吗，实现了vector的深拷贝，那还有什么问题呢？别急，先看下面的代码：

void test_6()
{
	vector<string>v;
	v.push_back("11");
	v.push_back("22");
	v.push_back("33");
	v.push_back("44");
	v.push_back("55");
	print_vector(v);
}

在这里插入图片描述
what happened？怎么用string类型push_back就报错了？
实际上是扩容时reserve的memcpy在作怪，注意我们的memcpy是逐字节拷贝的，问题是string逐字节拷贝，那不就是浅拷贝吗？
也就是这里隐含了一个浅拷贝问题，更正也非常简单，我们改为赋值就行：

void reserve(size_t n)
{
	if (n <= capacity())return;
	size_t ole_size = size();
	T* tmp = new T[n];
	for (size_t i = 0; i < ole_size; i++)
	{
		tmp[i] = _start[i];
	}
	delete[] _start;

	_start = tmp;
	_finish = tmp + ole_size;
	_endofstorage = tmp + n;

}

迭代器失效2

void test_7()
{
	vector<int>v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	print_vector(v1);

	vector<int>::iterator it = v1.begin() + 3;
	v1.insert(v1.begin(), 40);
	print_vector(v1);
	cout << *it << endl;
	v1.push_back(7);
	v1.push_back(8);
	cout << *it << endl;
}

运行结果：
在这里插入图片描述
可以发现上述代码没有实现我们想要的结果，本质原因就是前面提到过的迭代器失效。
那么如何解决这个问题呢？
实际上是无需解决，迭代器失效以后就跟野指针一样，我们就不去使用它即可。

除此之外，我们使用erase也有可能导致迭代器失效，解决方法是erase返回最后一个删除的元素对应的迭代器。

完整代码

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
namespace myvector
{
	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;
		}
		//注意不加引用
		void swap(vector<T> v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage,v._endofstorage);
		}
		vector()
		{}
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (auto& e : v)push_back(e);
		}
		vector(size_t n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)push_back(val);
		}
		vector(int n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)push_back(val);
		}
		vector(initializer_list<T>il)
		{
			reserve(il.size());
			for (auto& e : il)
			{
				push_back(e);
			}
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		vector<T>& operator=(vector<T>v)
		{
			swap(v);
			return *this;
		}
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}
		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];

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

		}
		void reserve(size_t n)
		{
			if (n <= capacity())return;
			size_t ole_size = size();
			T* tmp = new T[n];
			//memcpy(tmp, _start, ole_size * sizeof(T));
			for (size_t i = 0; i < ole_size; i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;

			_start = tmp;
			_finish = tmp + ole_size;
			_endofstorage = tmp + n;

		}
		void resize(size_t n,const T&val=T())
		{
			if (n > size())
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}
		void push_back(const T& val)//不可传值
		{
			//if (_finish == _endofstorage)
			//{
			//	size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2; 
			//	reserve(newcapacity);
			//}  
			//*_finish = val;
			//++_finish;
			insert(_finish, val);
		}
		bool empty()
		{
			return _finish == _start;
		}
		void pop_back()
		{
			//assert(!empty);
			//--_finish;
			erase(_finish - 1);
		}
		void insert(iterator pos,const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + len;
			}
			iterator it = _finish - 1;
			while (it >= pos)
			{
				*(it + 1) = *it;
				--it;
			}
			*pos = val;
			++_finish;
		}
		void erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
			}
			--_finish;
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};
	template<class T>
	void print_vector(const vector<T>& v)
	{
		for (size_t i = 0; i < v.size(); i++)
		{
			cout << v[i] << ' ';
		}
		cout << endl;
		for (auto& e : v)cout << e << ' ';
		cout << endl;
		//vector<T>::const_iterator it = v.begin();错误的
		//typename vector<T>::const_iterator it = v.begin();正确的
		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << ' ';
			it++;
		}
		cout << endl;
		while (it != v.end())
		{
			cout << *it << ' ';
			it++;
		}
		cout << endl;
	}  
}