【STL】vector的模拟实现

目录

vector的介绍和使用

vector的介绍

vector的使用

构造函数

 迭代器

空间增长问题 

vector的增删查改等 

vector的迭代器失效问题 

vector的模拟实现

insert

reserve

push_back

push_front

resize

erase

pop_back

pop_front

代码

---

vector的介绍和使用

vector的介绍

1）vector是可变数组大小的序列容器

2）与数组相比，vector提供了更多的功能

3）vector会分配一些额外的空间以适应可能得增长

vector的使用

构造函数

构造函数	说明
vector()	无参构造
vector(size_type n, const value_type& val = value_type ())	构造并初始化n个val
vector(const vector& x);	拷贝构造
vector(InputIterator first, InputIterator last);	使用迭代器进行初始化构造

代码演示：

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	vector<int> v1; //无参构造
	vector<int> v2(3, 9); //构造并初始化n个val(9 9 9)
	vector<int>::iterator it2 = v2.begin();
	while (it2 != v2.end())
	{
		cout << *it2 << " ";
		++it2;
	}
	cout << endl;

	vector<int> v3 = v2; //拷贝构造(9 9 9)
	vector<int>::iterator it3 = v3.begin();
	while (it3 != v3.end())
	{
		cout << *it3 << " ";
		++it3;
	}
	cout << endl;

	vector<int> v4(v3.begin(), v3.end()); //迭代器区间构造(9 9 9)
	vector<int>::iterator it4 = v4.begin();
	while (it4 != v4.end())
	{
		cout << *it4 << " ";
		++it4;
	}
	cout << endl;

	return 0;
}

 迭代器

函数	说明
begin()	获取第一个元素的迭代器
end()	获取最后一个元素的下一个位置的迭代器
rbegin()	获取最后一个元素的迭代器
rend()	获取第一个元素前一个位置的迭代器

 代码演示：

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	int arr[] = { 1,2,3,4,5 };
	vector<int> v(arr, arr + 5); //5 4 3 2 1 
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	return 0;
}

空间增长问题 

函数	说明
size()	获取数据个数
empty()	判断是否为空
capacity()	获取容量大小
resize()	改变vector的size
reserve()	改变vector的capacity

1）在vs下，capacity是按1.5倍增长，g++下是按2倍增长

2）reserve只负责开辟空间，如果知道开多大的空间，reserve还可以减少扩容的代价

3）resize在开辟空间的同时还会进行初始化，影响size

测试vector在VS2019下的默认扩容机制：

#include <iostream>
#include <vector>
using namespace std;

void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	sz = v.capacity();
	for (int i = 0; i < 100; i++)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed:" << sz << endl;
		}
	}
}

int main()
{
	TestVectorExpand();
	return 0;
}

reserve的使用：

#include <iostream>
#include <vector>
using namespace std;

void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	sz = v.capacity();
	v.reserve(100);
	for (int i = 0; i < 100; i++)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed:" << sz << endl;
		}
	}
}

int main()
{
	TestVectorExpand();
	return 0;
}

如果已知大概需要的空间，可以提前开好，避免频繁扩容导致效率低。

vector的增删查改等 

函数	说明
push_back	尾插
pop_back	尾删
find	查找（这个是算法模块实现的，并非vector的成员函数）
insert	在指定位置前插入
erase	删除指定位置的数据
swap	交换两个vector的数据空间
operator[ ]	像数组一样访问

以上这些函数的使用相对比较简单，这里就不赘述了，直接进入重点vector的迭代器失效问题。

vector的迭代器失效问题 

vector迭代器的底层其实就是个原生指针T*，之所以会导致迭代器失效，是因为vector的底层空间发生了改变，导致T*为野指针。总结起来就是一句话：任何引起vector底层改变的操作都可能会导致vector迭代器失效。比如：insert、erase、resize、reverse等。

以erase为例：

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	vector<int> v{ 1,2,3,4 };
	//找到指定删除的位置
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	//删除指定位置的值
	v.erase(pos);
	cout << *pos << endl;

	return 0;
}

删除pos位置的元素后，pos位置之后的元素会往前挪动，没有导致底层空间的变化，理论上讲迭代器应该是还没失效的。但是，我们可以想象如果删除的pos是最后一个元素，那么pos刚好是end的位置，然而end是没有存放有效数据的，这时pos就失效了。因此，删除任意位置的元素，VS都认为该位置的迭代器失效了。 

迭代器失效的解决方法：在使用前，对迭代器重新赋值即可。

示例：

#include <iostream>
#include <vector>
using namespace std;

int main()
{
	vector<int> v{ 1,2,3,4 };
	//找到指定删除的位置
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	//删除指定位置的值
	pos = v.erase(pos);
	cout << *pos << endl;

	return 0;
}

vector的模拟实现

vector的基本框架：

namespace pcz
{
	template <class T>
	class vector
	{
		typedef T* iterator;//vector的迭代器为原生指针
		typedef const T* const_iterator;//const修饰的是T指向的内容

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

		//……
	protected:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

end_of_storage是啥？

end_of_storage是指向vector容器当前分配的内存空间的末尾的指针或迭代器，是容量的边界。

insert

在指定位置进行插入，挪动数据必不可少。

iterator insert(iterator pos, const T& x)
{
	assert(pos <= _finish);
	assert(pos >= _start);

	if (_finish == _end_of_storage)
	{
		size_t old_len = pos - _start;//扩容导致迭代器失效，需要计算偏移量
		size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(new_capacity);
		pos = _start + old_len;
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		end--;
	}

	*pos = x;
	++_finish;

	return pos;
}

reserve

负责开辟空间。

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();//记录size，看看size的计算方法就明白了
		T* tmp = new T[n];

		if (_start)
		{
			//直接用memcpy会有问题，浅拷贝
			//memcpy(tmp, _start, sizeof(T) * size());
			//_start = tmp;
			for (int i = 0; i < size(); i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}

		_start = tmp;
		_finish = _start + old_size;
		_end_of_storage = _start + n;
	}
}

push_back

复用insert。

iterator push_back(const T& x)
{
	return insert(end(), x);
}

push_front

复用insert。

iterator push_front(const T& x)
{
	return insert(begin(), x);
}

resize

再谈resize的作用：

1）resize用于调整vector的大小，它可以增加或减少vector中元素的数量，以达到指定的新大小。

2）如果vector的新大小大于当前大小，则会在末尾添加足够数量的新元素。、

3）如果vector的新大小小于当前大小，则vector中超出新大小的部分会被丢弃，vector的大小变为指定的新大小。

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

	if(n > capacity())
		reserve(n);

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

erase

删除指定位置的元素，伴随着数据挪动。

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	iterator it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}

	--_finish;
	return pos;
}

pop_back

iterator pop_back()
{
	return erase(_finish - 1);
}

pop_front

iterator pop_front()
{
	return erase(_start);
}

代码

template <class T>
class vector
{
public:
typedef T* iterator;//vector的迭代器为原生指针
typedef const T* const_iterator;//const修饰的是T指向的内容
	
~vector()
{
	if (_start)
	{
		delete[] _start;
		_start = _finish = _end_of_storage = nullptr;
	}
}

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

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

iterator begin()
{
	return _start;
}

const_iterator cbegin() const
{
	return _start;
}

iterator end()
{
	return _finish;
}

const_iterator cend() const
{
	return _finish;
}

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();//记录size，看看size的计算方法就明白了
		T* tmp = new T[n];

		if (_start)
		{
			//直接用memcpy会有问题，浅拷贝
			//memcpy(tmp, _start, sizeof(T) * size());
			//_start = tmp;
			for (int i = 0; i < size(); i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}

		_start = tmp;
		_finish = _start + old_size;
		_end_of_storage = _start + n;
	}
}

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

	if(n > capacity())
		reserve(n);

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

iterator insert(iterator pos, const T& x)
{
	assert(pos <= _finish);
	assert(pos >= _start);

	if (_finish == _end_of_storage)
	{
		size_t old_len = pos - _start;//扩容导致迭代器失效，需要计算偏移量
		size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(new_capacity);
		pos = _start + old_len;
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		end--;
	}

	*pos = x;
	++_finish;

	return pos;
}

		iterator push_back(const T& x)
		{
			return insert(end(), x);
		}

		iterator push_front(const T& x)
		{
			return insert(begin(), x);
		}

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	iterator it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}

	--_finish;
	return pos;
}

iterator pop_back()
{
	return erase(_finish - 1);
}

iterator pop_front()
{
	return erase(_start);
}

bool empty() const
{
	return _start == nullptr;
}

protected:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _end_of_storage = nullptr;
};

---

完~