vector的实现

最新推荐文章于 2022-09-12 20:51:32 发布
最新推荐文章于 2022-09-12 20:51:32 发布
阅读量313 收藏 1
点赞数
分类专栏： 数据结构 linux 编程 文章标签： c++ vector stl linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clh01s/article/details/88240921
版权
编程 同时被 3 个专栏收录
37 篇文章 0 订阅
订阅专栏
linux
9 篇文章 0 订阅
订阅专栏
数据结构
3 篇文章 0 订阅
订阅专栏

磨磨蹭蹭了三

个月终于吧vector的实现给写了一遍 = =

/*
 * Vector.h
 *
 *  Created on: Dec 6, 2018
 *      Author: clh01s
 */

#ifndef VECTOR_H_
#define VECTOR_H_

//#include <vector>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/functexcept.h>
#include <bits/concept_check.h>
#include <initializer_list>
#include <iostream>

template<typename _Tp, typename _Alloc>
struct _Vector_base
{
	typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
		rebind<_Tp>::other _Tp_alloc_type;
	typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
		pointer;
	struct _Vector_impl: public _Tp_alloc_type
	{
		pointer _M_start;			//表示目前使用空间的头
		pointer _M_finish;			//表示目前使用空间的尾
		pointer _M_end_of_storage;  //表示目前可用空间的尾
		_Vector_impl()
		: _Tp_alloc_type(),_M_start(),_M_finish(),_M_end_of_storage()
		{}

		_Vector_impl(_Tp_alloc_type const& __a) _GLIBCXX_NOEXCEPT
		: _Tp_alloc_type(__a),_M_start(),_M_finish(),_M_end_of_storage()
		{}

		_Vector_impl(_Tp_alloc_type& __a) noexcept
		: _Tp_alloc_type(std::move(__a)),
		  _M_start(),_M_finish(),_M_end_of_storage()
		  {}

		void _M_swap_data(_Vector_impl& __x) _GLIBCXX_NOEXCEPT
		{
			std::swap(_M_start, __x._M_start);
			std::swap(_M_finish, __x._M_finish);
			std::swap(_M_end_of_storage, __x._M_end_of_storage);
		}
	};

	public:
	typedef _Alloc allocator_type;

	_Tp_alloc_type&
	_M_get_Tp_allocator() _GLIBCXX_NOEXCEPT
	{
		return *static_cast<_Tp_alloc_type*>(&this->_M_impl);
	}

	const _Tp_alloc_type&
	_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
	{
		return *static_cast<const _Tp_alloc_type*>(&this->_M_impl);
	}

	allocator_type
	get_allocator() const _GLIBCXX_NOEXCEPT
	{
		return allocator_type(_M_get_Tp_allocator());
	}

	_Vector_base()
	:_M_impl(){}

	_Vector_base(const allocator_type& __a) _GLIBCXX_NOEXCEPT
	:_M_impl(__a){}

	_Vector_base(size_t __n)
	:_M_impl()
	{_M_create_storage(__n);}

	_Vector_base(size_t __n, const allocator_type& __a)
	:_M_impl(__a)
	{_M_create_storage(__n);}

	_Vector_base(_Tp_alloc_type&& __a) noexcept
	:_M_impl(std::move(__a))
	{}

	_Vector_base(_Vector_base&& __x) noexcept
	:_M_impl(std::move(__x._M_get_Tp_allocator()))
	{this->_M_impl._M_swap_data(__x._M_impl);}

	_Vector_base(_Vector_base&& __x, const allocator_type& __a)
	:_M_impl(__a)
	{
		if(__x.get_allocator() == __a)
		{
			this->_M_impl._M_swap_data(__x._M_impl);
		}
		else
		{
			size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
			_M_create_storage(__n);
		}
	}
	//析构函数
	~_Vector_base() _GLIBCXX_NOEXCEPT
	{
		_M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
				- this->_M_impl._M_start);
	}

	public:
	_Vector_impl _M_impl;

	//内存分配函数
	pointer _M_allocate(size_t __n)
	{
		typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
		//如果__n不等于0则按照__n构建内存，否则返回一个初始的地址
		return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
	}

	//内存释放函数
	void _M_deallocate(pointer __p, size_t __n)
	{
		typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
		if(__p)
		{
			_Tr::deallocate(_M_impl, __p, __n);
		}
	}
	private:
	void _M_create_storage(size_t __n)
	{
		//创建指定大小的内存空间
		this->_M_impl._M_start = this->_M_allocate(__n);
		this->_M_impl._M_finish = this->_M_impl._M_start;
		this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
	}
};

template<typename _Tp, typename _Alloc = std::allocator<_Tp>>
class my_vector: protected _Vector_base<_Tp, _Alloc>
{
	typedef typename _Alloc::value_type _Alloc_value_type;
	__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
	__glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)

	typedef _Vector_base<_Tp, _Alloc> _Base;
	typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
	typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;

public:
	typedef _Tp value_type;
	typedef typename _Base::pointer pointer;
	typedef typename _Alloc_traits::const_pointer const_pointer;
	typedef typename _Alloc_traits::reference reference;
	typedef typename _Alloc_traits::const_reference const_reference;
	typedef __gnu_cxx::__normal_iterator<pointer, my_vector> iterator;
	typedef __gnu_cxx::__normal_iterator<const_pointer, my_vector> const_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef _Alloc allocator_type;

protected:
	using _Base::_M_allocate;
	using _Base::_M_deallocate;
	using _Base::_M_impl;
	using _Base::_M_get_Tp_allocator;

public:
	my_vector()
//判断是否为默认构造
#if __cplusplus >= 201103L
	noexcept(is_nothrow_default_constructible<_Alloc>::value)
#endif
	:_Base(){ }

	explicit
	my_vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT
	:_Base(__a){}

#if __cpluscplus >= 201103L
	explicit
	my_vector(size_type __n, const allocator_type$ __a = allocator_type())
	:_Base(__n, __a)
	{ _M_default_initialize(__n);}

	my_vector(size_type __n, const value_type& __value,
			const allocator_type& __a = allocate_type())
	:_Base(__n, __a)
	{_M_fill_initialize(__n, __value);}
#else
	my_vector(const my_vector& __x)
	:_Base(__x.size(), _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
	{
		std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start,
				_M_get_Tp_allocator());
	}

	~my_vector() _GLIBCXX_NOEXCEPT
	{
		std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
				_M_get_Tp_allocator());
	}
#endif

	void clear() _GLIBCXX_NOEXCEPT
	{_M_erase_at_end(this->_M_impl._M_start);}

	size_type
	capacity() const _GLIBCXX_NOEXCEPT
	{
		return size_type(this->_M_impl._M_end_of_storage
				- this->_M_impl._M_start);
	}

	my_vector&
	operator=(const my_vector& __x)
	{
		if(&__x != this)
		{
			if(_Alloc_traits::_S_propagate_on_copy_assign())
			{

				if(!_Alloc_traits::_S_always_equal()
				&& _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
				{
					this->clear();
					_M_deallocate(this->_M_impl._M_start,
							this->_M_impl._M_end_of_storage
							- this->_M_start);
					this->_M_impl._M_start = nullptr;
					this->_M_impl._M_finish = nullptr;
					this->_M_impl._M_end_of_storage = nullptr;
				}
				std::__alloc_on_copy(_M_get_Tp_allocator(),
						__x._M_getTp_allocator());
			}

			const size_type __xlen = __x.size();
			if(__xlen > capacity())
			{
				pointer __tmp = _M_allocate_and_copy(__xlen,__x.begin(),
						__x.end());
				std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
						_M_get_Tp_allocator());
				_M_deallocate(this->_M_impl._M_start,
						this->_M_impl._M_end_of_storage
						- this->_M_impl._M_start);
				this->_M_impl._M_start = __tmp;
				this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
			}
			else if(size() >= __xlen)
			{
				std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
						end(), _M_get_Tp_allocator());
			}
			else
			{
				std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
						this->_M_impl._M_start);
				std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
						__x._M_impl._M_finish,
						this->_M_impl._M_finish,
						_M_get_Tp_allocator());
			}
			this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
		}
		return *this;
	}

	iterator begin() _GLIBCXX_NOEXCEPT
	{
		return iterator(this->_M_impl._M_start);
	}

	const_iterator begin() const _GLIBCXX_NOEXCEPT
	{
		return const_iterator(this->_M_impl._M_start);
	}

	iterator end() const _GLIBCXX_NOEXCEPT
	{
		return iterator(this->_M_impl._M_finish);
	}

	size_type size() const _GLIBCXX_NOEXCEPT
	{
		return size_type(this->_M_impl._M_finish - this->_M_impl._M_start);
	}

	size_type
	max_size() const _GLIBCXX_NOEXCEPT
	{
		return _Alloc_traits::max_size(_M_get_Tp_allocator());
	}

	bool empty() const _GLIBCXX_NOEXCEPT
	{
		return begin() == end();
	}

	reference
	operator[](size_type __n) _GLIBCXX_NOEXCEPT
	{
		return *(this->_M_impl._M_start + __n);
	}

	void
	push_back(const value_type& __x)
	{
		if(this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
		{
			_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
					__x);
			++this->_M_impl._M_finish;
		}
		else
		{
			_M_emplace_back_aux(__x);
		}
	}

	const_iterator
	cbegin() const noexcept
	{
		return const_iterator(this->_M_impl._M_start);
	}

	iterator
	erase(const_iterator __position)
	{
		return _M_erase(begin() + (__position - cbegin()));
	}

	iterator
	erase(const_iterator __first, const_iterator __last)
	{
		const auto __beg = begin();
		const auto __cbeg = cbegin();
		return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
	}

protected:

	template<typename _ForwardIterator>
	pointer
	_M_allocate_and_copy(size_type __n,
			_ForwardIterator __first,_ForwardIterator __last)
	{
		pointer __result = this->_M_allocate(__n);
		try
		{
			std::__uninitialized_copy_a(__first, __last, __result,
					_M_get_Tp_allocator());
			return __result;
		}
		catch(...)
		{
			_M_deallocate(__result,__n);
			__throw_exception_again;
		}
	}

	void
	_M_erase_at_end(iterator __pos)
	{
		this->_M_impl._M_finish = __pos;
	}

	size_type
	_M_check_len(size_type __n, const char* __s) const
	{
		if(max_size() - size() < __n)
		{
			__throw_length_error(__N(__s));
		}

		const size_type __len = size() + std::max(size(), __n);
		return (__len < size() || __len > max_size()) ? max_size() : __len;
	}

	//原有存储空间不够用时的push操作
	template<typename... _Args>
	void _M_emplace_back_aux(_Args&&... __args)
	{
		const size_type __len =
				_M_check_len(size_type(1), "Vector::_M_emplace_back_aux");
		pointer __new_start(this->_M_allocate(__len));
		pointer __new_finish(__new_start);
		try
		{
			_Alloc_traits::construct(this->_M_impl, __new_start + size(),
					std::forward<_Args>(__args)...);
			__new_finish = pointer();

			__new_finish
			= std::__uninitialized_move_if_noexcept_a
			(this->_M_impl._M_start, this->_M_impl._M_finish,
					__new_start,_M_get_Tp_allocator());
			++__new_finish;
		}
		catch(...)
		{
			//出现异常则执行内存回收操作
			if(!__new_finish)
			{
				_Alloc_traits::destroy(this->_M_impl, __new_start + size());
			}
			else
			{
				std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
				_M_deallocate(__new_start, __len);
				__throw_exception_again;
			}
		}

		std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
				_M_get_Tp_allocator());
		_M_deallocate(this->_M_impl._M_start,
				this->_M_impl._M_end_of_storage
				- this->_M_impl._M_start);
		this->_M_impl._M_start = __new_start;
		this->_M_impl._M_finish = __new_finish;
		this->_M_impl._M_end_of_storage = __new_start + __len;
	}


	iterator _M_erase(iterator __position)
	{
		if(__position +1 != end())
		{
			//从__position +1的位置开始拷贝所有的元素到__position的位置
			//相当于用__position +1的元素替换__position
			std::copy(__position+1  , end(), __position);
		}
		//拷贝完毕后将内存大小--
		--this->_M_impl._M_finish;
		return __position;
	}

//	iterator _M_erase(iterator __first, iterator __last)
//	{
//		if(__first != __last)
//		{
//			_M_erase_at_end(std::copy(__last, end(), __first));
//		}
//		return __first;
//	}
};

#endif /* VECTOR_H_ */

下面是调用代码：

/*
 * test.cpp
 *
 *  Created on: Jul 31, 2018
 *      Author: clh01s
 */
#include <iostream>
#include "RB_tree.h"
#include "Vector.h"


using namespace std;

int main()
{
	my_vector<int> vec_a;
	//为vector添加元素
	for(int i = 0; i < 10; ++i)
	{
		vec_a.push_back(i);
	}
	cout<<"输出所有元素！"<<endl;
	for(int i = 0; i < vec_a.size(); ++i)
	{
		cout<<"vec["<<i<<"] = "<<vec_a[i]<<endl;
	}

	cout<<"删除0123号元素"<<endl;
	//未实现范围删除，所以使用一个个删除
	vec_a.erase(vec_a.begin());
	vec_a.erase(vec_a.begin());
	vec_a.erase(vec_a.begin());
	vec_a.erase(vec_a.begin());
	cout<<"输出删除后的元素！"<<endl;
	for(int i = 0; i < vec_a.size(); ++i)
	{
		cout<<"vec["<<i<<"] = "<<vec_a[i]<<endl;
	}
	return 0;
}

执行结果：

clh01s@clh01s:~/testcode/数据结构$ ./a.out
输出所有元素！
vec[0] = 0
vec[1] = 1
vec[2] = 2
vec[3] = 3
vec[4] = 4
vec[5] = 5
vec[6] = 6
vec[7] = 7
vec[8] = 8
vec[9] = 9
删除0123号元素
输出删除后的元素！
vec[0] = 4
vec[1] = 5
vec[2] = 6
vec[3] = 7
vec[4] = 8
vec[5] = 9

clh01s
关注
专栏目录
【C++】std::vector源码浅析
Making Life Better. Making Others Better.
12-03 8045
std::vector是stl标准模板库中的一个序列容器，其源码实现有几个特点：（1）C++中include的标准头文件是没有“.h”后缀的，其实这是C++的一层包裹，内部实现还是在“.h”文件中完成的，以我们include的vector为例，其中还会include一些真正的vector实现文件，如“stl_vector.h”。（2）vector的实现有一些内部使用的函数和数据类型，它们以下划线“_
c++ string 释放_源码分析C++的string实现
weixin_39906906的博客
11-26 806
我们平时使用C++开发过程中或多或少都会使用std::string，但您了解string具体是如何实现的吗，这里程序喵给大家从源码角度分析一下。读完本文相信您可以回答以下问题：string的常见的实现方式有几种？string类的内部结构是什么样子？string内部使用的内存是如何分配管理的？string是如何拷贝构造，如何析构的，有引用计数的概念吗？string的data()和c_str()函数有...
vector 详解（C++）
fierce_zhang的博客
09-12 473
C++ STL中的verctor好比是C语言中的数组，但是vector又具有数组没有的一些高级功能。与数组相比，vector就是一个可以不用再初始化就必须制定大小的边长数组，当然了，它还有许多高级功能。
vector数组push_backvec[0][0]的区别
长胖了辣条的博客
02-10 438
vector数组push_back与vec[0][0]添加数组的区别
vector
lswdcyy的博客
01-04 432
对于容器vector，他的存储原理就是一个数组，对于数组空间申请的话，那么就是基于https://welsey.blog.csdn.net/article/details/112189216中的空间分配器去进行空间申请； vector核心成员数据： pointer _M_start; // 开始存储元素的空间地址 pointer _M_finish; // 最后一个存储元素的之后的一个位置的空间地址 pointer _M_end_of_stor
纯c语言向量vector实现vector_master
06-27
为了在这些场景下也能实现类似的功能，我们可以自己编写一个纯C语言版本的向量（vector）数据结构。`vector_master`项目就是这样一个实现，它提供了C语言环境下向量的基本操作。 首先，让我们理解一下向量（vector...
使用Vector实现简单线程池
03-27
标题"使用Vector实现简单线程池"指的是将Java中的`Vector`类用于构建一个基础版本的线程池。`Vector`是Java集合框架的一部分，它是一个线程安全的动态数组，支持同步访问，这使得它成为多线程环境中存储和管理任务的...
C++容器vector实现通讯录功能
08-25
C++容器vector实现通讯录功能 C++容器vector实现通讯录功能是指使用C++语言中的vector容器来实现一个通讯录系统。这种系统可以存储和管理个人通讯录信息，并提供基本的增删改查功能。 在这个系统中，使用vector...
C++ 用vector实现图
03-23
C++ 用vector实现图，包括dijkstra算法，prim算法，以及拓扑排序等内容
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
SGI STL顺序容器 vector
木牛的博客
06-24 258
目录在SGI STL中，vector和array都是数组容器，两种操作非常相似。区别在于：array是静态空间，一旦配置就不能改变；vector是动态空间，随着新元素加入，内部机制或自行扩充空间以容纳新元素。vector维护的是一个连续线性空间，不论元素类型是什么，普通指针都可以作为vector的迭代器而满足所有必要条件，因为vector需要的操作：operator*，operator->，operatro++， operator--， operator+， operator-， operator+=， o
STL源码分析之vector
小鱼学编程
07-12 2215
本篇文章我们来学习vector的源码
GUN C++ STL中的vector的内存分配器
DOGGGGG的博客
10-17 2791
GUN C STL中的vector的内存分配器 alloc_traits GUN C++ STL中的vector的内存分配器//vector 原型 默认情况下其内存配置器为std::allocator<_Tp> template <typename _Tp, typename _Alloc = std::allocator<_Tp>> class vector : protected _Vecto
OpenCV 笔记（09）— 常用的数据结构和函数（Vec、Point、Scalar、Size、Rect、cvtColor）
wohu1104的专栏
10-31 2555
1. Vec 对象类型 Vec 是一个主要用于数值向量的模板类。我们可以定义向量的类型和组件的数量： Vec<double, 19> myVector 我们还可以使用任何的预定义类型： typedef Vec<uchar, 2> Vec2b; typedef Vec<uchar, 3> Vec3b; typedef Vec<uchar, 4> Vec4b; typedef Vec<short, 2> Vec2s; typedef Vec<
C/C++常见gcc编译链接错误解决方法
weixin_33962621的博客
05-19 4959
除非明确说明，本文内容仅针对x86/x86_64的Linux开发环境，有朋友说baidu不到，开个贴记录一下（加粗字体是关键词）： 用“-Wl,-Bstatic”指定链接静态库，使用“-Wl,-Bdynamic”指定链接共享库，使用示例： -Wl,-Bstatic -lmysqlclient_r -lssl -lcrypto -Wl,-Bdynamic...
C++进阶——STL源码之顺序容器vector
qq_25065595的博客
08-02 1148
顺序容器vector vector的数据安排以及操作和array相似，二者的唯一的差别在于空间的运用灵活性：array 是静态空间，一旦配置之后就不能改变；vector是动态空间，随着元素的加入，它的内部机制会自行的扩充空间以容纳新的元素。 vector的实现技术，关键在于对其大小的控制以及重新配置时的数据移动效率，一旦vector旧空间满载，vector将会以一种空间配置策略来扩充空间，从而降低配置新空间、数据移动、释放旧空间带来的性能消耗。 vector类的结构图 通过上面的类结构图，可以知
vector详解
Wilbert的博客
08-14 1万+
引言emmm…这篇博客写作的缘由其实就是我在日常使用vector的时候发现对vector并不怎么了解所以决定写这篇博客的。 写这篇博客，我参考了vector - C++ Reference中的内容，及侯捷先生的《STL源码剖析》一书，所实验的环境是CentOS7，g++4.8.5，所查看源码是SGI STL v3.3。这个版本的STL发布于2000年，而且是最新版。所以不包含C++11后的内容，所
vector底层实现及应用注意事项
热门推荐
weixin_52259848的博客
09-01 3万+
vector底层实现及应用注意事项
vector容器at访问报错以及operator[]
qq_42896627的博客
06-02 4016
初始化3个int型大小的元素，不清空，at正常访问 #include <iostream> #include <vector> using namespace std; int main() { vector<int> v(3); //v.clear(); v.at(1) = 10; cout << v[0] << ":" << v[1] << ":" << v[2]; return 0; } 初始
c++ vector 实现
最新发布
09-11
c++ vector是一个动态数组，可以根据需要自动增加或减少大小。使用vector需要包含vector头文件。...总结起来，c++ vector实现了一个动态数组，提供了一系列成员函数和运算符重载，使得操作和管理数组变得更加方便。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值