vector模拟实现

一. vector的模拟实现

我们知道：
在STL中，我们上次学了string
但其实准确来说string并不算是STL中的成员。
因为string出现的比STL要早
所以string的设计相比于STL中其他的容器要麻烦的多。

但是今天带来的vector可以说是是完完全全的STL中的容器。

这里可能还有人不知道容器是什么东西。
容器准确来说是用来处理数据的
就比如我们之前学习进程的时候，在管理文件的时候
文件：文件内容+文件属性
本质都是数据，所以我们能看到很多的链表和顺序表的成分在。

而之后我们要学习的算法
作用则是:处理数据
存储数据+处理数据可以说是组成了程序

1.0 与string的区别

为什么这里要讲string和vector的区别？

因为string和vector一样实际上就是一个顺序表

但是还是有很大的区别：

而vector通过模板的功能来实现，能存储多种类型的数据

string相当于将char类型的数据拎出来，为它拓宽了很多接口的同时，为了兼容C语言，保留了很多字符串的特殊点。
所以：
i. string只能存储char类型
ii. string保留了末尾是’\0’的成分

而vector则是全新的对象，不需要兼容C语言。
i. 所以vector能存储各种类型
ii. 同时末尾不用添加’\0’

1.1 实现内容

我们模拟实现vector的目的：
是为了更好的了解vector来帮助我们更好的使用和学习。

所以这里就挑几个比较重要的接口进行实现
做到一个比较基础的vector。

这个就是大致的实现内容。

因为这个和string的实现实在是太像了，所以就选几个比较重点的讲

其他未讲到的会后面会放在整体代码中。

实现方法

这里不同于string的capacity和data实现方法

这里vector用的是三个指针成员变量的实现方法，但是实际上没有相差多少，用string的同样可以实现。

class vector 
{
public:
private:
	iterator _start;
	iterator _finish;
	iterator _eofstorage;
};

这里的：
_start：就是开辟数组的开始指针
_finishi:就是开辟数组最后一个元素的指针
_eofstorage:数组开辟空间的空间的最后位置的地址

这个实现方法区别其实不重要，用string的实现方法依旧可以实现。

二. vector模拟中重点讲解内容（坑）

2.1 erase的使用问题

erase
这个函数的功能是：
删除指定位置的元素。

int main()
{
	std::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	std::vector<int>::iterator begin = v1.begin();
	v1.erase(begin);
	for (auto i : v1)
	{
		std::cout << i;
	}
}

具体就是这样使用。

接下来就来演示erase的一个非常经典的错误用法。

这里用的是STL中的vector，因为官方的使用中，这个问题也是十分常见的。

#include<iostream>
#include<vector>
#include"vector.h"
int main()
{
	std::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	std::vector<int>::iterator begin = v1.begin();
	v1.erase(begin);
	while (begin != v1.end())
	{
		std::cout << *begin;
		begin++;
	}
}

这里能发现程序崩掉了。

这是我们发现
这里我们把begin迭代器指定的内容删除后
然后继续使用了begin迭代器。

但是按照我们的道理来讲
这个begin的指向的方向应该还是老方向。
erase之后，各类元素会向前面补位，begin应该指向新补位的2了。

按道理来说这个begin应该是可以继续使用的。

因为在vs中，这个问题算是迭代器失效
在使用迭代器对象进行insert与erase之后。
vs会默认该迭代器无法继续使用

我们知道STL不同编译器下是不同的，因为官方给了一个STL的最基本的设定，具体的修改和实现方法是取决于公司自己

所以在linux中，可能就不会判断这个迭代器失效的效果。

这里我们来试一下。

还是同样的代码

这里能发现在linux中能进行访问。

但是这样的话为什么vs要禁止用户使用呢？
这里就要讲下允许使用这个的坏处了。

这里我们在linux中用这个测试一道题：
删除数组中的所有偶数

这里结果我们发现少删除了一个2。
这里其实仔细观察一下我们就能发现问题所在。

这里就能发现it删除完，还会进行一次++，会略过连续的偶数。

这里掠过算是比较ok一点的错误了，但是如果想象一下最后一位是偶数，这样的话会直接掠过数组的最后一位，直接向后面遍历，非常容易导致越界访问。

这里其实要解决也是很简单。

只要在其中加一个else就可以了。

但是这样虽然能解决问题，但是大大限制了它的平台可移植性。

所以这个情况也是开发者所在意的。

这里能发现erase有一个iterator 的返回值。
这个iterator是用来返回下一个位置的值的。

所以这里需要去接受一下返回值，才能继续用这个begin变量。

2.2 resize的特殊写法

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

这个是resize的函数实现。
我们知道：
reserve：开辟空间，插入数据时不扩容
resize：开空间+初始化为指定值

但是resize初始化为指定值的时候，指定值有多种不同的类型。

但是有时候如果用户不输入初始化的值该怎么办？

void resize(int n, const T& val = T())

这个第二个参数，const T& val=T();
这个可以说是一个新写法，这个前面是类型

val=T();是缺省值。
那这个T()；
其实就是调用T类型的构造函数的的意思。

那这样我们大致就能明白是什么意思了
如果用户没有给初始化值，那就去调用vector类型T的构造函数

2.3 operator =

这里的operator和string的的一样，要注意深浅拷贝的问题。

所以同样可以用到swap深拷贝函数。

void check_capacity()
		{
			if (_finish == _eofstorage)
			{
				if (_start == NULL)
					reserve(4);
				else
					reserve(capacity() * 2);
			}
		}

2.4 reserve

void reserve(int n)
{
	if (n > capacity())
	{
		int oldsize = capacity();
		T* new_vec = new T[n];
		if (_start != nullptr)
		{
    		for(int i=0;i<oldsize;i++)
    		{
         		new_vec[i]=_start[i];
    		}
			delete _start;
		}
		_start = new_vec;
		_finish = _start + oldsize;
		_eofstorage = _start + n;

	}
}

这个是完成版的reserve

		void reserve(int n)
		{
			if (n > capacity())
			{
				int oldsize = capacity();
				T* new_vec = new T[n];
				if (_start != nullptr)
				{
					memcpy(new_vec, _start, oldsize*sizeof(T));
					delete _start;
				}
				_start = new_vec;
				_finish = _start + oldsize;
				_eofstorage = _start + n;

			}
		}

这个是改版前的reserve函数

这里发现只有一个地方发生了了改变。

if (_start != nullptr)
{
		memcpy(new_vec, _start, oldsize*sizeof(T));
		delete _start;
}

这里乍一看好像没有什么问题。

但是我们仔细想想，如果vector的类型是一个自定义类型，具有地址成员变量。

那memcpy对new_vec与_start进行改变时，就会这个是浅拷贝，无法进行深拷贝，就会发生严重的问题

所以就改成了

for(int i=0;i<oldsize;i++)
  {
    	new_vec[i]=_start[i];
  }

这里使用赋值重载来进行深度拷贝。
就没有这样的问题了

三. 整体代码

#include<string.h>
#include<assert.h>
#include<iostream>
namespace my_vector 
{
	template<typename T>
	class vector 
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_eofstorage(nullptr)
		{}
    vector(const vector<T>& v)
    {
      _eofstorage=_finish=_start=nullptr;
      for(int i=0;i<v.size();i++)
      {
        push_back(v[i]);
      }
    }
    vector(int n,const T& data)
    {
      _start=nullptr;
      _finish=nullptr;
      _eofstorage=nullptr;
      resize(n,data);
    }
    template<class alliterator>
    vector(alliterator first,alliterator end)
    {
      _finish=nullptr;
      _start=nullptr;
      _eofstorage=nullptr;
      while(first!=end)
      {
        push_back(*first);
        first++;
      } 
    }
		~vector()
		{
			delete _start;
			_start = _finish =_eofstorage = nullptr;
		}
		void check_capacity()
		{
			if (_finish == _eofstorage)
			{
				if (_start == NULL)
					reserve(4);
				else
					reserve(capacity() * 2);
			}
		}
    vector<T>&  operator= (const vector<T>& v)
    {
      if(this!=v)
      { 
        std::swap(_start,v._start);
        std::swap(_finish,v.finish);
        std::swap(_eofstorage,v._eofstorage);
      }
      return *this;

    }
		void push_back(const T& data)
		{
			check_capacity();
			insert(size(), data);
		}
		void reserve(int n)
		{
			if (n > capacity())
			{
				int oldsize = capacity();
				T* new_vec = new T[n];
				if (_start != nullptr)
				{
          for(int i=0;i<oldsize;i++)
          {
            new_vec[i]=_start[i];
          }
					delete _start;
				}
				_start = new_vec;
				_finish = _start + oldsize;
				_eofstorage = _start + n;

			}
		}
    
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		size_t size() const
		{
			return _finish - _start;
		}
		void insert(int pos,const T& data)
		{

			assert(pos >= 0 && pos <= size());
			check_capacity();
			T* end = _finish;
			while (end > _start+pos)
			{
				*end = *(end - 1);
				end--;
			}
			_start[pos] = data;
			_finish++;
		}
		void erase(int pos)
		{

			assert(pos >=0 && pos <= size());
			T* end = _start+pos;
			while (end <_finish)
			{
				*end = *(end + 1);
				end++;
			}
			_finish--;
		}
		size_t capacity() const
		{
			return _eofstorage - _start;
		}
		T& operator[](int pos)
		{
			assert(pos < size());
			return _start[pos];
		}
		const T& operator[](int pos) const
		{
			assert(pos < size());
			return _start[pos];
		}
		void pop_back()
		{
			erase(_finish - _start);
		}

		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
		void resize(int n,const T& val=T())
		{
			if (n < size())
			{
				_finish=_start + n;
			}
			else
			{
				reserve(n);
        while(_finish!=_start+n)
        {
          *_finish=val;
          _finish++;
        }
			}
		}



	private:
		iterator _start;
		iterator _finish;
		iterator _eofstorage;

	};
}