STL-vector的使用及简单的模拟实现

STL


STL-vector

  • STL
  • 前言
  • 一、vetcor是什么?
  • 二、vector的使用
    • 1.定义
    • 2.vector iterator的使用
    • 3.vector 空间增长
    • 4.vector 增删查改
    • 5.迭代器失效的问题
  • 三、vector的简单模拟

前言

在C语言中,数组的大小是只能设为常量的,使用起来很不方便,于是在C++中就诞生了vector


一、vetcor是什么?

1.vector是个可变大小的动态数组,是一个容器;
2.vector采用连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问;
3.vector使用动态分配数组来存储元素,当数组为了增加存储空间时,会重新分配新大小的数组空间,然后将之前的全部元素移到这个数组,时间代价很大;
4.vector空间分配策略:vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的,但在中间插入元素时需要移动元素,时间效率很低;
5.vector访问元素的时候相比其他容器更高效。

二、vector的使用

在使用库中的vector时需要引头文件

1.定义

代码如下(示例):

构造函数 接口说明
vector() 无参构造
vector(size_type n,const value_type&val = value_type()) 构造并初始化n个val
vector(const vector& x) 拷贝构造
vector(inputiterator first, Inputiterator last) 使用迭代器进行初始化构造
	vector<int> iv;//创建一个长度为0的空数组
	vector<int> iv1(10, 2);//创建长度为10且每个元素都为2的数组
	vector<int> iv11(iv1);//通过iv1拷贝创建iv11
	int arr[] = {
      1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int num = sizeof(arr) / sizeof(arr[0]);
	vector<int>iv2(arr, arr + num);//以arr数组为区间创建数组

STL-vector的使用及简单的模拟实现_第1张图片

2.vector iterator的使用

iterator的使用 接口说明
begin+end 获取第一个数据位置的iterator/const_iterator,获取最后一个数据的下一个位置的iterator/const_iterator
rbegin+rend 获取最后一个数据位置的reverse_iterator,获取第一个数据前一个位置的reverse_iterator

STL-vector的使用及简单的模拟实现_第2张图片

代码如下(示例):

	int arr[] = {
      1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int num = sizeof(arr) / sizeof(arr[0]);
	vector<int>iv2(arr, arr + num);//以arr数组为区间创建数组
	vector<int>::iterator it = iv2.begin();
	cout << "iv2:  ";
	while (it != iv2.end())
	{
     
		cout << *it << " ";
		++it;
	}
	cout << endl;
	vector<int>::reverse_iterator rit = iv2.rbegin();
	cout << "iv2Reverse:  ";
	while (rit != iv2.rend())
	{
     
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

STL-vector的使用及简单的模拟实现_第3张图片

3.vector 空间增长

容量空间 接口说明
size 获取数据个数
capactiy 获取容量大小
empty 判断是否为空
resize 改变vector的size
resserve 改变vector放入的capacity
	int n = iv2.size();
	cout << "size = " << n << endl;
	cout << "capacity = " << iv2.capacity() << endl;
	iv2.resize(11);//重新设置大小
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     
		cout << e << " ";
	}
	cout << endl;
	cout << "capacity = " << iv2.capacity() << endl;
	iv2.reserve(10);
	cout << "capacity = " << iv2.capacity() << endl;

	iv2.resize(16, 6);
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     
		cout << e << " ";
	}
	cout << endl;

STL-vector的使用及简单的模拟实现_第4张图片

capacity在VS下是1.5倍增长的,g++是按2倍增长的,VS是PJ版本的STL,g++是SGI版本的STL。
reserve只负责开辟空间,如果确定知道需要用多少空间,reserve可以缓解vector增容的代价缺陷问题。
resize在开辟空间时还会进行初始化。

4.vector 增删查改

vector 增删查改 接口说明
push_back 尾部插入
pop_back 尾部删除
find 查找。(不是成员函数)
insert 在position之前插入val
erase 删除position位置的数据
swap 交换两个vector的数据空间
operator[] 像数组一样访问
iv2.push_back(666);//尾部插入666
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     cout << e << " ";}
	cout << endl;
	iv2.insert(iv2.begin(), 666);//在开头插入666
	iv2.pop_back();//尾部删除
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     cout << e << " ";}
	cout << endl;
	auto pos = find(iv2.begin(), iv2.end(), 0);
	iv2.insert(pos, 99);//在值为0的位置前插入99
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     cout << e << " ";}
	cout << endl;
	auto pos1 = find(iv2.begin(), iv2.end(), 5);
	iv2.erase(pos1);//删除值为5位置的元素
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     cout << e << " ";}
	cout << endl;
	vector<int> iv3(5, 2);//创建长度为5的数组数据都为2
	iv2.swap(iv3);//交换iv2和iv3
	cout << "iv2:  ";
	for (auto &e : iv2)
	{
     cout << e << " ";}
	cout << endl;

STL-vector的使用及简单的模拟实现_第5张图片

5.迭代器失效的问题

STL-vector的使用及简单的模拟实现_第6张图片
迭代器的主要作用就是让算法能够不用关心底层数据结构,其底层实际就是一个指针,或者是对指针进行了封装,vector的迭代器就是原生态指针*T,因此迭代器失效,实际就是迭代器底层对应指针所指向的空间被销毁了,而使用一块已经被释放的空间,就会造成程序崩溃。

vector<int>::iterator it2 = (iv2.begin());
	cout << "*it2= " << *it2 << endl;
	cout << "size = " << iv2.size() << endl;
	cout << "capacity = " << iv2.capacity() << endl;
	iv2.push_back(5);//插入导致需要重新开辟空间
	cout << "*it2= " << *it2 << endl;//再次访问it2时,it2已经失效

STL-vector的使用及简单的模拟实现_第7张图片

1.会引起vector底层空间改变的操作,都有可能是迭代器失效,比如,resize,reserve,insert,assign,push_back等这些可能会使底层原有空间被释放掉(因为要扩容),而在打印时,使用的依然还是被释放的原有空间,从而使程序崩溃。
解决方法:在以上操作完成后,给迭代器重新赋值。

	it2 = find(iv2.begin(), iv2.end(), 5);

2.指定位置元素的删除操作erase
根据编译器不同而不同,VS是删除哪个位置,就会导致该位置的迭代器失效,erase删除pos位置元素后,pos位置之后的元素会往前搬移,没有导致底层空间的改变,理论上来说迭代器应该不会失效),但是如果刚好是最后一个元素,删完之后刚好是end的位置,而end位置是没有元素的,pos的it就会失效。因此在删除vector任意位置的元素时,vs就认为该位置迭代器失效了。
STL-vector的使用及简单的模拟实现_第8张图片

int arr1[] = {
      1, 2, 3, 4 };
vector<int> iv6(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
vector<int>::iterator it3 = find(iv6.begin(), iv6.end(), 3);
iv6.erase(it3);//删除值为3的元素
cout << "iv6:  ";
for (auto &e : iv6)
{
     cout << e << " ";}
cout << endl;
cout << "*it3 = " << *it3 << endl;//再次访问it3

因为我用的是VS所以会报错。
STL-vector的使用及简单的模拟实现_第9张图片
我们再来看一下erase之后是返回指向下一个数据的迭代器还是指向原位置。

	int arr1[] = {
      1, 2, 3, 4,5 };
	vector<int> iv6(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
	vector<int>::iterator it3 = find(iv6.begin(), iv6.end(), 3);
	auto it4 = iv6.erase(it3);//删除值为3的元素
	cout << "*it4 = " << *it4 << endl;//看一下it4指的是4还是5

在这里插入图片描述
可见erase的返回值依旧是指向原来位置的迭代器,只不过删除原位置的数据后,其后面的元素往前挪,所以是4。


三、vector的简单模拟

#include 
using namespace std;

namespace LJL
{
     
	template<class _Ty>
	class vector
	{
     
	public:
		typedef _Ty* iterator;//迭代器就是原生指针
	public:
		vector() :_First(nullptr),
			_Last(nullptr),
			_End(nullptr)
		{
     }
		vector(int n, const _Ty &x = _Ty())
			:_First(nullptr), _Last(nullptr), _End(nullptr)
		{
     
			reserve(n);
			while (n--)
				push_back(x);
		}
		vector(vector<_Ty> &v) :
			_First(nullptr), _Last(nullptr), _End(nullptr)
		{
     
			reserve(v.capacity());
			iterator it = begin();
			iterator it1 = v.begin();
			while (it1 != v.end())
			{
     
				*it++ = *it1++;
			}
			_Last = it;
		}
		vector<_Ty> & operator=(vector<_Ty> v)
		{
     
			vecter<_Ty> tmp(v);
			swap(tmp);
			return *this;
		}
		~vector()
		{
     
			delete _First;
			_First = _Last = _End = nullptr;
		}
	public:
		size_t size()const
		{
     return _Last - _First;}
		size_t capacity()const
		{
     return _End - _First;}
		bool empty()
		{
     return _First == _Last;}
		iterator begin()
		{
     return _First;}
		iterator end()
		{
     return _Last;}
		iterator rbegin()
		{
     return _Last;}
		iterator rend()
		{
     return _First;}
		_Ty& operator[](size_t pos)
		{
     return _First[pos];}
		void push_back(const _Ty &x)
		{
     insert(end(), x);}
		void pop_back(const _Ty &x)
		{
     erase(--end());}
		void swap(vector<_Ty> &v)
		{
     
			swap(_First, v._First);
			swap(_Last, v._Last);
			swap(_End, v._End);
		}
	public:
		void reserve(size_t n)
		{
     
			if (n > capacity())
			{
     
				//扩容
				size_t old_size = size();
				_Ty *new_first = new _Ty[n];
				//memcpy(new_first, _First, sizeof(_Ty)*old_size);
				//delete[]_First;
				if (_First)
				{
     
					for (size_t i = 0; i < old_size; ++i)
					new_first[i] = _First[i];
				}
				_First = new_first;
				_Last = _First + old_size;
				_End = _First + n;
			}
		}
		void resize(size_t n, const _Ty &x = _Ty())
		{
     
			if (n <= size())
			{
     
				_Last = _First + n;
				return;
			}
			else
			{
     
				if (n > capacity())
				{
     
					reserve(n);
				}
				iterator cur = _Last;
				_Last = _First + n;
				while (cur != _Last)
				{
     
					*cur = x;
					++cur;
				}
			}
			
		}
		iterator insert(iterator _P, const _Ty &x)//返回的迭代器指向新插入的元素
		{
     
			//确定空间是否够
			if (_Last == _End)
			{
     
				size_t p_size = _P - _First;
				size_t new_size = size() == 0 ? 1 : size() * 2;
				reserve(new_size);
				_P = _First + p_size;//修改_P迭代器
			}
			//后移
				iterator end = _Last;
				while (end > _P)
				{
     
					*end = *(end - 1);
					--end;
				}
				*_P = x;
			++_Last;
			return _P;
		}
		iterator erase(iterator pos)
		{
     
			// 挪动数据进行删除
			iterator begin = pos + 1;
			while (begin != _Last)
			{
     
				*(begin - 1) = *begin;
				++begin;
			}
			--_Last;
			return pos;
		}
	private:
		iterator _First;//指向空间起始
		iterator _Last;//指向空间内任一位置
		iterator _End;//空间尾部
	};

}

少了几个接口,暂时没能搞出来,等解决了再到评论区补充。

你可能感兴趣的:(c++,算法,STL,vector)