【C++进阶之路】vector的基本使用和模拟实现

前言

 作为STL的容器之一,vector的名字通常令人疑惑?在字面上,我们通常会翻译成向量,但感觉又解释不通,总觉得应该叫dynamic array翻译成动态数组/顺序表,更容易理解?那为啥呢?

我从知乎上看到这样的一个回答看起来挺有道理的~

【C++进阶之路】vector的基本使用和模拟实现_第1张图片

  • 下面有一条评论也觉得挺有意思的,体会到STL的设计者的苦衷——并不是不想取,而是这个dynamic array这个名字已经被占了,不得已才取这个名字。

原文链接:c++里如何理解vector是动态数组,而这个单词本义是向量?为什么这么叫?

再查看文档对这个词的解释~

Vectors are sequence containers representing arrays that can change in size.
翻译: Vectors是一些表示动态数组顺序的容器。——就是顺序表的意思。

再查看一下定义~

template < class T, class Alloc = allocator<T> > class vector; 
//第一个参数是模板参数,第二个参数是空间配置器也叫内存池,这个参数我们先不做了解。

一、vector简单使用

①接口

这里的常用接口跟string的差不多我就讲个别跟string有区别的。

1.reserve

 这个reserve 只会扩容,其它情况不做处理,而其他情况string会给出一个模棱两可的答案——优化(具体看编译器的实现)。

②用法

1.内置类型

这里举一个int

vector<int> v;

2.二维

比如你要开一个二维动态数组(int)

vector<vector<int>> vv;

内存布局:
【C++进阶之路】vector的基本使用和模拟实现_第2张图片

3.自定义类型

比如string

vector<string> vv;
string str("shun_hua");
vv.push_back(str);
//用类定义变量,再用变量进行初始化
vv.push_back(string("shun_hua"));
//用匿名对象初始化
vv.push_back("shun_hua");
//隐式类型转换直接初始化

说明:只要是类型,皆可以进行模板实例化。

③迭代器失效

我们只需记住两句话:

  • 数据的储存空间改变(常见的为扩容)可能会导致迭代器失效。

因为迭代器的底层是类似于指针的东西,当发生扩容时,指向旧空间的迭代器如果没有更新指向新空间,就会伴随着失效的问题。

比如:push_back,reserve,insert,swap

  • 移动数据可能会使迭代器失效。

比如:erase,在vs下使用过后判定为失效,再使用会直接出错,但是在Linux下,则不会。因此为了考虑平台移植性,我们统一认为迭代器会失效。

二、模拟实现

①要点说明

  • 1.为了不与库里面的vector冲突,我们需要命名空间对自己实现的类进行封装
  • 2.这里我们实现的框架是按照顺序表的数据结构进行实现的。
  • 3.为了理解,下面的接口是分开讲解的,最后我会给出源码

②基本框架

namespace my_vector
{
	template<class T>
	class vector
	{
	public:
		typedef T value_type;
		typedef const T const_value_type;
		typedef T* iterator;
		typedef const T* const_iterator;
		//迭代器的类型重定义
	private:
		iterator _begin = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
		//给缺省值,构造函数无需写初始化列表了,方便一些。
	};
}

大致框架图解:
【C++进阶之路】vector的基本使用和模拟实现_第3张图片
有的小伙伴问了,为啥不用顺序表的标准形式实现呢?这里实现主要是为了学习库里的底层原理,所以库里是这样实现的,我们就这样写了,其实这样写也有好处,下面讲。

③迭代器

1.begin

iterator begin()
{
	return _begin;
}
const_iterator begin()const
{
	return _begin;
}

2.end

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

浅浅的提一下:库里的cbegin与cend返回值只有const_iterator,且this指针经过特殊处理~

④ size

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

⑤capacity

size_t capacity()const
{
	return _end_of_storage - _begin;
}
  • size与capacity 运用的是指针减指针等于相邻元素个数,区间是左闭右开

⑥构造函数与析构函数

构造函数

1.默认构造函数

vector()
{
	
}

2.构造函数

//为了与下面的构造函数关联起来,这里就直接给出了。
void resize(size_t n, value_type val = value_type())
{
	if (n < size())
	{
		_finish = _finish + n;
	}
	else
	{
		reserve(n);
		iterator end = _begin + n;
		while (_finish != end)
		{
			*_finish = val;
			_finish++;
		}
		//这里直接对_finish进行调整,最后省去了一步操作。
	}
}
vector(size_t n, const value_type& val = value_type())
{
	resize(n, val);
}
//这个是用迭代器区间进行初始化
template<class InputIterator>
vector(InputIterator first , InputIterator last)
{
	size_t old_size = last - first;
	_begin = new value_type[old_size];
	InputIterator begin = first;
	while (begin != last)
	{
		push_back(*begin);
		begin++;
	}
}

这里有几个问题需要谈,我们先来谈第一个——value_type()

  • 这是C++语法支持的,适用于内置类型和自定义类型,对于内置类型会去调用它的默认构造,而对于内置类型也是可以的。

第二个问题,编译器不会按照我们想的去调用某个模板,而会去走最合适的模板。

//第一种写法
my_vector::vector<int> v(10,1);
//第二种写法
my_vector::vector<int> v(10u,1);
  • 其实第一种写法,我们是想走第一种构造函数的,但是这里的类型一样,更适合第二种构造,所以这里编译器会调用第二种,那这里如何解决呢?显然这里无法对迭代器进行显示声明,那我们只能走强制类型转换,也就是我们看到的第二种写法。

3.拷贝构造

vector(const vector& v)
{
	_begin = new value_type[v.size()];
	//大多数小伙伴可能会写第一种
	//memcpy(_begin, v._begin, sizeof(value_type) * v.size());
	//第二种	
	for (size_t i = 0; i < v.size(); i++)
	{
		_begin[i] = v[i];//不要小瞧这一步操作,下面细讲。
	}
	_finish = _end_of_storage = _begin + v.size();
}
//这个用到了reserve 和push_back,也比较方便
vector(const vector& v)
{
	reserve(v.capacity());
	for (auto e : v)
	{
		push_back(e);
	}
}

  • 这里涉及深拷贝的浅拷贝的问题。

这里举个例子。

vector<string> v;
v.push_back("1111");
v.push_back("2222");
vector<string> v1(v);

如果我们采用第一种写法:
【C++进阶之路】vector的基本使用和模拟实现_第4张图片

  • 这里典型的是浅拷贝,运行结束,同一块空间析构两次,会报错的。

而第二种写法,会调用string类的赋值重载,完成深拷贝,如果你要说string类的赋值重载是浅拷贝,那是string类的问题不是我们的问题。

析构函数

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

⑦reserve

void reserve(size_t n = 0)
{
	if (n > capacity())
	{
		size_t old_size = size();
		iterator tmp = new value_type[n];
		//这里在自定义类型也会出深拷贝的浅拷贝问题
		//memcpy(_tmp, _begin, sizeof(value_type)*old_size);
		for (size_t i = 0; i < size(); i++)
		{
			tmp[i] = _begin[i];
		}
		delete[] _begin;
		_begin = tmp;
		_finish = _begin + old_size;
		_end_of_storage = _begin + n;
	}
}

⑧push_back

void push_back(const value_type & val)
{
	if (_finish == _end_of_storage)
	{
		size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
		//扩容
		reserve(new_capacity);
	}
	*(_finish++) = val;
}

⑨[]

value_type& operator[](size_t pos)
{
	assert(pos < size());
	return _begin[pos]; 
}

const_value_type& operator[](size_t pos)const
{
	assert(pos < size());

	return _begin[pos];
}

⑩insert

void insert(iterator pos, const size_t val)
{
	assert(pos <= _finish && pos >= _begin);
	//是可以等于_finish的相当于尾插了
	if (_finish == _end_of_storage)
	{
		size_t rpos = pos - _begin;
		size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
		//扩容
		reserve(new_capacity);
		pos = _begin + rpos;
	}
	iterator end = _finish;
	while (end != pos)
	{
		*(end) = *(end - 1);
		end--;
	}
	*pos = val;
	_finish++;
}

⑪erase

iterator erase(iterator pos)
{
	assert(pos < _finish&& pos >= _begin);
	//只能删除有效数据
	iterator cur = pos;
	while (cur != _finish)
	{
		*(cur) = *(cur + 1);
		cur++;
	}
	_finish--;
	return pos;
}

举例:删除偶数的代码

	my_vector::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;
	//这是通用的代码
	my_vector::vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			it = v.earse(it);
		}
		else
		{
			it++;
		}
	}
	//这是不具有平台移植性的代码
	my_vector::vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.earse(it);
		}
		else
		{
			it++;
		}
	}
	//这是错误的代码,想想为什么。
	my_vector::vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.earse(it);
		}
		it++;
	}
	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

  • 因此:用返回值解决迭代器失效的问题,使代码具有了平台移植性。

⑫pop_back

void pop_back()
{
	earse(--end());
}

⑬swap

void swap(vector & x)
{
	std::swap(_begin, x._begin);
	std::swap(_finish, x._finish);
	std::swap(_end_of_storage, x._end_of_storage);
}

⑭ =

  • 这里我们还是采用现代写法
vector& operator =(vector tmp)
{
	swap(tmp);
	return *this;
}

源码

namespace my_vector
{
	template<class T>
	class vector
	{
	public:
		typedef T value_type;
		typedef const T const_value_type;
		typedef T* iterator;
		typedef const T* const_iterator;
		//迭代器
		iterator begin()
		{
			return _begin;
		}
		const_iterator begin()const
		{
			return _begin;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator end()const
		{
			return _finish;
		}
		vector(const vector& v)
		{
			_begin = new value_type[v.size()];
			//这里也会发生深拷贝的浅拷贝现象
			/*memcpy(_begin, v._begin, sizeof(value_type) * v.size());*/
			for (size_t i = 0; i < v.size(); i++)
			{
				_begin[i] = v[i];
			}
			_finish = _end_of_storage = _begin + v.size();
		}
		vector(size_t n, const value_type& val = value_type())
		{
			resize(n, val);
		}
		template<class InputIterator>
		vector(InputIterator first , InputIterator last)
		{
			size_t old_size = last - first;
			_begin = new value_type[old_size];
			InputIterator begin = first;
			int i = 0;
			while (begin != last)
			{
				push_back(*begin);
				begin++;
			}
		}
		//这个比较简单
		//vector(const vector& v)
		//{
		//	reserve(v.capacity());
		//	for (auto e : v)
		//	{
		//		push_back(e);
		//	}
		//}
		~vector()
		{
			delete[]_begin;
			_begin = _finish = _end_of_storage = nullptr;
		}
		size_t size() const
		{
			return _finish - _begin;
		}
		size_t capacity()const
		{
			return _end_of_storage - _begin;
		}
		void reserve(size_t n = 0)
		{
			if (n > capacity())
			{
				size_t old_size = size();
				iterator tmp = new value_type[n];
				//这里在自定义类型会出大坑
				//memcpy(_tmp, _begin, sizeof(value_type)*old_size);
				for (size_t i = 0; i < size(); i++)
				{
					tmp[i] = _begin[i];
				}
				delete[] _begin;
				_begin = tmp;
				_finish = _begin + old_size;
				_end_of_storage = _begin + n;
			}
		}
		void push_back(const value_type & val)
		{
			if (_finish == _end_of_storage)
			{
				size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
				//扩容
				reserve(new_capacity);
			}
			*(_finish++) = val;
		}
		value_type& operator[](size_t pos)
		{
			assert(pos < size());
			return _begin[pos]; 
		}
		const_value_type& operator[](size_t pos)const
		{
			assert(pos < size());

			return _begin[pos];
		}
		void insert(iterator pos, const size_t val)
		{
			assert(pos <= _finish && pos >= _begin);
			if (_finish == _end_of_storage)
			{
				size_t rpos = pos - _begin;
				size_t new_capacity = size() == 0 ? 4 : capacity() * 2;
				//扩容
				reserve(new_capacity);
				pos = _begin + rpos;
			}
			iterator end = _finish;
			while (end != pos)
			{
				*(end) = *(end - 1);
				end--;
			}
			*pos = val;
			_finish++;
		}
		iterator erase(iterator pos)
		{
			assert(pos < _finish&& pos >= _begin);
			iterator cur = pos;
			while (cur != _finish)
			{
				*(cur) = *(cur + 1);
				cur++;
			}
			_finish--;
			return pos;
		}
		//尾删
		void pop_back()
		{
			earse(--end());
		}
		void swap(vector & x)
		{
			std::swap(_begin, x._begin);
			std::swap(_finish, x._finish);
			std::swap(_end_of_storage, x._end_of_storage);
		}
		//赋值
		vector& operator =(vector tmp)
		{
			swap(tmp);
			return *this;
		}
		//value_type()这里匿名算是调用默认构造,对缺省参数进行初始化
		//1.对内置类型,C++对其做了升级,有对应的默认构造
		//2.对自定义类型,会去调用其默认构造。
		void resize(size_t n, value_type val = value_type())
		{
			if (n < size())
			{
				_finish = _finish + n;
			}
			else
			{
				reserve(n);
				iterator end = _begin + n;
				while (_finish != end)
				{
					*_finish = val;
					_finish++;
				}
			}
		}
	private:
		iterator _begin = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

总结

 今天的分享就到这里了,如果觉得文章不错,点个赞鼓励一下吧!我们下篇文章再见

你可能感兴趣的:(C++进阶之路,c++,开发语言,笔记)