模拟实现vector

最新推荐文章于 2024-08-23 11:07:46 发布
最新推荐文章于 2024-08-23 11:07:46 发布
阅读量145 收藏 1
点赞数 2
分类专栏： C++ 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45476980/article/details/132190642
版权

前言：

  了解学习完vector的底层之后，写一篇vector模拟实现，梳理一下知识点，帮助自己加深对vector的理解，以及以后得复习使用。（）常用部分）

关于vector 是用迭代器（本部分底层是T*类型）start、finish、endofstorge计算元素个数和容量。

vector 是一种顺序表可以存储多种类型的元素，可以是自定义也可以是内置类型，所以我们加入类模板，同时使用通用类型，定义迭代器：


	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
        iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

 构造函数

vector构造函数，可以使用默认构造，也可以使用迭代器区间初始化，还可以使用类型等构造的方式，代码如下：

vector(size_t n, const T& val =  T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		vector(int n, const T& val = T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		//使用迭代器区间初始化，为了匹配各种类型的迭代器，所以使用类模板定义
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}

		}

		//系统默认
		vector()
		{}

 这里需要注意的是：1、c++11 也支持内置烈性的匿名 譬如 int()  char() 都可以，

2、我们使用resize 默认开辟空间  并将空间初始化成 val 我在将resize的地方通过代码详细说明。

3.使用迭代器区间初始化，也是vector底层允许的，为了匹配各种类型的迭代器，我们使用类模板定义一个兼顾各种类型。

实现代码如下：

void test_vector2()
{
	manvec::vector<int> v1(10, 1);
	manvec::vector<string>v2(10,"hello word");
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : v2)
	{
		cout << e << " ";
	}
	cout << endl;

	manvec::vector<int> v3(v1.begin(), v1.end());
	string str("nihao shijie");
	manvec::vector<string> v4(v2.begin(), v2.end());
	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : v4)
	{
		cout << e << " ";
	}
	cout << endl;
	int a[] = { 16,2,77,29 };
	manvec::vector<int> v5(a, a + 4);
	for (auto e : v5)
	{
		cout << e << " ";
	}
	cout << endl;
}

拷贝构造

//拷贝构造
		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];//不确定T类型 有可能是自定义 
			//在这里 使用了 赋值 有效避免了 memcpy的浅拷贝
			memcpy(_start, v._start, sizeof(T) * v.size());
			/*for (size_t i = 0; i < v.size(); i++)
			{
				
				
				_start[i] = v._start[i];
			}*/
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
		}
		//交换

 这里需要注意的是，这种拷贝，存在隐患，如果只是简单地内置类型，是完全没问题的。

如下图所示

但是如果是自定义类型的呢？

 

如果想避免这个问题，就要把重载部分模拟实现。

 重载

    交换 

在介绍赋值重载之前 我们先引入交换函数 我们这里使用的是std里自带的交换函数，代码如下：

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

我们可以看看std:swap底层实现；帮助我们理解

 =赋值重载

		//v1 = v2
		vector<T>& operator=(vector<T> v) //再浏览一下
		{
			swap(v);
			return *this;
		}

  这里形参部分是v2的拷贝构造，在完成交换之后，函数结束，形参的声明周期也就结束了。但是我们已经通过引用接受返回的*this 就是v1。

[]重载

 

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

			return _start[pos];
		}

 reserve函数

 

		void reserve(size_t n)
		{
			//先判断是否需要扩容
			if (n > capacity())
			{
				// 记录原始 vector 的size
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//同样避免浅拷贝 地址失效
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;
				}
										
					_start = tmp;
					_finish = _start + sz;
					_endofstorage = _start + n;									
				
			}
		}

 这个地方如果我们使用的是memcpy   将_start指向的空间释放会发生什么呢？ tmp是不是也就变成野指针了？如下图所示。

 

 所以，对于T是string这样的深拷贝的类，调用的是string赋值重载，实现string对象的深拷贝。

resize函数

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);

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

 插入函数

因为插入的时候，会面临迭代器失效的问题，所以我要把这个函数理一遍，要保证插入的位置在合理的范围内，

iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);
			// 如果扩容的的话 会存在迭代器失效，所以我们要记录pos相对于_start的位置
			size_t len = pos - _start;
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				//迭代器失效解决地方
				pos = _start + len;
			}
			iterator end = _finish - 1;
			
			while (end >=pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++ _finish;

 			return pos;
         }

 图解如下：

 擦除函数

对删除位置的pos 位置之后 迭代器可能失效，vs进行了强制检查，如果访问就会直接报错，

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

			return pos;
		}

整体模拟实现

#pragma once
#include<assert.h>

namespace manvec
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
		vector(size_t n, const T& val =  T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		vector(int n, const T& val = T())  // 并不知道T的类型 可能内置很小 可能很大 所以用引用接收
		{
			//扩容 并初始化为val
			resize(n, val);
		}
		//使用迭代器区间初始化，为了匹配各种类型的迭代器，所以使用类模板定义
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}

		}

		//系统默认
		vector()
		{}
		//拷贝构造
		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];//不确定T类型 有可能是自定义 
			//在这里 使用了 赋值 有效避免了 memcpy的浅拷贝
			memcpy(_start, v._start, sizeof(T) * v.size());
			/*for (size_t i = 0; i < v.size(); i++)
			{
				
				
				_start[i] = v._start[i];
			}*/
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
		}
		//交换
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}
		//v1 = v2
		T& operator=(vector<T> v) //再浏览一下
		{
			swap(v);
			return *this;
		}

		~vector()
		{
			if (_start)
			{
				delete[]_start;
				_start = _finish = _endofstorage = nullptr;
			}
			
		}
		void reserve(size_t n)
		{
			//先判断是否需要扩容
			if (n > capacity())
			{
				// 记录原始 vector 的size
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//同样避免浅拷贝 地址失效
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					delete[]_start;
				}
										
					_start = tmp;
					_finish = _start + sz;
					_endofstorage = _start + n;									
				
			}
		}

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}
		void push_back(const T& x)
		{
			/*if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			++finish;*/
			insert(end(), x);

		}


		T& operator[](size_t pos)
		{
			assert(pos< size());
			return _start[pos];
		}
		const T& operator[](size_t pos) const
		{
			assert(pos < size());
			return _start[pos];
		}
		//获取容量
		size_t capacity()  const
		{
			return _endofstorage - _start;
		}
		//获取填充个数
		size_t size()  const
		{
			return _finish - _start;
		}
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);
			// 如果扩容的的话 会存在迭代器失效，所以我们要记录pos相对于_start的位置
			size_t len = pos - _start;
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				//迭代器失效解决地方
				pos = _start + len;
			}
			iterator end = _finish - 1;
			
			while (end >=pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++ _finish;

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

			return pos;
		}
		void print(const vector<int>& v)
		{
			for (auto e : v)
			{
				cout << e << " ";
			}
			cout << endl;
		}

	private:
		//c++11 支持在定义的时候给缺省值
		iterator _start  = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;

	};
}

 

养乌龟的小少年
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
模拟实现vector超详解（C++）
m0_67430750的博客
04-24 2283
简易版vector模拟实现超详解
C++模拟实现vector
03-07
C++模拟实现vector
C++ 模拟实现vector
Han同学
12-10 2160
C++模拟实现vector
初识C++ · 模拟实现vector
游人
05-27 865
目录前言：1 部分简单函数的实现2 push_back和pop_back3 reserve和resize4 Print_vector5 insert和erase6 拷贝构造7 构造8 赋值9 memcpy的问题10 迭代器失效继上文模拟实现了string之后，接着就模拟实现vector，因为有了使用string的基础之后，vector的使用就易如反掌了，所以这里直接就模拟实现了，那么实现之前，我们先看一下源代码和文档：源码不多看，因为很容易绕晕进去，我们从这两个部分得到的信息就够了，首先，vector是一个
【C++】模拟实现vector
C/C++领域,数据结构,linux,MySQl学习者
07-29 815
使用C++语言模拟实现vector,包括vector中的构造函数,析构函数,operator=,operator[],begin(),end(),capacity(),size(),push_back(),pop_back(),insert(),erase(),reserve(),resize(),swap()等函数.是适合C++初学者的入门模拟实现vector逐步详解.
【C++ STL】模拟实现 vector
水墨不写bug
07-08 1060
C++ STL 模拟实现vector
C++入门之vector的模拟实现
cls的博客
03-26 1138
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
C++：模拟实现vector
小柒的秃头之路
11-04 617
11_4模拟实现vector 1.string——近容器 vecotr容器（类似于数组） void resize();//长度和实际长度（实际数据发生变化） void reserve();//扩容（只改变长度） 2.使用模板实现vector (1)mvector.h #ifndef MVECTOR_H #define MVECTOR_H template<typename T> class Mvector { public: Mvector() { _arr = NULL; _le
【C++】vector模拟实现
VHhhbb的博客
07-15 1003
【C++】vector模拟实现
vector模拟实现
wmh
06-12 2914
vector的模拟实现
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 857
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 355
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法025：前缀和
m0_62319039的博客
08-22 210
算法025：前缀和
计算机毕业设计选题推荐-二手房价分析与预测-Python爬虫可视化-算法
IT研究室的博客
08-21 874
随着城市化进程的加快和房地产市场的发展，二手房市场日益活跃。二手房价格不仅受到经济、政策、地理位置等多种因素的影响，还与房屋本身的结构、面积、建造年代等属性密切相关。根据国家统计局的数据，近年来，二手房交易量持续增长，房价波动也成为社会关注的焦点。有效的二手房价分析与预测对于政府制定房地产政策、投资者做出投资决策以及普通购房者选择购房时机都具有重要意义。本课题旨在开发一个二手房价分析与预测系统，通过该系统，管理员和用户能够对二手房市场进行深入的数据分析和房价预测。
智能微气候:精准调控背后的算法革命
u010079117的博客
08-20 977
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
最小区间00
青釉Oo的博客
08-21 489
最小区间
算法笔试-编程练习-01-B-23
最新发布
志远的博客
08-23 802
小红组内有 n 个人，大家合作完成了一个初版方案，初始时大家的愤怒值都是 0。 但是领导对方案并不满意，共需要修改 m 次方案，每次修改会先让第 l 到 r 个人的愤怒值加 1，然后再修改方案；
c++模拟实现vector
09-01
总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值