C++之STL容器-----Vector实现

最新推荐文章于 2024-11-08 15:01:00 发布
最新推荐文章于 2024-11-08 15:01:00 发布
阅读量621 收藏 11
点赞数 10
文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44839773/article/details/140549992
版权

C++之STL容器-----Vector实现

一、Vector容器底层实现简易设计

（Vector内存图纵览）
在这里插入图片描述

（实现代码总览）

namespace wanboss
{
	template<class T>
	class vector
	{
	public:
		typedef T* itetator;
		
		//构造函数
		vector()
			:_start(nullptr), 
			 _finish(nullptr), 
			 _end_of_storage(nullptr)//初始化成员变量。
		{	}

		//拷贝构造函数 vector v(v1)
		vector(const vector<T>& v)//this-->v, const vector<T>& v-->v1。
		{
			_start = new T[v.capacity()];//创建一块以v1为基准的内存。
			_finish = _start;//新内存中没有数据，因此将尾指针指向开始位置。
			_end_of_storage = _start + v.capacity();//相当于capacity().

			for (size_t i = 0; i < v.size(); ++i)
			{
				//将 v 中值逐个拷贝给新的空间中，v[i] 会调用 operator[]方法。
				*_finish = v[i];
				++_finish;//元素进来得移动尾指针。
			}
		}
		
		//析构函数
		~vector()
		{
			delete[] _start;//释放内存空间
			_start = _finish = _end_of_storage = nullptr;//将指针置为空。
		}
		
		//迭代器的开始位置
		itetator begin()
		{
			return _start;
		}
	
		//迭代器的尾巴位置
		itetator end()
		{
			return _finish;
		}
		
		//const-->非const可以访问，const也可访问。
		size_t size() const
		{
			return _finish - _start;
		}

		//const-->非const可以访问，const也可访问。
		size_t capacity()const
		{
			return _end_of_storage - _start;
		}
		
		//operator[] 重定义。
		T& operator[](size_t i)
		{
			return *(_start + i);
		}
	
		//const-->非const可以访问，const也可访问。
		const T& operator[](size_t i)const
		{
			return *(_start + i);
		}
		
		//------------------------传统写法---------------------------------
		//v1(v2)
		vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)//防止 s1 = s1 防止降低效率。
			{
				delete[] _start;//释放原来的内存空间
				//基于 v2 创建一块新空间，并让原来旧空间指针指向。
				_start = new T[v.capacity()];
				//memcpy，按字节拷贝，将 v2 的内容拷贝给 v1。
				memcpy(_start, v._start, sizeof(T) * v.size());
			}
			return *this;
		}
		//------------------------传统写法---------------------------------

		//------------------------现代写法---------------------------------
		vector<T>& operator=(const vector<T>& v)
		{
			swap(_start, v._start);
			swap(_finish, v._finish);
			swap(_end_of_storage, v._end_of_storage);

			return *this;
		}
		//------------------------现代写法---------------------------------

		//reserve() 是改变容量的
		void reserve(size_t n)// n-->就是新的容量。
		{
			if (n > capacity())//如果 新空间大于总容量，增容。
			{
				//在进行内存操作之前，保存当前的大小，防止丢失。
				size_t old_size = size();

				T* temp = new T[n];//开辟一块临时空间

				/*
				如果 _start 为 nullptr，则表示当前 vector 是空的，没有任何已分配的内存，
				则无需进行以下的内存复制和释放操作，因为没有数据需要被复制，也没有内存需要被释放。
				*/
				if (_start)//
				{
					//memcpy(temp, _start, sizeof(T)* old_size);//按字节进行拷贝，属于浅拷贝
					for (size_t i = 0; i < old_size; ++i)
						temp[i] = _start[i];//调用的是 T 的operator=，属于深拷贝。

					delete[] _start;//释放原来的空间。
				}
				_start = temp;//将旧的指向变成新的空间指向。
				_finish = temp + old_size;//新的空间指向 + 旧的数据大小 = 新的空间数据结尾
				_end_of_storage = temp + n;//新的空间指向 + 旧的空间容量 = 新的空间容量。
			}

		}

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
				{
					 reserve(n);
				}
				
				itetator it = _start;
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

		void push_back(const T& x)
		{
			//if (_finish == _end_of_storage)//首先判断，容量是否够？
			//{
			//	size_t newcapacoty = capacity() == 0 ? 2 : capacity() * 2;//不够，增容。
			//	reserve(newcapacoty);
			//}
			//*_finish = x;//尾插，将_finish指向的空间填入尾插的值
			//++_finish;//更新尾指针。
			insert(_finish, x);
		}

		void pop_back()
		{
			//if (_finish >= _start)
			//	_finish--;

			//assert(_finish >= _start);//加入一个断言比较符合规定。
			erase(_finish - 1);
		}

		void insert(itetator pos, const T& x)//表示插入一个元素
		{
			assert(pos <= _finish);//表示可以尾插
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;//记录pos在增容前，与头指针距离。
				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
				reserve(newcapacity);

				pos = _start + len;//更新pos在增容后，新空间指向问题。
			}

			itetator end = _finish - 1;//尾部第一个数。
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			*pos = x;
			++_finish;
		}

		itetator erase(itetator pos)
		{
			if (_end_of_storage != _start)
			{
				assert(pos < _finish&& pos >= _start);
				itetator newstart = pos;
				while (newstart < _finish)
				{
					*newstart = *(newstart + 1);
					++newstart;
				}

				--_finish;
				return pos;
			}
			else
			{
				return nullptr;
			}
		}
	private:
		itetator _start;
		itetator _finish;
		itetator _end_of_storage;
	};
}

二、Verctor类实现细节

2.1 构造函数、拷贝构造和析构函数

		//---------------------构造函数-----------------------------------
		/*一般的构造函数对成员变量进行初始化工作，这里的成员变量是指针，一般让其指向空*/
		vector()
			:_start(nullptr), 
			 _finish(nullptr), 
			 _end_of_storage(nullptr)//初始化成员变量。
		{	}
		//---------------------构造函数-----------------------------------

		//---------------------拷贝构造函数-----------------------------------
		//拷贝构造函数 vector v2(v1)
		/*碰到拷贝构造函数，就可以想到 Vector v2(v1) 这个示例，主要是分清楚：
		v1 和 v2 在拷贝构造中代表这谁。技巧：谁基于谁才创建的----> v2 是基于 v1 创建的*/
		vector(const vector<T>& v)//this-->v2, const vector<T>& v-->v1。
		{
			_start = new T[v.capacity()];//创建一块以v1为基准的内存。
			//this->_start = new T[v.capacity()];
			_finish = _start;//新内存中没有数据，因此将尾指针指向开始位置。
			_end_of_storage = _start + v.capacity();//相当于capacity().

			for (size_t i = 0; i < v.size(); ++i)
			{
				//将 v 中值逐个拷贝给新的空间中，v[i] 会调用 operator[]方法。
				*_finish = v[i];
				++_finish;//元素进来得移动尾指针。
			}
		}
		//---------------------拷贝构造函数-----------------------------------

		//析构函数
		~vector()
		{
			delete[] _start;//释放内存空间
			_start = _finish = _end_of_storage = nullptr;//将指针置为空。
		}

针对拷贝构造函数，绘制思维图理解。
在这里插入图片描述

2.2 迭代器相关—begin( )、end( )、size( )、capacity( )。

（ 迭代器 浅层可以认为是 一个指针）

//迭代器的开始位置
itetator begin()
{
	return _start;
}

//迭代器的尾巴位置
itetator end()
{
	return _finish;
}

//const-->非const可以访问，const也可访问。
size_t size() const
{
	return _finish - _start;
}

//const-->非const可以访问，const也可访问。
size_t capacity()const
{
	return _end_of_storage - _start;
}

从下图可以看出上述代码的关系图：
在这里插入图片描述

2.3 有关 operator 的运算符重载：operator = 和 operator [ ]

//operator[] 重定义。
T& operator[](size_t i)
{
	return *(_start + i);
}

//const-->非const可以访问，const也可访问。
const T& operator[](size_t i)const
{
	return *(_start + i);
}

//------------------------传统写法---------------------------------
//v1 = v2
vector<T>& operator=(const vector<T>& v)
{
	if (this != &v)//防止 s1 = s1 防止降低效率。
	{
		delete[] _start;//释放原来的内存空间
		//基于 v2 创建一块新空间，并让原来旧空间指针指向。
		_start = new T[v.capacity()];
		//memcpy，按字节拷贝，将 v2 的内容拷贝给 v1。
		memcpy(_start, v._start, sizeof(T) * v.size());
	}
	return *this;
}
//------------------------传统写法---------------------------------

//------------------------现代写法---------------------------------
vector<T>& operator=(const vector<T>& v)
{
	swap(_start, v._start);
	swap(_finish, v._finish);
	swap(_end_of_storage, v._end_of_storage);

	return *this;
}
//------------------------现代写法---------------------------------

有关于const问题：（可参考这篇博客–关于const修饰成员变量）
在这里插入图片描述
关于运算符重载问题
在这里插入图片描述

2.4 reserve( ) 和 resize( ) 函数

reserve() : 改变容量（capacity()）、resize() ：改变有效字符大小个数（size()）

//reserve() 是改变容量的
void reserve(size_t n)// n-->就是新的容量。
{
	if (n > capacity())//如果 新空间大于总容量，增容。
	{
		//在进行内存操作之前，保存当前的大小，防止丢失。
		size_t old_size = size();

		T* temp = new T[n];//开辟一块临时空间

		/*
		如果 _start 为 nullptr，则表示当前 vector 是空的，没有任何已分配的内存，
		则无需进行以下的内存复制和释放操作，因为没有数据需要被复制，也没有内存需要被释放。
		*/
		if (_start)//
		{
			//memcpy(temp, _start, sizeof(T)* old_size);//按字节进行拷贝，属于浅拷贝
			for (size_t i = 0; i < old_size; ++i)
				temp[i] = _start[i];//调用的是 T 的operator=，属于深拷贝。

			delete[] _start;//释放原来的空间。
		}
		_start = temp;//将旧的指向变成新的空间指向。
		_finish = temp + old_size;//新的空间指向 + 旧的数据大小 = 新的空间数据结尾
		_end_of_storage = temp + n;//新的空间指向 + 旧的空间容量 = 新的空间容量。
	}

}

void resize(size_t n, const T& val = T())//改变有效内容的大小，并将新的内容进行初始化。
{
	if (n < size())//
	{
		_finish = _start + n;
	}
	else
	{
		if (n > capacity())
		{
			 reserve(n);
		}
		
		itetator it = _start;
		//这一步比较关键，因为resize他是改变有效内容的大小并对新的空间进行初始化。
		//因此是在_finish之后添加，可以保证 n < size()时，不会改变原有内容。

		while (_finish < _start + n)		
		{
			*_finish = val;
			++_finish;
		}
	}
}

关于reserve( )的设计思绪图：
在这里插入图片描述
面试点：为什么reserve在进行拷贝的时候要使用代码上的形式，使用memcpy函数不行？
在这里插入图片描述

学而恕己，宽而谅
关注
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
C++实现STL容器之Vector
04-08
C++实现STL容器之Vector
C++ STL --- vector类模拟实现
weixin_57761086的博客
08-29 1814
C++STL之vector的模拟实现，模拟实现了构造模块、迭代器模块、容量模块、元素访问模块、修改模块。同时讲解了为什么不能用memset和memecpy函数。使用大量代码举例子。
C++ STL--vector详解
weixin_62590142的博客
05-03 2314
以上是vector的几种定义方式，
C++系列-STL容器之vector
weixin_48668114的博客
08-29 1022
C++系列-STL容器之vector
C++ STL --- vector之迭代器失效
weixin_57761086的博客
08-28 1764
讲解C++ STL vector的迭代器失效。用简单的方式解决1.什么是迭代器失效？ 2.vector哪些操作会导致迭代器失效？ 3.如何避免迭代器失效？这三个问题。
C++中STL---vector详解
qq_44423388的博客
07-23 1954
vector函数及使用详解
【c++】STL--vector
includeevey的博客
12-26 2493
关于vector的讲解是非常值得收藏的
【C++入门】STL容器--vector底层数据结构剖析
2202_75605090的博客
01-20 1899
vector在C++中非常重要的容器，在刷题中也经常使用，它是一个动态的数组，提供了快速的随机访问和在尾部的插入和删除操作。vector的底层实现也是非常优秀的数据结构，值得我们去学习鉴赏，使用STL我们需要做到三个境界：能用，明理，能扩展；所以了解它的基本底层原理也是非常有必要的。在本文中，我们深入探讨了STL容器中的vector，以及它的底层数据结构。vector的底层设计也是比较好的，值得每位初学者借鉴学习；
C++ STL--vector容器
积木的笔记
12-09 1102
C++ STL--vector容器
C++常用STL容器--list
hcx的博客
06-14 2107
list基本功能：将数据进行链式存储 链表(list) 是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
C++进阶之路---STL---vector
qq_48083892的博客
04-27 1594
vector一：vector简介二.vector的初始化方式三.vector的常见问题1.size()和capacity()的区别2.元素的构建方式3.访问容器内部元素的方式方式一：方式二：error : 有可能造成访问越界方式三：方式四：方式五：autoauto注意点：需求决定实现4.const修饰迭代器自身5.data() 方式慎重使用6.reserve()7.resize()8.assign()9.回收空间10.元素插入:也可使迭代器失效方式一:insert()方式二:push_back()方式三:
C++课程小作业-STL容器与迭代器的实现路径-设计类vector容器myVector
06-14
STL是高效的C++程序库，是大量类模板和函数模板的聚集，主要的组成部分包括容器、迭代器、算法、函数等。其中容器是存放对象的集合，使用类模板方式; 选代器是容器与算法的粘合剂，是所谓的泛型指针, 使用类模板方式...
[C++]STL-vector容器
01-06
vector容器（动态数组，可变数组） 单口容器 vector动态增长的基本原理 当插入新元素时，如果空间不足，那么vector会重新申请更大的一块内存空间，将原来空间拷贝到新空间上，释放旧空间的数据，再把新元素插入新...
STL.rar_C++ STL_FSET-885_STL_stl源码_visual c
09-24
Visual C++编译器通常会包含STL的实现，但查看源码可以帮助我们学习如何使用STL更高效地编写C++程序。 在这个"STL.rar"压缩包中，你将找到STL的源代码，这是一份宝贵的教育资源。通过阅读和学习这些源码，你可以...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 734
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C++文件的读取操作
m0_67677309的博客
11-04 156
fstream 对文件的读写操作，继承了ofstream\ifstream类的功能。1. ofstream 对文件的写操作，继承了ostream类的功能。ifstream 对文件的读操作，继承了istream类的功能。对文件操作，打开才能写。
C 学习（4）
search7的博客
11-05 750
C语言学习，每个模块来自工作中的？？？
GitLab 提交 C++ 技巧
最新发布
nbspzs的专栏
11-08 124
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值