模拟实现vector

前言:

  了解学习完vector的底层之后,写一篇vector模拟实现,梳理一下知识点,帮助自己加深对vector的理解,以及以后得复习使用。()常用部分)

关于vector 是用迭代器(本部分底层是T*类型)start、finish、endofstorge计算元素个数和容量。

模拟实现vector_第1张图片

vector 是一种顺序表可以存储多种类型的元素,可以是自定义也可以是内置类型,所以我们加入类模板,同时使用通用类型,定义迭代器:


	template 
	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构造函数,可以使用默认构造,也可以使用迭代器区间初始化,还可以使用类型等构造的方式,代码如下:

vector(size_t n, const T& val =  T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		vector(int n, const T& val = T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		//使用迭代器区间初始化,为了匹配各种类型的迭代器,所以使用类模板定义
		template
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}

		}

		//系统默认
		vector()
		{}

 这里需要注意的是:1、c++11 也支持内置烈性的匿名 譬如 int()  char() 都可以,

2、我们使用resize 默认开辟空间  并将空间初始化成 val 我在将resize的地方通过代码详细说明。

3.使用迭代器区间初始化,也是vector底层允许的,为了匹配各种类型的迭代器,我们使用类模板定义一个兼顾各种类型。

实现代码如下:

void test_vector2()
{
	manvec::vector v1(10, 1);
	manvec::vectorv2(10,"hello word");
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;

	manvec::vector v3(v1.begin(), v1.end());
	string str("nihao shijie");
	manvec::vector v4(v2.begin(), v2.end());
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;
	int a[] = { 16,2,77,29 };
	manvec::vector v5(a, a + 4);
	for (auto e : v5)
	{
		cout << e << " ";
	}
	cout << endl;
}

拷贝构造

//拷贝构造
		vector(const vector& v)
		{
			_start = new T[v.capacity()];//不确定T类型 有可能是自定义 
			//在这里 使用了 赋值 有效避免了 memcpy的浅拷贝
			memcpy(_start, v._start, sizeof(T) * v.size());
			/*for (size_t i = 0; i < v.size(); i++)
			{
				
				
				_start[i] = v._start[i];
			}*/
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
		}
		//交换

 这里需要注意的是,这种拷贝,存在隐患,如果只是简单地内置类型,是完全没问题的。

如下图所示

模拟实现vector_第2张图片

但是如果是自定义类型的呢?

模拟实现vector_第3张图片 

如果想避免这个问题,就要把重载部分模拟实现。

 重载

    交换 

在介绍赋值重载之前 我们先引入交换函数 我们这里使用的是std里自带的交换函数,代码如下:

		void swap(vector& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

我们可以看看std:swap底层实现;帮助我们理解

模拟实现vector_第4张图片

 =赋值重载

		//v1 = v2
		vector& operator=(vector v) //再浏览一下
		{
			swap(v);
			return *this;
		}

  这里形参部分是v2的拷贝构造,在完成交换之后,函数结束,形参的声明周期也就结束了。但是我们已经通过引用接受返回的*this 就是v1。

[]重载

 

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

			return _start[pos];
		}

 reserve函数

 

		void reserve(size_t n)
		{
			//先判断是否需要扩容
			if (n > capacity())
			{
				// 记录原始 vector 的size
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//同样避免浅拷贝 地址失效
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;
				}
										
					_start = tmp;
					_finish = _start + sz;
					_endofstorage = _start + n;									
				
			}
		}

 这个地方如果我们使用的是memcpy   将_start指向的空间释放会发生什么呢? tmp是不是也就变成野指针了?如下图所示。

模拟实现vector_第5张图片 

 所以,对于T是string这样的深拷贝的类,调用的是string赋值重载,实现string对象的深拷贝。

resize函数

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

				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

 插入函数

因为插入的时候,会面临迭代器失效的问题,所以我要把这个函数理一遍,要保证插入的位置在合理的范围内,

iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);
			// 如果扩容的的话 会存在迭代器失效,所以我们要记录pos相对于_start的位置
			size_t len = pos - _start;
			if (_finish == _endofstorage)
			{
				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;
         }

 图解如下:

模拟实现vector_第6张图片

 擦除函数

对删除位置的pos 位置之后 迭代器可能失效,vs进行了强制检查,如果访问就会直接报错,

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

			return pos;
		}

整体模拟实现

#pragma once
#include

namespace manvec
{
	template 
	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(size_t n, const T& val =  T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		vector(int n, const T& val = T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		//使用迭代器区间初始化,为了匹配各种类型的迭代器,所以使用类模板定义
		template
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}

		}

		//系统默认
		vector()
		{}
		//拷贝构造
		vector(const vector& v)
		{
			_start = new T[v.capacity()];//不确定T类型 有可能是自定义 
			//在这里 使用了 赋值 有效避免了 memcpy的浅拷贝
			memcpy(_start, v._start, sizeof(T) * v.size());
			/*for (size_t i = 0; i < v.size(); i++)
			{
				
				
				_start[i] = v._start[i];
			}*/
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
		}
		//交换
		void swap(vector& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}
		//v1 = v2
		T& operator=(vector v) //再浏览一下
		{
			swap(v);
			return *this;
		}

		~vector()
		{
			if (_start)
			{
				delete[]_start;
				_start = _finish = _endofstorage = nullptr;
			}
			
		}
		void reserve(size_t n)
		{
			//先判断是否需要扩容
			if (n > capacity())
			{
				// 记录原始 vector 的size
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//同样避免浅拷贝 地址失效
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;
				}
										
					_start = tmp;
					_finish = _start + sz;
					_endofstorage = _start + n;									
				
			}
		}

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}
		void push_back(const T& x)
		{
			/*if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			++finish;*/
			insert(end(), x);

		}


		T& operator[](size_t pos)
		{
			assert(pos< size());
			return _start[pos];
		}
		const T& operator[](size_t pos) const
		{
			assert(pos < size());
			return _start[pos];
		}
		//获取容量
		size_t capacity()  const
		{
			return _endofstorage - _start;
		}
		//获取填充个数
		size_t size()  const
		{
			return _finish - _start;
		}
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);
			// 如果扩容的的话 会存在迭代器失效,所以我们要记录pos相对于_start的位置
			size_t len = pos - _start;
			if (_finish == _endofstorage)
			{
				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 cur = pos + 1;
			while (cur!= _finish)
			{
				*(cur - 1) = *cur;
				++cur;
			}
			--_finish;

			return pos;
		}
		void print(const vector& v)
		{
			for (auto e : v)
			{
				cout << e << " ";
			}
			cout << endl;
		}

	private:
		//c++11 支持在定义的时候给缺省值
		iterator _start  = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;

	};
}

 

你可能感兴趣的:(算法)