C++STL---->vector

本文详细介绍了C++ STL中vector的数据结构,包括其扩容原理(VS 1.5倍和SGI 2倍)、迭代器的使用方法,以及构造、接口函数的实战演示。通过模拟实现和讨论迭代器失效问题,帮助读者深入理解vector的工作机制。
摘要由CSDN通过智能技术生成


什么是vector
和学习string一样,我们也是通过官方的文档来看一看vector是怎么声明的
在这里插入图片描述
我们可以进一步对vector的声明做简化

template<class T> class vector

可以看到vector是一个类模板,结构上就是我们先前在数据结构初阶学习的动态顺序表。在插入一定的数据的时候会进行扩容。因此我们就可以知道vector的底层是一个连续的数组。


vector是怎么进行扩容的
STL有很多不同的版本,微软维护的版本是PJ版本,而Linux的g++维护的是SGI版。这两个版本的扩容设计的就不太相同。下面我们简单在两个平台下面测试一下:

#include<iostream>
#include<vector>
using namespace std;
void test1()
{
	vector<int>v(2);
	v.push_back(1);
	v.push_back(1);
	cout << v.capacity() << endl;
	//这一次插入就会发生扩容
	v.push_back(2);
	cout << v.capacity() << endl;
	v.push_back(3);
	v.push_back(3);
	v.push_back(3);
	cout << v.capacity() << endl;
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
可以发现,vs下面的vetor的扩容是按照1.5倍进行扩容的。我们切换到Linux下使用g++测试对应的扩容因子。
在这里插入图片描述
可以看到SGI版本下vector的扩容因子是2倍,也就是按照2倍扩容的。至于1.5倍和2倍扩容哪一个更好,我的观点是这两个扩容方案都非常优秀。


vector的迭代器
接下来我们来看一看vector的迭代器,和string的迭代器类似。vector的迭代器也是一个原生指针 那么我们简单来看一看vector的迭代器怎么使用

#include<iostream>
#include<vector>
using namespace std;
void test()
{
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	//使用迭代器访问
	//迭代器的类型是vector<T>::iterator--->(T是实例化的类型)
	//auto it=v.begin();---->c++11支持这么做
	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
int main()
{
	test();
	return 0;
}

在这里插入图片描述
对于vector而言,掌握vector的迭代器非常重要!因为vector的insert和erase方法提供的只有迭代器版本的,没有下标版本的,所以掌握vector的迭代器非常重要!


vector的构造和常见接口的使用
接下来我们就来看一看vector的构造函数和常见接口的使用,和先前学习string一样,我们先从官方文档来了解:
先来看一看vector的构造函数
在这里插入图片描述
接着我们上手来使用几个构造函数

void test3()
{  
	//默认构造一个空容器
	vector<int>v1;
	//构造3个元素是5的vector
	vector<int>v2(3, 5);
	//迭代器区间构造
	vector<int>v3(v2.begin(), v2.end());
	//拷贝构造
	vector<int>v4(v2);
}

我们更多会用的是默认构造,迭代器区间构造,拷贝构造,而对于n个值是val的构造方式我们了解就可以了。
接下来我们再来看一看vector的常见的接口函数:
在这里插入图片描述

void test()
{
	vector<int>v;
	//尾插元素
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);
	for (auto c : v)
	{
		cout << c << " ";
	}
	cout << endl;
	//尾删元素
	v.pop_back();
	for (auto c : v)
	{
		cout << c << " ";
	}
	cout << endl;
	//insert方法--->使用迭代器往指定位置前元素
	v.insert(v.begin(), 3);
	for (auto c : v)
	{
		cout << c << " ";
	}
	cout << endl;
	//erase方法--->使用迭代器删除位置元素
	v.erase(v.begin() + 1);
	for (auto c : v)
	{
		cout << c << " ";
	}
	cout << endl;
}
int main()
{
	test();
	return 0;
}

在这里插入图片描述
其实整个vector的设计和string的设计是比较类似的,这里就不在过多展开描述了。


vector的模拟实现和迭代器失效的问题
为了能够更好理解vector的底层结构,接下来我们模拟实现vector。模拟实现只是为了更好地了解底层,而不是造更好地vector使用
我们先来看看STL里面是怎么设计
在这里插入图片描述
可以看到vector里面封装了三个迭代器

start:指向起始的位置
finish:指向有效数据的下一个位置
end_of_storage:指向能够存储最大有效数据

接下来我们类比这个官方库来设计框架

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
//和库里面的区分,封到一个命名空间里面
namespace chy
{
  //vector是一个模板类
  template<typename T>
  class vector
  {
  public:
	  typedef T* iterator;
	  typedef const T* const_iterator;
  private:
	  iterator _start;
	  iterator _finish;
	  iterator _end_of_stroge;
  };
}

接下来,快速提供默认构造和size()还有capacity()接口以及begin(),end()

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
//和库里面的区分,封到一个命名空间里面
namespace chy
{
  //vector是一个模板类
  template<typename T>
  class vector
  {
  public:
	  typedef T* iterator;
	  typedef const T* const_iterator;
	  vector<T>()
		  :_start(nullptr)
		  ,_finish(nullptr)
		  , _end_of_stroge(nullptr)
	  {}
	  
	   size_t size()const
	  {
		  return _finish - _start;
	  }
	  size_t capacity()const
	  {
		  return _end_of_stroge - _start;
	  }
	  iterator begin()
	  {
		  return _start;
	  }
	  iterator end()
	  {
		  return _finish;
	  }
	  const_iterator begin()const
	  {
		  return _start;
	  }
	  const_iterator end()const
	  {
		  return _finish;
	  }
  private:
	  iterator _start;
	  iterator _finish;
	  iterator _end_of_stroge;
  };
}

接下来我们就要写赋值运算符重载和拷贝构造函数。从前面string类的学习我们知道要实现成深拷贝。而关于深拷贝还有一种现代写法

//深拷贝现代写法--->构造临时对象,交换指针
 void swap(vector<T>& v)
	 {
		 //交换_start,_finish,_end_of_stroge就可以了
		 std::swap(_start, v._start);
		 std::swap(_finish, v._finish);
		 std::swap(_end_of_stroge, v._end_of_stroge);
	 }
//为了支持拷贝构造,需要一个迭代器区间构造版本的构造函数
	 template<typename InputIterator>
	 vector<T>(InputIterator first, InputIterator last)
		 :_start(nullptr)
		 ,_finish(nullptr)
		 ,_end_of_stroge(nullptr)
	 {
		 while (first != last)
		 {
			 push_back(*first);
			 ++first;
		 }
	 } 
 //拷贝构造
	 vector<T>(const vector<T>& v)
		 : _start(nullptr)
		 , _finish(nullptr)
		 , _end_of_stroge(nullptr)
	 {   
	     //构造临时对象
		 vector<T> tmp(v.begin(), v.end());
		 //交换资源
		 swap(tmp);
		 //tmp生命周期结束,自动析构处理
	  }
//赋值运算符重载
	 vector<T>& operator=(vector<T> v)
	 {
		 swap(v);
		 return *this;
	 }  

常见的函数接口的模拟实现:

 //n个val构造
	 vector<T>(size_t n, const T& val = T())
		 :_start(nullptr)
		 ,_finish(nullptr)
		 ,_end_of_stroge(nullptr)
	 {
		 reserve(n);
		 for (size_t i = 0; i < n; ++i)
		 {
			 push_back(val);
		 }
	 }
	 //提供这个版本是为了解决vector<int>v(int,int)的推演到迭代器构造的问题
	 vector<T>(int n, T val = T())
		 :_start(nullptr)
		 , _finish(nullptr)
		 , _end_of_stroge(nullptr)
	 {
		 reserve(n);
		 for (int i = 0; i < n; ++i)
		 {
			 push_back(val);
		 }
	 }
	void reserve(size_t n)
	  {    
		  size_t sz = size();
		  size_t cp = capacity();
		  if (n > capacity())
		  {
			  T* tmp = new T[n];
			  if (_start)
			  {
				  //memcpy(tmp, _start, sizeof(T) * size());
				  for (size_t i = 0; i < size(); ++i)
				  {
					  //一个一个拷贝
					  tmp[i] = _start[i];
				  }
				  delete[] _start;
			  }
			  _start = tmp;
		  }
		  //size=_finish-start  capacity=esg-start
		  //tmp+_finish-tmp=_finish=nullptr
		  _finish = _start + sz;
		  _end_of_stroge = _start + n;
	  }
	  void push_back(const T& val)
	  {
		 /* if (_finish == _end_of_stroge)
		  {
			  size_t n_capacity = capacity() == 0 ? 2 : 2 * capacity();
			  reserve(n_capacity);
		  }
		  *_finish = val;
		  ++_finish;*/
		  //复用insert
		  insert(end(), val);
	  } 
	void resize(size_t n, T val = T())
	  {
		  if (n < size())
		  {
			  _finish = _start + n;
		  }
		  else
		  {
			  if (n > capacity())
			  {
				  reserve(n);
			  }
			  while (_finish != _start + n)
			  {
				  *_finish = val;
				  ++_finish;
			  }
		  }
	  }
	  void pop_back()
	  {
		  /*assert(_finish!=_start);
		  _finish--;*/
		  //复用erase
		  erase(end() - 1);
	  }
	  iterator insert(iterator pos, const T& val)
	  {   
		  assert(pos >= _start && pos <= _finish);  
		  if (_finish == _end_of_stroge)
		  {   
			  size_t d = pos - _start;
			  reserve(capacity() == 0 ? 2 : 2 * capacity());
			  pos = _start + d;
		  }
		  //扩容以后,面临迭代器失效的问题,所以要更新pos
		  iterator end = _finish-1;
		  while (end >= pos)
		  {
			  *(end+1) = *end;
			  --end;
		  }
		  *pos = val;
		  ++_finish;
		  return pos;
	  }
	  T& operator[](size_t pos)
	  {
		  assert(pos < size());
		  return _start[pos];
	  }
	  const T& operator[](size_t pos)const
	  {
		  assert(pos < size());
		  return _start[pos];
	  }
	  iterator erase(iterator pos)
	  {   
		  assert(pos >= _start && pos < _finish);
		  iterator it = pos + 1;
		  while (it != _finish)
		  {
			  *(it - 1) = *it;
			  ++it;
		  }
		  --_finish;
		  return pos;
	  }
	  ~vector<T>()
	  {
		  if (_start)
		  {
			  delete[] _start;
			  _finish = _start = _end_of_stroge = nullptr;
		  }
	   }  

这里细心的同学会发现,insert和erase是有返回值的。那么这个返回值有什么意义呢?这里就要牵扯到一个问题----->迭代器失效
我们先来看看insert方法的迭代器失效问题:
在这里插入图片描述
那么我们来看官方库是怎么解决迭代器失效的问题:
在这里插入图片描述

insert方法返回一个迭代器,这个返回的迭代器指向新插入的迭代器,所以我们也类比库里面设计迭代器

iterator insert(iterator pos, const T& val)
	  {   
		  assert(pos >= _start && pos <= _finish);  
		  //处理扩容带来的迭代器失效问题
		  if (_finish == _end_of_stroge)
		  {   
			  size_t d = pos - _start;
			  reserve(capacity() == 0 ? 2 : 2 * capacity());
			  pos = _start + d;
		  }
		  iterator end = _finish-1;
		  while (end >= pos)
		  {
			  *(end+1) = *end;
			  --end;
		  }
		  *pos = val;
		  ++_finish;
		  return pos;
	  }

而erase方法也会有迭代器失效的问题。而相对于insert方法来说,erase方法仅仅只会存在语义上的失效,因为erase不会存在扩容的问题。
我们也同样通过官方文档来看一看怎么处理。
在这里插入图片描述

erase返回的迭代器指向删除位置后的第一个元素的位置

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

最后就是vector的析构函数:

 ~vector<T>()
	  {  
		  //非空才处理
		  if (_start)
		  {
			  delete[] _start;
			  _finish = _start = _end_of_stroge = nullptr;
		  }
	   }

关于vector的一些知识就介绍到这里。如果有不足的地方希望能够指出,希望大家可以一起进步。

评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值