vector的模拟实现

目录

• 引言
• 构造函数
• • 默认构造函数
  • 用n个val值来构造
  • 利用迭代器区间构造
  • 拷贝构造
• 赋值重载
• 容量
• • reserve()预留空间
  • resize()开辟空间并且初始化
  • capacity()
  • size()
  • Iterator
• operator[]
• 修改
• • push_back()
  • pop_back()
  • insert()
  • erase()
• 关于迭代器失效问题

引言

学习c++的过程中，stl库是必不可少的，今天我们就要讲讲vector的模拟实现。模拟实现是为了让我们更了解底层的stl库，并不是为了让我们自己创造，因为stl已经做得足够好了，我们只需要更好的使用库就可以了。

构造函数

构造函数作为最重要的部分，我们还是放在第一位去说，在库中，vector给了我们四个构造函数。图下是库中为我准备的四个构造函数。

默认构造函数

在c98中，他是这样描述的：

1. empty containerconstructor(defaultconstructor)：Constructs an empty container, with no elements.构造一个没有元素的vector。
   所以我们只需要把他们置空就可以了，如果需要插入数据，我们在另外开空间。

这里我们为什么不用数组呢?是因为在stl库，他们就用了指针来实现的，我们为了做到和库中一致。

class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	vector()
	{}
private:
	iterator _start = nullptr;//缺省值
	iterator _finish = nullptr;
	iterator _endofstorge = nullptr;
}

用n个val值来构造

这里我们没有真正像库中一样实现，这里存在内存池的知识，所以我们只实现用n个val值来构造。

vector(int n, const T& val = T())
{
	//用n个数初始化成val
	//重载原因：防止模版更匹配情况，导致编译器调用错误
	reserve(n);
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

会发现我给的缺省值是T()匿名对象

问题1：那么为什么不能给0？答：因为虽然顺序表我们常用int练习，但是不代表我们就只能存放int类型的数值，所以0是万万不可以的。正确方式就是匿名对象

问题2：那么内置类型也有匿名对象吗？答：有，随着编译器的更新，也会有以下形式。

	int j = int(10);
	std::cout <<"j=" << j << std::endl;

利用迭代器区间构造

从库中看出，我们的模板类可以嵌套模板函数。

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

拷贝构造

以下代码是现代写法，当然了我们可以用传统写法，开一段空间，然后把内容赋值进去，但是以下方式更好，我们提前开辟和v一样大的空间，然后尾插就可以了。

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

赋值重载

赋值重载，这里我们可以复用拷贝构造 。这里我们利用传值传参，去调用拷贝构造，然后在进行swap交换。那么它的流程是什么呢？图下就是全部过程，传入swap后，与临时变量中的数值进行交换，就形成了赋值重载。

void swap(vector<T>& v)
{
	std::swap(_start, v._start);//调用库中的构造函数
	std::swap(_finish, v._finish);
	std::swap(_endofstorge, v._endofstorge);
}
//d1=d2
vector<T>& operator= (vector<T> v)
{
	swap(v);
	return *this;
}

容量

reserve()预留空间

reserve()也是老朋友了，为我们提前开辟n个空间，提前开好，节省时间 ，并且也是我们扩容的好帮手。

void reserve(size_t n)
{
	if (n > capacity())
	{
		//扩容
		size_t old_size = size();
		T* tmp = new T[n];
		memcpy(tmp, _start, size() * sizeof(T));
		_start = tmp;
		_finish = tmp + old_size;
		_endofstorge = tmp + n;
	}
}

resize()开辟空间并且初始化

resize比较特殊，有三种情况 ：

①.如果n比capacity大，那么我就开辟空间。

②.如果比size小，那么就裁剪数据，保留到n位。

③.如果在大于size，小于capacity区间中，就直接插入数据。

问题1：为什么while循环中，不是_finish<_start+n呢？

答：我们可以看库中resize()的特性。如下图，并不会清空原始的数据，而是一种追加开辟。

问题2：为什么if(n>size())而不是n>capacity()呢？

答：原因是我们在reserve中已经对n有capacity的比较了，如果不满足，他也不会开空间。

void resize(size_t n, const T& value = T())
{
	if (n > size())
	{
		//扩容
		reserve(n);//reverse内置的判断会看是否有多余空间
		while (_finish < _start + n)//为什么这里是_start+n呢？
		{
			*_finish = value;
			_finish++;
		}
	}
	else
	{
		//缩短数据
		_finish = _start + n;
	}
}

capacity()

查看容量就很简单啦，用地址相减就可以啦。

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

size()

返回当前个数。

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

Iterator

关于迭代器，也很简单，返回指向头尾就可以啦。

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

operator[]

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

修改

push_back()

push_back()我们见过很多次了，这次就不太多介绍了，尾插一个数。

void push_back(const T& val)
{
	if (_finish == _endofstorge)
	{
		//扩容
		reserve(capacity() == 0 ? 4 : 2*capacity());
	}
	*_finish = val;
	_finish++;
}

pop_back()

尾删。

void pop_back()
{
	assert(size() != 0);
	_finish--;
}

insert()

库中没有为我们准备头插尾插的原因是因为效率很低，不实用，如果你很需要头插的话，可以利用insert在开头位置插入。

问题1：为什么要提前保存len的长度？

答：因为我们使用指针，在扩容的时候，我们会开新的空间，就会导致原指针失效，就造成了野指针访问，所以我们需要记录pos指向的位置，更改之后再更新pos指针。

iterator insert(iterator pos, const T& x)
{
	assert(pos > _start);
	assert(pos < _finish);
	if (_finish == _endofstorge)
	{
		//扩容
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : 2 * capacity());
		pos = _start + len;//更新pos，因为_start已经改变位置了
	}
	iterator it = _finish - 1;
	while (it>=pos)
	{
		*(it +1)= *it;
		--it;
	}
	*pos = x;
	_finish++;
	return _start;
}

erase()

在某个位置删除一个位置。

问题：我们为什么会返回pos+1呢？

答：在库中，An iterator pointing to the new location of the element that followed the last element erased by the function call.一个迭代器，指向被函数调用删除的最后一个元素后面的元素的新位置。

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

关于迭代器失效问题

上述我们其实在insert()遇到过这个问题,比如扩容导致的位置变化，所以我们需要更新，那么库中有这个问题吗？答案是有的，解决方式是如果你一定要使用，①即使修改新的地址，或者②.不要用迭代器。