【C++初阶】vector模拟实现

news2024/9/21 4:37:39

请添加图片描述

✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿
🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟
🌟🌟 追风赶月莫停留 🌟🌟
🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀
🌟🌟 平芜尽处是春山🌟🌟
🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟
🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅

🍋vector模拟实现

  • 🍑默认成员函数
    • 🍍构造函数
    • 🍍拷贝构造函数
    • 🍍析构函数
    • 🍍赋值重载函数
  • 🍑迭代器
  • 🍑增删查改功能实现
    • 🍍增加数据
    • 🍍删除数据
    • 🍍查找数据
    • 🍍改变数据
    • 🍍其它程序
  • 🍑vector模拟整体代码

🍑默认成员函数

🍍构造函数

//默认构造
vector()
{}

//带参构造
vector(size_t x, const T& val = T())
{
	resize(x, val);
}

......

对于带参构造当中，第二个参数，所采用的是匿名对象作为缺省值；因为在这里T的的类型不确定，只能使用匿名对象来修饰。

匿名对象：指的是没有被显式命名（即没有标识符或变量名）的对象实例。这类对象通常在需要临时执行某些操作或作为函数参数/返回值传递时创建，而不需要将结果长期存储于某个变量中。

此处的构造只涉及到浅拷贝，对于深拷贝后面会有介绍。

🍍拷贝构造函数

//拷贝构造(普通写法)
vector(const vector<T>& v)
{
	_start = new T[v.capacity()];
	memcpy(_start, v._start, sizeof(T) * v.size());
	_finish = _start + v.size();
	_endofstorage = _start + v.capacity();
}



//拷贝构造(实用写法)
vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (const auto& in : v)
	{
		push_back(in);
	}
}

//现代写法
vector(vector<T>& v)
{
	vector<T> ret(v.begin(), v.end());
	swap(ret);
}

此处的拷贝构造函数就涉及到深拷贝问题，这里我提供了三种写法。
(1)第一种写法就是普通的写法，相信大家自己来模拟拷贝构造，思路大径相同；这里还用到了memmove()函数， 大家也可以采用while()循环的方式来代替，方法多种多样。
(2)第二种写法就是利用vector的插入完成，不过需要提前开满足够的空间，不然内存会泄露。
(3)第三种写法利用swap的特性。

🍍析构函数

//iterator _start = nullptr;
//iterator _finish = nullptr;
//iterator _endofstorage = nullptr;

~vector()
{
	if(_start)
	{
		delete[] _start;
		_start = nullptr;
		_finish = nullptr;
		_endofstorage = nullptr;
	}
}

析构函数还是常规写法，没有什么特别之处。
_start、_finish、_endofstorage是vector的迭代器。_start是指向头；_finish是数据存储大小的尾;_endofstorage是整个空间大小的尾。

🍍赋值重载函数

//传统写法
vector<T>& operator=(const vector<T>& v)
{
	if (this != &v)
	{
		reserve(v.capacity());
		for (size_t i = 0; i < v.size(); i++)
		{
			_start[i] = v[i];
		}
		_finish = _start + v.size();
	}
	return *this;
}

//优化写法
vector<T>& operator=(vector<T> v)
{
	swap(v);
	return *this;
}

在进行赋值重载操作时，可以先对数据进行对比，如果相同就不用再进行此操作。
赋值重载需要注意的是优化写法中在参数中没有采用引用的写法，swap()函数是把两处的内容完全交换，而我们在这里仅仅只需要赋值，所以我在这里并对v采用引用的写法，如果对v采用引用的写法可能会把原有的v中数据破坏，未被引用的v仅仅只是原来v中数据的拷贝，虽然它俩名字相同，但作用域不同。

🍑迭代器

无论是范围for还是方括号进行遍历，底层原理都是迭代器,迭代器有两种版本，有const版本和非const版本；迭代器写法还是直接调用子函数进行实现。

iterator begin()
{
	return _start;
}
iterator end()
{
	return _finish;
}

const_iterator begin() const
{
	return _start;
}
const_iterator end() const
{
	return _finish;
}

🍑增删查改功能实现

🍍增加数据

  1. reserve()函数是扩容函数，capacity()函数是算出实际空间的大小，还额外使用了memcpy()函数进行了拷贝，这里之所以扩容在if条件下进行，是因为我们不仅仅是在插入数据的时候才用到扩容函数，比如赋值等等。
    这里还有一点需要注意，需要在_start空间释放前把实际数据的长度先保存，在这实际长度的计算是采用_finish-_start的长度，当我们已经释放_start，再次使用size()函数时，_start和_finish不在同一个物理量上，程序会报错，如下图：

在这里插入图片描述

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t len = size();
		T* tem = new T[n];
		if (_start)
		{
			memcpy(tem, _start, len * sizeof(T));
			delete[] _start;
		}

		_start = tem;
		_finish = _start + len;
		_endofstorage = _start + n;
	}
}
  1. push_back()是尾插函数的实现，开头还是得先判断空间是否溢出再进行判断；_finish是实际数据大小的尾，_endofstorage是空间实际的大小，当这两者相等，空间就会溢出。reserve()函数是扩容函数。
void push_back(const T& x)
{
	if (_finish == _endofstorage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}

	*_finish = x;
	_finish++;
}
  1. Insert()函数是插入函数，在pos位置插入新的数据，还使用了memmove()函数进行了数据的移动，当然也可以使用while()和for()这两个也可以，看大家对那个熟悉就用那个。
    首先还是要先对pos位置进行判断，防止提供的pos位置有误；再用_finish与_endofstorage进行对比来判断空间是否溢出,是否需要扩容；最后再把pos位置往后的整体数据往后移一步，把新的数据插入pos位置即可。
void Insert(iterator pos, const T& x)
{
	assert(pos >= _start && pos <= _finish);
	if (_finish == _endofstorage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		pos = _start + len;
	}

	memmove(pos + 1, pos, (_finish - pos) * sizeof(T));
	*pos = x;
	++_finish;
}

🍍删除数据

  1. erase()函数是删除数据的函数。首先还是对题目提供的pos进行判断，我在这里就没有采用memmove()函数进行数据的移动，还是因为memmove()函数在删除末尾数据时有点问题，最后我还是采用while()循环来实现数据的移动。
void erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);

	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;
		++it;
	}
	--_finish;

}
  1. pop_back()函数是尾删数据的函数，实现方式也是直接把_finish减一个数就可以，主要还是_finish是指向该数据的尾.
void pop_back()
{
	assert(size() > 0);
	--_finish;
}

🍍查找数据

  1. Find()函数是查找数据。实现方式也是利用迭代器进行遍历查找。
bool Find(T x)
{
	iterator pos = _start;

	while (pos <= _finish)
	{
		if (*pos == x) return true;
		++pos;
	}
	return false;
}

🍍改变数据

  1. resize()函数是利用空间的性质对数据进行扩容和删除，也就是它既具有扩容的功能，又有删除的功能，还有增加数据的功能，只不过增加的是默认值0。

    参数中的T由于不确定类型所以采用的是匿名对象的缺省参数。该函数大家可以很少用到，下面是程序运行图：

在这里插入图片描述

void resize(size_t n, T val = T())//匿名对象的缺省值
{
	if (n > size())
	{
		reserve(n);
		while (_finish < _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
	else
	{
		_finish = _start + n;
	}
}

🍍其它程序

  1. size()函数是计算实际数据大小，capacity()函数是计算实际空间的大小，当实际数据大小等于实际空间的大小，该空间就满了，再往里插入新数据，空间就会溢出。
size_t size() const
{
	return _finish - _start;
}

size_t capacity() const
{
	return _endofstorage - _start;
}
  1. operator函数是方便该类数据可以使用方括号进行遍历，也就是数组的方式进行遍历。也是有两个版本，一个是const类，另一个是非const类。
T& operator[](const T& pos)
{
	assert(pos < size());
	return _start[pos];
}

const T& operator[](const T& pos) const
{
	assert(pos < size());
	return _start[pos];
}

🍑vector模拟整体代码

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

using namespace std;



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

		vector()
		{}


		//拷贝构造(普通写法)
		/*vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			memcpy(_start, v._start, sizeof(T) * v.size());
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
		}*/

		//拷贝构造(实用写法)
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (const auto& in : v)
			{
				push_back(in);
			}
		}

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

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

		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endofstorage = nullptr;
			}
		}

		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t len = size();
				T* tem = new T[n];
				if (_start)
				{
					memcpy(tem, _start, len * sizeof(T));
					delete[] _start;
				}
		
				_start = tem;
				_finish = _start + len;
				_endofstorage = _start + n;
			}
		}

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}

			*_finish = x;
			_finish++;
		}

		void pop_back()
		{
			assert(size() > 0);
			--_finish;
		}

		void Insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}

			memmove(pos + 1, pos, (_finish - pos) * sizeof(T));
			*pos = x;
			++_finish;
		}

		void erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			//memmove(pos, pos + 1, sizeof(T) * (_finish - pos));
			//--_finish;

			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;

		}

		bool Find(T x)
		{
			iterator pos = _start;

			while (pos <= _finish)
			{
				if (*pos == x) return true;
				++pos;
			}
			return false;
		}

		void resize(size_t n, T val = T())//匿名对象的缺省值
		{
			if (n > size())
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

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

		size_t capacity() const
		{
			return _endofstorage - _start;
		}

		T& operator[](const T& pos)
		{
			assert(pos < size());
			return _start[pos];
		}

		const T& operator[](const T& pos) const
		{
			assert(pos < size());
			return _start[pos];
		}

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};

	void print_vector(const vector<int>& v)
	{
		for (auto in : v)
		{
			cout << in << " ";
		}
		cout << endl;
	}

	void test_vector1()
	{
		vector<int> vv;
		vv.push_back(1);
		vv.push_back(2);
		vv.push_back(3);
		vv.push_back(4);
		vv.push_back(4);
		vv.push_back(4);
		vv.push_back(4);
		vv.push_back(4);

		vector<int>::iterator it = vv.begin();
		while (it != vv.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
		
		vv.erase(vv.end());

		for (auto in : vv)
		{
			cout << in << " ";
		}
		cout << endl;

		for (size_t i = 0; i < vv.size(); i++)
		{
			cout << vv[i] << " ";
		}
		cout << endl;
		
		vv.Insert(vv.begin(), 100);
		print_vector(vv);

		vector<int> v2;
		v2.push_back(100);
		v2.push_back(120);
		v2.push_back(130);
		v2.push_back(140);

		vv = v2;

		for (size_t i = 0; i < vv.size(); i++)
		{
			cout << vv[i] << " ";
		}
		cout << endl;
	}

	void test_vector2()
	{
		vector<int> v1;
		v1.push_back(100);
		v1.push_back(110);
		v1.push_back(120);
		v1.push_back(130);
		v1.push_back(140);
		v1.push_back(150);
		v1.push_back(160);
		v1.push_back(170);
		v1.push_back(180);
		v1.push_back(190);
		v1.push_back(200);

		cout << "原有数据:";
		for (size_t i = 0; i < v1.size(); i++)
		{
			cout << v1[i] << " ";
		}
		cout << endl;

		v1.resize(15);

		cout << "resize(15)空间变大后的数据:";
		for (size_t i = 0; i < v1.size(); i++)
		{
			cout << v1[i] << " ";
		}
		cout << endl;


		v1.resize(8);

		cout << "resize(8),空间变小的数据:";
		for (size_t i = 0; i < v1.size(); i++)
		{
			cout << v1[i] << " ";
		}
		cout << endl;


		

	}


}


int main()
{
	ciking::test_vector2();

	return 0;
}

关于本章知识点如果有不足或者遗漏，欢迎大家指正，谢谢！！！

请添加图片描述

请添加图片描述

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

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

相关文章

什么是全国特价电影票api？接口如何对接？

什么是全国特价电影票api？接口如何对接？

一、全国特价电影票接口对接的基本情况 接口包含信息&#xff1a;电影票API接口中包含影院、影厅、座位、影片、场次、日期及票价等信息。市场需求背景&#xff1a;随着我国电影消费市场的火爆&#xff0c;观影人数增多&#xff0c;除了猫眼、淘票票等平台&#xff0c;各大平台…
阅读更多...
SLA 概念和计算方法

SLA 概念和计算方法

SLA 概念和计算方法 SLA SLA&#xff1a;服务等级协议&#xff08;简称&#xff1a;SLA&#xff0c;全称&#xff1a;service level agreement&#xff09; 网站服务可用性的一个保证 9越多代表全年服务可用时间越长服务更可靠&#xff0c;停机时间越短&#xff0c;反之亦然…
阅读更多...
简单题66-加一（Python）20240918

简单题66-加一（Python）20240918

问题描述&#xff1a; python class Solution(object):def plusOne(self, digits):""":type digits: List[int]:rtype: List[int]"""n len(digits)# 从最后一位开始处理进位for i in range(n - 1, -1, -1):if digits[i] < 9:digits[i] 1re…
阅读更多...
xmos 编程指南

xmos 编程指南

并行执行 并行执行时使用par {} 进行并行处理 点灯 #include <stdio.h> #include<xs1.h> #include<timer.h> #include<platform.h>port p XS1_PORT_8C;void hw(unsigned n) { printf("Hello world from task number %u\n", n); } int ma…
阅读更多...
多线程---线程的状态及常用方法

多线程---线程的状态及常用方法

1. 线程的状态 在Java程序中&#xff0c;一个线程对象通过调用start()方法启动线程&#xff0c;并且在线程获取CPU时&#xff0c;自动执行run()方法。run()方法执行完毕&#xff0c;代表线程的生命周期结束。 在整个线程的生命周期中&#xff0c;线程的状态有以下六种&#xff…
阅读更多...
文件翻译英文是什么软件？5款软件评测助你决策

文件翻译英文是什么软件？5款软件评测助你决策

在企业的日常运营中&#xff0c;文件翻译格式的多样性常常成为沟通效率的瓶颈。 从简单的文本文件到复杂的PDF文档&#xff0c;每一种格式都可能因为其特有的结构和布局&#xff0c;给翻译工作带来额外的挑战。 掌握翻译技巧需要时间和实践&#xff0c;以下是一些实用的翻译技…
阅读更多...
数据增强又突破了！升级版“双杀”两大顶会，实现无痛涨点

数据增强又突破了！升级版“双杀”两大顶会，实现无痛涨点

数据收集和标注的艰难想必大家都有所体会&#xff0c;不仅耗时耗力还很贵&#xff0c;一般人顶不住。那怎么解决&#xff1f;你的“强”&#xff08;数据增强&#xff09;来了~ 数据增强作为一种正则化技术&#xff0c;可以帮助我们在有限的数据下&#xff0c;提高模型的性能。…
阅读更多...
Vue.js魔法书：前端开发者的终极指南----指令篇续篇

Vue.js魔法书：前端开发者的终极指南----指令篇续篇

​个人名片&#xff1a; &#x1f60a;作者简介&#xff1a;一个为了让更多人看见许舒雅的宝贝的小白先生 &#x1f921;个人主页&#xff1a;&#x1f517; 许舒雅的宝贝 &#x1f43c;座右铭&#xff1a;深夜两点半的夜灯依旧闪烁&#xff0c;凌晨四点的闹钟不止你一个。 &am…
阅读更多...
linux 操作系统下的dhclient命令介绍和案例使用

linux 操作系统下的dhclient命令介绍和案例使用

linux 操作系统下的dhclient命令介绍和案例使用 dhclient 是 Linux 系统中用于动态主机配置协议&#xff08;DHCP&#xff09;客户端的命令。它的主要功能是从 DHCP 服务器获取网络配置&#xff0c;包括 IP 地址、子网掩码、默认网关和 DNS 服务器等信息 dhclient 命令概述 …
阅读更多...
如何使用ssm实现校园二手交易平台的设计与开发+vue

如何使用ssm实现校园二手交易平台的设计与开发+vue

TOC ssm641校园二手交易平台的设计与开发vue 研究背景与现状 时代的进步使人们的生活实现了部分自动化&#xff0c;由最初的全手动办公已转向手动自动相结合的方式。比如各种办公系统、智能电子电器的出现&#xff0c;都为人们生活的享受提供帮助。采用新型的自动化方式可以…
阅读更多...
速通汇编（六）认识栈，SS、SP寄存器，push和pop指令的作用

速通汇编（六）认识栈，SS、SP寄存器，push和pop指令的作用

一&#xff0c;栈 &#xff08;一&#xff09;栈的特点 栈是一种具有特殊访问方式的存储空间&#xff0c;特殊在于&#xff0c;进出这块存储空间的数据&#xff0c;“先进后出&#xff0c;后进先出” 由于栈的这个“先进后出”的特点&#xff0c;我们可以利用其来很好的操作内…
阅读更多...
传输层协议 —— TCP协议（上篇）

传输层协议 —— TCP协议（上篇）

目录 1.认识TCP 2.TCP协议段格式 3.可靠性保证的机制 确认应答机制 超时重传机制 连接管理机制 三次握手 四次挥手 1.认识TCP 在网络通信模型中&#xff0c;传输层有两个经典的协议&#xff0c;分别是UDP协议和TCP协议。其中TCP协议全称为传输控制协议&#xff08;Tra…
阅读更多...
Java毕业设计 基于SpringBoot和Vue自习室管理系统

Java毕业设计 基于SpringBoot和Vue自习室管理系统

Java毕业设计 基于SpringBoot和Vue自习室管理系统 这篇博文将介绍一个基于SpringBoot框架和Vue开发的自习室管理系统&#xff0c;适合用于Java毕业设计。 功能介绍 学生　登录 个人中心 修改密码 系统首页　自习室浏览　学生预约记录 管理员　 登录 个人中心 修改密码 系统…
阅读更多...
零信任安全架构--持续验证

零信任安全架构--持续验证

随着网络安全威胁的不断演变&#xff0c;传统的“信任但验证”安全模式已无法应对现代复杂的攻击。零信任安全架构&#xff08;Zero Trust Architecture, ZTA&#xff09;应运而生&#xff0c;作为一种全新的安全理念&#xff0c;它彻底改变了企业的网络安全防护方式。核心思想…
阅读更多...
file的判断和获取，创建和删除

file的判断和获取，创建和删除

常见成员方法 1.length 返回文件的大小(字节数量) 细节1:这个方法只能获取文件的大小&#xff0c;单位是字节如果单位我们要是M&#xff0c;G&#xff0c;可以不断的除以1024 细节2:这个方法无法获取文件夹的大小如果我们要获取一个文件夹的大小&#xff0c;需要把这个文件夹…
阅读更多...
项目管理系统的期限提醒功能如何确保项目按时推进？

项目管理系统的期限提醒功能如何确保项目按时推进？

在竞争激烈的项目申报垂直领域&#xff0c;时间就是效率&#xff0c;效率关乎成败。每一个申报项目的截止日期都是一道不容错过的关卡&#xff0c;错过即意味着失去了宝贵的机会。为了确保项目能够按时推进&#xff0c;避免因时间管理不当而导致的延误&#xff0c;项目管理系统…
阅读更多...
SpringCloud系列之一---搭建高可用的Eureka注册中心

SpringCloud系列之一---搭建高可用的Eureka注册中心

前言 本篇文章主要介绍的是SpringCloud相关知识、微服务架构以及搭建服务注册与发现的服务模块(Eureka)以及Eureka集群。 GitHub源码链接位于文章底部。 什么是SpringCloud Spring Cloud 是一系列框架的有序集合。 它利用 Spring Boot 的开发便利性巧妙地简化了分布式系统基础设…
阅读更多...
如何使用ssm实现基于web的物流配送管理系统的设计与实现+vue

如何使用ssm实现基于web的物流配送管理系统的设计与实现+vue

TOC ssm646基于web的物流配送管理系统的设计与实现vue 第一章 绪论 1.1研究背景与意义 在科学技术水平还比较低下的时期&#xff0c;企业通常采用人工登记的方式对相关的物流配送信息进行记录&#xff0c;而后对这些信息记录进行管理和控制。这种采用纸质存储信息的管理模式…
阅读更多...
平安养老险广东分公司：防范非法集资，守护消费者“钱袋子”

平安养老险广东分公司：防范非法集资，守护消费者“钱袋子”

随着经济的不断发展&#xff0c;非法集资犯罪案件频频发生。非法集资案件受害人多&#xff0c;涉及资金广&#xff0c;犯罪手段多元化&#xff0c;涉案财物追缴困难等等。为提升金融消费者风险防范意识&#xff0c;保障其合法经济利益&#xff0c;今天我们一起来学习防范非法集…
阅读更多...
利用条件编译解决vivado下verilog代码中ila与仿真的共存问题

利用条件编译解决vivado下verilog代码中ila与仿真的共存问题

vivado自带的仿真工具已经接近Modelsim的功能&#xff0c;且与原生开发环境的紧密结合&#xff0c;对仿真非常方便。 我的习惯是在实现工程中另外建一个仿真工程&#xff0c;保存仿真的testbench文件等&#xff0c;而实现工程中保存实际功能的源码文件。 这样仿真时会存在一个问…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023