【C++】—— vector模拟实现

news2024/10/4 19:38:04

vector 接口预览

namespace HL
{
	template<class T>
	class vector
	{
		//迭代器iterator
		typedef T* iterator;
		typedef const T* const_iterator;

	public:
		//默认成员函数
		vector();
		vector(size_t n, const T& val = T());
		vector(int n, const T& val = T());
		vector(const vector& v);
		template<class InputIterator>
		vector(InputIterator first, InputIterator last);
		~vector();
		vector<T>& operator=(vector v);
		//Iterator
		iterator& begin();
		iterator& end();
		const_iterator begin() const;
		const_iterator& end() const;
		//Capacity
		size_t size() const;
		size_t capacity() const;
		bool empty() const;
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());
		//Modifiers
		void push_back(const T& val);
		void pop_back();
		void insert(iterator pos, const T& val);
		template<class InputIterator>
		void insert(iterator pos, InputIterator first, InputIterator last);
		iterator erase(iterator pos);
		void swap(vector<T>& v);
		//Element access:
		T& operator[](size_t i);
		const T& operator[](size_t i) const;
		
	private:
		iterator start;
		iterator finish;
		iterator end_of_storage;
	};

};

vector模拟实现

vector成员变量

​ vector成员变量，和顺序表的成员变量有所不同，不再是指针、size和capacity了，而是迭代器 start、finish和end_of_storage。
在这里插入图片描述

start指向起始位置、finish指向最后一个数据的下一个位置（表示数据的末尾）、end_of_storage指向这一块空间的最后。

默认成员函数

构造函数

1、无参构造

​ 无参构造，就是默认构造函数，将成员变量都初始化成nullptr。

vector()
	:start(nullptr)
	,finish(nullptr)
	,end_of_storage(nullptr)
{}
2、构造并初始化成n个val值

​ 理论上，我们只需要写一个函数vector(size_t n, const T& val = T());即可，但是如果两个参数都是int类型，（即vector v(5,1);）编译器在编译时，认为T已经实例化成了int，对于两个int类型，编译器就会选择更为匹配的模版

template vector(InputIterator first, InputIterator last);

所以这里写一个vector(int n, const T& val = T()); 让上面这种情况匹配这个函数。

vector(size_t n, const T& val = T())
{
	start = new T[n];
	for (size_t i = 0; i < n; i++)
	{
		start[i] = val;
	}
	end_of_storage = finish = start + n;
}
vector(int n, const T& val = T())
{
	start = new T[n];
	for (int i = 0; i < n; i++)
	{
		start[i] = val;
	}
	end_of_storage = finish = start + n;
}
3、使用一段迭代器区间进行初始化

​ 使用迭代器区间进行初始化，这里不一定是vector的迭代器，所以写成模板。

		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			size_t sz = last - first;
			start = new T[sz];
			finish = start;
			while (first != last)
			{
				*finish = *first;
				++finish;
				++first;
			}
			end_of_storage = start + sz;
		}
4、拷贝构造

​ 这里要注意，需要深拷贝，而不是浅拷贝。

		vector(const vector& v)
		{
			size_t sz = v.size();
			size_t cp = v.capacity();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = start + sz;
			end_of_storage = start + cp;
		}

析构函数

​ 析构函数比较简单，释放动态开辟的空间即可。

		~vector()
		{
			if (start)
				delete[] start;
			start = finish = end_of_storage = nullptr;
		}

赋值运算符重载

​ 赋值运算符重载，这个编译器自动生成的是浅拷贝，我们需要写一个深拷贝的。

这里有多种写法，首先就是传统写法，我们自己释放、开辟空间再拷贝数据

		vector<T>& operator=(const vector& v)
		{
			if (start)
				delete[] start;
			size_t sz = v.size();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = end_of_storage = start + sz;
		}

​ 还有现代写法，我们这里传参不使用引用，而使用传值传参；这样生成的形参对象再与我们的this(对象)进行交换；这样形参出了作用域就自动调用析构函数，不用我们去处理了。（这个需要先实现交换函数）

		vector<T>& operator=(vector v)
		{
			swap(v);
			return *this;
		}

​ 注意事项： 在赋值的过程中没有使用memcpy函数，因为这个函数只是将数值拷贝过去(浅拷贝)；

如果我们vector 示例化是vector 这样的自定义类型，使用浅拷贝就可能会出现问题；所以这里采用一个一个进行赋值操作，这样就会去调用自定义类型的赋值运算符重载；而不只是简单的浅拷贝了。

iterator 迭代器

​ vector 的迭代器这里实现的是原生指针；迭代器相关函数：begin()、end()这些都比较简单就不过多描述了。

		//迭代器iterator
		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;
		}

Capacity

​ capacity容量相关的函数，主要在于调整空间大小和设置内容。

size、capacity、empty

		size_t size() const
		{
			return finish - start;
		}
		size_t capacity() const
		{
			end_of_storage - start;
		}
		bool empty() const
		{
			return start == finish;
		}

reserve

​ reserve，调整空间大小；即扩容。

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = T[n];
				size_t sz = size();
				for (int i = 0; i < sz; i++)
				{
					tmp[i] = start[i];
				}
				if (start)
					delete[] start;
				start = tmp;
				finish = start + sz;
				end_of_storage = start + n;
			}
		}

resize()

		void resize(size_t n, const T& val = T())
		{
			reserve(n);
			if (n < size())
			{
				finish = start + n;
			}
			else {
				for (int i = size(); i < n; i++)
				{
					start[i] = val;
				}
				finish = start + n;
			}
		}

Modifiers

​ modifiers 增删查改、vector头插头删效率很低，就不提供头插头删接口了。

push_back、pop_back

​ 尾差、尾删，直接在vector最后插入删除数据。

		void push_back(const T& val)
		{
			if (capacity() == size())
			{
				size_t n = (capacity() == 0) ? 4 : 2 * capacity();
				reserve(n);
			}
			*finish = val;
			++finish;
		}
		void pop_back()
		{
			assert(start != finish);
			--finish;
		}

insert

insert函数，在某个位置插入n(可以是1)个数据。或者插入一段迭代器区间的数据。

iterator insert(iterator pos, const T& val)
{
	// 空间不够先进行增容
	if (finish == end_of_storage)
	{
		size_t newCapacity = (capacity() == 0) ? 1 : capacity() * 2;
		reserve(newCapacity);

		// 如果发生了增容，需要重置pos
		pos = _start + size();
	}
	//挪动数据
	iterator p = finish;
	while (p != pos)
	{
		*p = *(p - 1);
		--p;
	}
	*pos = val;
	finish += 1;
	return pos;
}
template<class InputIterator>
void insert(iterator pos, InputIterator first, InputIterator last)
{
	//这里如果迭代器不是原生指针或者内存空间不连续就不能进行 - 操作了
	size_t sz = last - first;
	size_t n = pos - start;
	reserve(sz + size());
	pos = start + n;
	//挪数据
	iterator p = finish - 1;
	while (p >= pos)
	{
		*(p + sz) = *p;
		--p;
	}
	//插入数据
	for (size_t i = 0; i < sz; i++)
	{
		pos[i] = first[i];
	}
	finish += sz;
}

​ 这里，扩容之后还用一个迭代器失效问题，需要重新给pos赋值。

erase

​ erase就是删除某个位置的数据，直接将后面数据往前移动即可

		iterator erase(iterator pos)
		{
			size_t sz = finish - pos;
			for (int i = 0; i < sz; i++)
			{
				pos[i] = pos[i + 1];
			}
			finish -= 1;
			return pos;
		}

clear、swap

		void swap(vector<T>& v)
		{
			std::swap(start, v.start);
			std::swap(finish, v.finish);
			std::swap(end_of_storage, v.end_of_storage);
		}
		void clear()
		{
			finish = start;
		}

Element access

operator[ ]

​ 下标访问，直接返回start[i]即可。

		T& operator[](size_t i)
		{
			return start[i];
		}
		const T& operator[](size_t i) const
		{
			return start[i];
		}

代码总览

#pragma once
#include<iostream>
#include<assert.h>

namespace HL
{
	template<class T>
	class vector
	{
		//迭代器iterator
		typedef T* iterator;
		typedef const T* const_iterator;

	public:
		//默认成员函数
		vector()
			:start(nullptr)
			,finish(nullptr)
			,end_of_storage(nullptr)
		{}
		vector(size_t n, const T& val = T())
		{
			start = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				start[i] = val;
			}
			end_of_storage = finish = start + n;
		}
		vector(int n, const T& val = T())
		{
			start = new T[n];
			for (int i = 0; i < n; i++)
			{
				start[i] = val;
			}
			end_of_storage = finish = start + n;
		}
		vector(const vector& v)
		{
			size_t sz = v.size();
			size_t cp = v.capacity();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = start + sz;
			end_of_storage = start + cp;
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			size_t sz = last - first;
			start = new T[sz];
			finish = start;
			while (first != last)
			{
				*finish = *first;
				++finish;
				++first;
			}
			end_of_storage = start + sz;
		}
		~vector()
		{
			if (start)
				delete[] start;
			start = finish = end_of_storage = nullptr;
		}
		/*vector<T>& operator=(vector v)
		{
			swap(v);
			return *this;
		}*/
		vector<T>& operator=(const vector& v)
		{
			if (start)
				delete[] start;
			size_t sz = v.size();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = end_of_storage = start + sz;
		}
		//Iterator
		iterator& begin()
		{
			return start;
		}
		iterator& end()
		{
			return finish;
		}
		const_iterator begin() const
		{
			return start;
		}
		const_iterator& end() const
		{
			return finish;
		}
		//Capacity
		size_t size() const
		{
			return finish - start;
		}
		size_t capacity() const
		{
			end_of_storage - start;
		}
		bool empty() const
		{
			return start == finish;
		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = T[n];
				size_t sz = size();
				for (int i = 0; i < sz; i++)
				{
					tmp[i] = start[i];
				}
				if (start)
					delete[] start;
				start = tmp;
				finish = start + sz;
				end_of_storage = start + n;
			}
		}
		void resize(size_t n, const T& val = T())
		{
			reserve(n);
			if (n < size())
			{
				finish = start + n;
			}
			else {
				for (int i = size(); i < n; i++)
				{
					start[i] = val;
				}
				finish = start + n;
			}
		}
		//Modifiers
		void push_back(const T& val)
		{
			if (capacity() == size())
			{
				size_t n = (capacity() == 0) ? 4 : 2 * capacity();
				reserve(n);
			}
			*finish = val;
			++finish;
		}
		void pop_back()
		{
			assert(start != finish);
			--finish;
		}
		iterator insert(iterator pos, const T& val)
		{
			// 空间不够先进行增容
			if (finish == end_of_storage)
			{
				size_t newCapacity = (capacity() == 0) ? 1 : capacity() * 2;
				reserve(newCapacity);

				// 如果发生了增容，需要重置pos
				pos = _start + size();
			}
			//挪动数据
			iterator p = finish;
			while (p != pos)
			{
				*p = *(p - 1);
				--p;
			}
			*pos = val;
			finish += 1;
			return pos;
		}
		template<class InputIterator>
		void insert(iterator pos, InputIterator first, InputIterator last)
		{
			//这里如果迭代器不是原生指针或者内存空间不连续就不能进行 - 操作了
			size_t sz = last - first;
			size_t n = pos - start;
			reserve(sz + size());
			pos = start + n;
			//挪数据
			iterator p = finish - 1;
			while (p >= pos)
			{
				*(p + sz) = *p;
				--p;
			}
			//插入数据
			for (size_t i = 0; i < sz; i++)
			{
				pos[i] = first[i];
			}
			finish += sz;
		}
		iterator erase(iterator pos)
		{
			size_t sz = finish - pos;
			for (int i = 0; i < sz; i++)
			{
				pos[i] = pos[i + 1];
			}
			finish -= 1;
			return pos;
		}
		void swap(vector<T>& v)
		{
			std::swap(start, v.start);
			std::swap(finish, v.finish);
			std::swap(end_of_storage, v.end_of_storage);
		}
		void clear()
		{
			finish = start;
		}
		//Element access:
		T& operator[](size_t i)
		{
			return start[i];
		}
		const T& operator[](size_t i) const
		{
			return start[i];
		}
		
	private:
		iterator start;
		iterator finish;
		iterator end_of_storage;
	};

};

到这里，vector模拟实现就结束了，希望你能有所收获

感谢各位大佬支持并指出问题

​ 如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！

img

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2188578.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【学习资源】人在环路的机器学习

【学习资源】人在环路的机器学习

说明&#xff1a;本文图片和内容来源 Human-in-the-Loop Machine Learning Human-in-the-Loop Machine Learning Active learning and annotation for human-centered AI by Robert (Munro) Monarch, June 2021 介绍Human-in-the-Loop的目标&#xff0c;学习过程&#xff0c…
阅读更多...
Redis：通用命令 数据类型

Redis：通用命令 数据类型

Redis&#xff1a;通用命令 & 数据类型 通用命令SETGETKEYSEXISTSDELEXPIRETTLTYPEFLUSHALL 数据类型 Redis的客户端提供了很多命令用于操控Redis&#xff0c;在Redis中&#xff0c;key的类型都是字符串&#xff0c;而value有多种类型&#xff0c;每种类型都有自己的操作命…
阅读更多...
DMA 正点原子版

DMA 正点原子版

就是介绍一下dma&#xff0c;只能内存到外设&#xff0c;外设到内存&#xff0c;内存到内存&#xff0c;不能外设到外设这样进行数据传输 这个是 可以看这个表来查&#xff0c;哪个dma的哪个通道用来传输什么数据&#xff0c;这个是芯片固定好的&#xff0c;只能看表查&#xf…
阅读更多...
Geogebra基础篇002—关于Geogebra软件的介绍及与MatLab的区别

Geogebra基础篇002—关于Geogebra软件的介绍及与MatLab的区别

为什么要学Geogebra&#xff1f; 因为和MatLab的科学计算相比&#xff0c;GeoGebra重点突出教学展示&#xff0c;对于教师、学生人群来讲再合适不过了&#xff0c;尤其是可以融入到PPT里边呈现交互式动画&#xff0c;想想听众的表情&#xff01;这不就弥补了看到PPT播放数学公…
阅读更多...
Python+Matplotlib-高等数学上-P7-例如部分可视化

Python+Matplotlib-高等数学上-P7-例如部分可视化

import numpy as np import matplotlib.pyplot as plt# 设置中文字体&#xff0c;确保中文显示正确 plt.rcParams[font.sans-serif] [SimHei] # 用黑体显示中文 plt.rcParams[axes.unicode_minus] False # 正常显示负号# 设置图形和子图 fig, (ax1, ax2) plt.subplots(2, …
阅读更多...
Qt 5开发步骤及实例

Qt 5开发步骤及实例

目录 界面设计编写相应的计算圆面积代码 界面设计 创建桌面应用程序 得到这样一个树形视图 双击界面文件中的dialog.ui 直接双击控件label改名&#xff0c;然后修改最后一个label的属性 修改这个标签的样式&#xff0c;把frameshape改成Panel&#xff0c;frameshadow改…
阅读更多...
LC刷题专题：二叉树；迭代；递归（897、1372、208）

LC刷题专题：二叉树；迭代；递归（897、1372、208）

文章目录 897.递增顺序搜索树1372. 二叉树中的最长交错路径208. 实现 Trie (前缀树) 897.递增顺序搜索树 https://leetcode.cn/problems/increasing-order-search-tree/description/ 这道题目本身就是一个简单题&#xff1a;非常容易实现&#xff1a;只需要在递归或者迭代中序…
阅读更多...
【Java的SPI机制】Java SPI机制：实现灵活的服务扩展

【Java的SPI机制】Java SPI机制：实现灵活的服务扩展

在Java开发中&#xff0c;SPI&#xff08;Service Provider Interface&#xff0c;服务提供者接口&#xff09;机制是一种重要的设计模式&#xff0c;它允许在运行时动态地插入或更换组件实现&#xff0c;从而实现框架或库的扩展点。本文将深入浅出地介绍Java SPI机制&#xff…
阅读更多...
【Godot4.3】复合路径类myPath

【Godot4.3】复合路径类myPath

概述 之前编写过一个基于指令绘图的类交myPoint&#xff0c;但是只涉及折线段生成。这次我基于SVG的<path>标签路径指令的启发&#xff0c;实现了一个能够获得连续绘制的直线段、圆弧和贝塞尔复合路径的类型myPath。 可以使用绘图指令方法或字符串形式的绘图指令解析来…
阅读更多...
hbuilderx+uniapp+Android宠物用品商城领养服务系统的设计与实现 微信小程序沙箱支付

hbuilderx+uniapp+Android宠物用品商城领养服务系统的设计与实现 微信小程序沙箱支付

目录 项目介绍支持以下技术栈&#xff1a;具体实现截图HBuilderXuniappmysql数据库与主流编程语言java类核心代码部分展示登录的业务流程的顺序是&#xff1a;数据库设计性能分析操作可行性技术可行性系统安全性数据完整性软件测试详细视频演示源码获取方式 项目介绍 顾客 领养…
阅读更多...
OpenCAEPoro优化（1）

OpenCAEPoro优化（1）

核心目的&#xff1a;减少运行时的 object time 方法一&#xff1a;改变运行的进程数 进入OpenCAEPoro目录下运行下述代码&#xff08;进程数为4&#xff09; mpirun -np 4 ./testOpenCAEPoro ./data/case1/case1.data verbose1结果如下 可以看到&#xff0c;object time是…
阅读更多...
日常工作记录：服务器被攻击导致chattr: command not found

日常工作记录：服务器被攻击导致chattr: command not found

在深夜的寂静中&#xff0c;公司的服务器突然遭遇了一场突如其来的攻击。特别是nginx配置文件无法修改&#xff0c;仿佛预示着不祥的预兆&#xff0c;面对这突如其来的灾难&#xff0c;技术人员迅速响应。 这时候需要chattr&#xff0c;但是执行的chattr -i xxx的时候&#xf…
阅读更多...
神经网络激活函数之前的加权求和 ｜ 矩阵相乘运算法则（清晰版）

神经网络激活函数之前的加权求和 ｜ 矩阵相乘运算法则（清晰版）

1. 神经网络中进行加权求和为什么要将w矩阵进行转置&#xff1f; 下面以一个简单的神经网络作为举例&#xff1a; 我们要将输入特征与W进行加权求和&#xff0c;想要的是下面这种结果&#xff1a; 但是根据矩阵相乘的运算法则&#xff1a; 矩阵A的列数&#xff08;column&am…
阅读更多...
SysML案例-风力发电

SysML案例-风力发电

DDD领域驱动设计批评文集>> 《软件方法》强化自测题集>> 《软件方法》各章合集>>
阅读更多...
攻防世界----＞Newbie_calculations

攻防世界----＞Newbie_calculations

学习笔记。 前言&#xff1a;试过od动态分析&#xff0c; 然后发现&#xff0c;那些函数不完全是混淆&#xff0c;怎么剥离 - - 不会 现在学会了。 参考&#xff1a; xctf-Newbie_calculations - jane_315 - 博客园 (cnblogs.com)https://www.cnblogs.com/jane315/p/1376964…
阅读更多...
111.WEB渗透测试-信息收集-ARL（2）

111.WEB渗透测试-信息收集-ARL（2）

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 内容参考于&#xff1a; 易锦网校会员专享课 上一个内容&#xff1a;110.WEB渗透测试-信息收集-ARL&#xff08;1&#xff09; 2、安装ARL 1、最好先“apt-g…
阅读更多...
创建django项目时，不同的编译类型有什么区别

创建django项目时，不同的编译类型有什么区别

这里主要提及的是 project venv 和 Custom environment 两种类型。 简单来说&#xff0c;project venv 是Python 3.3及以上版本中自带的虚拟环境管理工具&#xff0c;使用venv可以为每个项目创建一个独立的环境&#xff1a;python -m venv myprojectenv &#xff08;项目名后e…
阅读更多...
电梯，建模的常见话题

电梯，建模的常见话题

以下是最近一则"女婿开电梯门导致岳父惨死"的新闻&#xff0c;可惜生命的同时&#xff0c;也引发了一系列联想。 不少人不了解或者了解但经常下意识忽略&#xff1a;电梯的门和轿厢是分离的部件。部件之间的协作如果有失误&#xff0c;系统就会出问题。电梯可以看作是…
阅读更多...
JVM 基础、GC 算法与 JProfiler 监控工具详解

JVM 基础、GC 算法与 JProfiler 监控工具详解

目录 1、引言 1.1 JVM内存与本地内存 1.2 JVM与JDK的关系 2、JVM基础 2.1 JVM&#xff08;Java Virtual Machine&#xff09; 2.2 Java与JVM的关系 2.3 JVM的内存结构 2.3.1 堆内存 2.3.2 栈内存 2.3.3 方法区 2.3.4 本地方法栈 2.3.5 程序计数器&#xff08;PC寄存…
阅读更多...
Python+Matplotlib创建y=sinx、y=cosx、y=sinx+cosx可视化

Python+Matplotlib创建y=sinx、y=cosx、y=sinx+cosx可视化

y sin x (奇函数)&#xff1a; 图像关于原点对称。 对于任何 x&#xff0c;sin(-x) -sin(x)&#xff0c;符合奇函数定义。 y cos x (偶函数)&#xff1a; 图像关于 y 轴对称。 对于任何 x&#xff0c;cos(-x) cos(x)&#xff0c;符合偶函数定义。 y sin x cos x (既…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023