vector的模拟实现

最新推荐文章于 2024-05-23 22:02:44 发布

半只牛马

最新推荐文章于 2024-05-23 22:02:44 发布

阅读量599

点赞数 2

文章标签：算法 c++ stl

本文链接：https://blog.csdn.net/weixin_68624665/article/details/133611264

版权

前言

之前给大家介绍了我们的vector的使用，相信大家都收获良多，那么为了更好的掌握我们的vector，我们还是需要对其底层进行部分的进行相关的刨析，理解，那么话不多说，我们直接开始我们今天的学习。

1.vector的基本框架和成员变量

首先在我们的使用中，我们的vector的底层可以是任何的类型，因此我们的vector实际上是一个类模板，也就是：

template<class T>

	class vector
	{

    }

那么对于该成员变量呢？按照我们的string的实现经验，可能大家是按我们string的模型进行猜想的，但是实际上，该底层是由三个指针进行维护的，这也就是我们的三个成员变量，具体如下：

template<class T>

	class vector
	{

     private:
          T* _start = nullptr; // 指向数据块的开始
          T* _finish=nullptr; // 指向有效数据的尾
          T* _endOfStorage=nullptr; // 指向存储容量的尾
    }

具体模型如下：

但是对于此处的指针是针对数组，实际上就是我们vector的迭代器，因此我们此处还要对该指针进简单的转换一下：

template<class T>
 class vector
	{
		typedef  T* iterator;
		typedef const T*  const_iterator;

    private:
		iterator _start = nullptr; // 指向数据块的开始

		iterator _finish=nullptr; // 指向有效数据的尾

		iterator _endOfStorage=nullptr; // 指向存储容量的尾
    //nullptr为其缺省参数会自动走我们的初始化列表

	};

2.迭代器实现

对于迭代器，这里依然是实现我们两个版本，一个版本是我们的普通版本，一个是我们的const版本，对于这两个版本的区别我就不多说了，不懂得大家可以去我string的模拟实现中进行查看。

这里仅仅需要注意的是我们的begin()函数是返回我们的数组首元素，我们的end()返回的是我们有效数据的下一个地址，如下：

实现如下：


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

3.容量操作部分

3.1 size和capacity接口

我们这里的size接口返回的是我们的有效数据个数，我们的capcacity返回的是我们数据容量的大小，那么我们通过三个指针如何去获取该值呢？

获取原理：指针之间的相减

之前给大家在C语言介绍过我们指针相减返回的是指针之间数据元素个数的值，实际上该底层在地址相减后会除以size(T)，从而得到我们指针之间的元素个数。因此该实现代码如下：

       size_t size() const//注意加const，因为此处我们const对象也要调用
		{
			return _finish - _start;
		}

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

3.2 reserve

reserve在我们这里起到的是空间开辟的效果，只有当我们所需要开辟的空间大小大于我们现有的空间大小，我们就需要进行重新开辟更大的空间，然后将我们的值重新拷贝到新空间。

void reserve(size_t n)
		{
			size_t oldsize = size();
			if (n > capacity())//只有n大于当前容量才需要进行扩容
			{
				T* tmp = new T[n];
				if (_start)
				{
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					//这里不能使用memcpy，原因是由于memcpy导致了内部对象的浅拷贝,这里使用=就相当于内置类型使用=，自定义类型调用其赋值函数重载
					delete[]_start;
				}
				_start = tmp;
				_finish = _start + oldsize;
				_endOfStorage = _start + n;
			}
		}

以上我们给大家提出了一个问题，就是我们拷贝将旧空间拷贝到我们新空间时，并不能使用我们的memcpy，这是什么原因导致的呢？

首先我们知道我们的vector可以存储任何类型的，然后我们的memcpy进行的是我们逐字节的拷贝，如果我们vector存储的是我们的内置类型，那么memcpy是不会导致任何问题的，但是如果存储的是string那样的自定义类型，我们看看会导致什么情况。

很明显这里会造成浅拷贝，导致程序崩溃，那么我们这里为什么使用=呢？原因是使用=,对于自定义类型会调用该赋值运算符，而内置类型会自动调用等号，从而就解决了此类问题。

3.3 resize

resize这里的作用是调整我们有效数据个数，和我们的string一样，我们这里也有三种情况需要进行讨论。

n<_size 直接删除数据：直接将我们的_finish置为_start+n即可。

_size<n<capacity 只需要将剩余的空间初始化：这里只需要从原先的_size开始依次往后填写直到达到我们有效数据个数即可，同时也要兼顾到我们_finish指针的指向

n>capacity 扩容+初始化：我们这里的操作只是比我们的情况二多了一个扩容操作，这里小编将情况三和情况二的判断放在了我们的reserve函数中，大家可以体会一下。

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

这里我们发现了，我们resize时，我们第二个参数我们提供了一个匿名对象，但是此处的匿名对象只是提供给具有默认构造的类型，那么我们对于自定义类型我们还能够提供默认构造，那么对于内置类型呢？

实际上，内置类型也有默认构造函数而这就是由于我们模板的出现对其做出的升级。

4.修改接口操作

4.1 push_back

对于这个接口实际上我们没什么好讲解的，大家值需要注意执行我们扩容操作即可。、

void push_back(const T& x)
{
	if (_finish == _endOfStorage)
	{
	  size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
	  reserve(newcapacity);
	}
	*_finish = x;
	_finish++;
}

4.2 swap

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

4.3 insert

之前给大家讲解过我们的insert的失效问题（由于扩容产生），对于我们insert的失效，我们该函数会返回一个新空间的对应迭代器的位置，来解决此类问题，那么我们是如何实现的呢？

这里我们采用的思路是，记录pos距离我们_start的相对位置，然后对应到我们的新空间的位置，最后将其返回。

最后就是实现我们insert的插入思路了，我们需要在pos位置之前进行插入，因此我们需要将pos以及该后面的位置全部往后移一位，最后在pos位置直接赋值即可

iterator insert(iterator pos, const T& x)//这里为了防止我们的外部迭代器失效，我们返回对应新空间的pos位置让别人进行访问
			{
				assert(pos >= _start && pos <= _finish);//检测pos的合法性
				//内部迭代器在扩容后原来的空间会销毁就会导致迭代器失效
				//以下我们使用len记录pos在原来空间的位置，然后如果进行了扩容操作就使用_start+len，让其回到原来的那个位置。
				if (_finish == _endOfStorage)
				{
					size_t len = pos - _start;
					size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
					reserve(newcapacity);
					pos = _start + len;//找到相对位置
				}
				iterator end = _finish - 1;
				while (end >= pos)
				{
					*(end + 1) = *(end);
					end--;
				}
				*pos = x;
				++_finish;
				return pos;
				
			}

4.4 erase

iterator erase(iterator pos)
{
	assert(pos >= _start && pos < _finish);
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it-1) = *(it);//将pos位置后的值往前移达到覆盖的效果
		it++;
	}
	finish--;
	return pos;
}

为了避免我们erase外部删除后出现迭代器失效，我们这里的做法是返回删除值位置的迭代器，以达到对外部迭代器进行更新的效果。

4.5 pop_back

这里是对我们erase的进行的复用

void pop_back()
{
	erase(--end());
}

5.构造函数

5.1 默认构造

对于我们这里的实现是：

vector()
{};

这里看到的代码是什么都没有的，这里实际上是要给三个指针进行赋空的操作，但是我们由于在声明的时候给其提供了缺省值，该缺省值会自动地走我们的初始化列表，因此我们也就没有必要再写一遍了。

5.2 初始化n个val

对于这个构造函数我们的实现逻辑是比较简单的，这里本质上实际是和我们resize的逻辑是类似的，因此这里我们直接复用我们的resize函数即可。

vector(int n, const T& value = T())
{
	resize(n, value);
};

5.3 迭代器构造

对于迭代器的构造方式，我们之前给大家介绍过该支持任何类型的迭代器，因此该是一个模板函数，该定义和实现方式如下：

template<class InputIterator>

		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);//直接复用即可
				first++;
			}

		};

6.拷贝构造

对于我的vector的拷贝构造该也是很明显是需要进行深拷贝的一个函数，该不但外部需要进行深拷贝，该数组中的每个对象也要进行我们的深拷贝（直接调用=即可）。

vector(const vector<T>& v)
{
	_start = new T[v.capacity()];
	for (size_t i = 0; i < v.size(); i++)
    {
		_start[i] = v._start[i];
	}
	_finish = _start + v.size();
	_endOfStorage = _start + v.capacity();
}

7.赋值运算符

对于赋值运算符，我们也是要进行重载让其变为深拷贝的。代码如下：

vector<T>& operator= (vector<T> v)//这里调用拷贝构造
{
	swap(v);//这里交换拷贝构造后的新空间，旧空间交给对v,该出作用域后会调用析构函数销毁旧空间
	return *this;
}

注意：这里是我们的现代写法，具体的看小编在string类模拟实现的阐述

8.析构函数

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

9.[]运算符重载

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

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

这里的代码逻辑都没什么好讲解的，这里注意的是需要提供两个版本，一个提供给普通对象的读写操作，一个提供const对象的读操作。

总代码

#include<assert.h>
#include<algorithm>
#include"Reverse_iterator.h"
using namespace std;
namespace xhj
{
	template<class T>

	class vector

	{
		typedef  T* iterator;
		typedef const T*  const_iterator;
	public:

		// Vector的迭代器是一个原生指针

		iterator begin() {
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin()const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
			// construct and destroy

		vector()
		{};

		vector(int n, const T& value = T())
		{
			resize(n, value);
		};

		template<class InputIterator>

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

		};

		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}
			_finish = _start + v.size();
			_endOfStorage = _start + v.capacity();
		}

		vector<T>& operator= (vector<T> v)//这里调用拷贝构造
		{
			swap(v);//这里交换拷贝构造后的新空间，旧空间交给对v,该出作用域后会调用析构函数销毁旧空间
			return *this;
		}

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

			// capacity

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

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

		void reserve(size_t n)
		{
			size_t oldsize = size();
			if (n > capacity())
			{
				T* tmp = new T[n];
				if (_start)
				{
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					//这里不能使用memcpy，原因是由于memcpy导致了内部对象的浅拷贝,这里使用=就相当于内置类型使用=，自定义类型调用其赋值函数重载
					delete[]_start;
				}
				_start = tmp;
				_finish = _start + oldsize;
				_endOfStorage = _start + n;
			}
		}

		void resize(size_t n, const T& value = T())//模板出现后让我们的内置类型也有默认构造函数，这里使用的是匿名对象
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*(_finish) = value;
					++_finish;
				}
			}
		}



			///access///

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

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



			///modify/

			void push_back(const T& x)
			{
				if (_finish == _endOfStorage)
				{
					size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
					reserve(newcapacity);
				}
				*_finish = x;
				_finish++;
			}

			void pop_back()
			{
				erase(--end());
			}

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

			iterator insert(iterator pos, const T& x)//这里为了防止我们的外部迭代器失效，我们返回对应新空间的pos位置让别人进行访问
			{
				assert(pos >= _start && pos <= _finish);
				//内部迭代器在扩容后原来的空间会销毁就会导致迭代器失效
				//以下我们使用len记录pos在原来空间的位置，然后如果进行了扩容操作就使用_start+len，让其回到原来的那个位置。
				if (_finish == _endOfStorage)
				{
					size_t len = pos - _start;
					size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
					reserve(newcapacity);
					pos = _start + len;
				}
				iterator end = _finish - 1;
				while (end >= pos)
				{
					*(end + 1) = *(end);
					end--;
				}
				*pos = x;
				++_finish;
				return pos;
				
			}

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

	private:
		iterator _start = nullptr; // 指向数据块的开始

		iterator _finish=nullptr; // 指向有效数据的尾

		iterator _endOfStorage=nullptr; // 指向存储容量的尾

	};

}