C++ vector的模拟实现

已于 2023-12-12 12:10:35 修改
阅读量66 收藏
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 stl 容器
于 2023-10-10 22:19:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74461263/article/details/133755773
版权

vector结构

    template<class T>
	class vector
	{
	public:
		typedef T* iterator;//typedef 受访问限定符限制
		typedef const T* const_iterator;
	private:
		iterator _start = nullptr;//给缺省值，初始化列表时等就不需要初始化了
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};

vector里的成员变量图解
在这里插入图片描述

vector的迭代器

迭代器分两种：const迭代器和非const迭代器

template<class T>
	class vector
	{
	public:
		typedef T* iterator;//typedef 受访问限定符限制
		typedef const T* const_iterator;

		const_iterator begin()const
		{
			return _start;
		}

		const_iterator end()const	
		{
			return _finish;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}
    }

vector的四个默认成员函数

1.构造函数

<1> 这两种无参的都可以，但是给了成员变量缺省值，我们更偏向于第二个

       vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{}

		vector()
		{}

<2>用迭代器做模板可以用其他各种迭代器

eg: string str(“hello world”);
vector v4(str.begin(), str.end());

template<class InputIteraotr>//用迭代器做模板可以用其他各种迭代器
		vector(InputIteraotr first, InputIteraotr last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

<3>给n个val初始化，用const T& val = T() 是因为你并不知道给的val是什么，int？char？string？
所以直接给匿名对象

		vector(size_t n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		
        vector(int n, const T& val = T())//下面注意里面激讲为什么要函数重载
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

注意：在vector v0(10, 0)时会默认调用<2>,因为相较于<3>的size_t 和 T变化匹配 ，<2>里面的参数反而显得更加匹配int int ，所以会默认去调用<2>, 但是<2>是给迭代器用的，会报错：非法的间接寻址，所以我们给<3>函数重载，让<3>更匹配

2.拷贝构造函数

容器容量设置 + 遍历尾插

		//v2(v1)
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

3.复制运算符重载

现代写法，这里要实现深拷贝, v2 = v1其实是v1去拷贝构造v，然后交换v2和v，便可对v2赋值

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

		}

		//v2 = v1
		vector<T>& operator=(vector<int> tmp)
		{
			swap(tmp);
			return *this;
		}

4.析构函数

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

其他

capacity 和 size

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

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

reserve 和 resize

n>capacity说明reserve不能缩容，只能扩
注意：1.将原空间内容拷贝到新空间，一定要用赋值的深拷贝
2.为什么要提前记录size()，因为如果在下面使用_finish = _start + size()的话，对于
size()里面的_finish - _start，_finish是老空间，_start是新空间，会出大问题。

        void reserve(size_t n)
		{
			if (n > capacity())//扩容才进去
			{
				size_t sz = size();//提前记录size
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);//浅拷贝
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];//赋值深拷贝
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;

				_endofstorage = _start + n;
			}
		}

1.resize可以删数据，需要n和size()比较。
2.小于的话就直接调整_finish的位置
3.大于的话交给reserve调整空间大小，遍历给赋值

		void resize(size_t n,const T& val = T())//匿名对象具有常性)
		{
			if (n <= size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);//让reserve去检查
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

push_back

因为写了reserve函数来调整空间了，所以判断空间是否用完后直接尾插就好了

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				//size_t sz = size();//提前存sz，避免后面因为size引发的指针问题
				//size_t cp = capacity() == 0 ? 4 : capacity() * 2;

				//T* tmp = new T[cp];
				//if (_start)
				//{
				//	memcpy(tmp, _start, sizeof(T) * sz);
				//	delete[] _start;
				//}
				///*_start = tmp;   error
				//_finish = _start + size();*/

				///*_finish = tmp + size();
				//_start = tmp;*/
				//_start = tmp;
				//_finish = _start + sz;
				// 
				//_endofstorage = _start + cp;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = x;
			++_finish;
		}

insert和erase

对于insert和erase导致的迭代器失效问题，在这一篇中你可以看到更详细的分析
有关vector迭代器失效问题

void insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;//迭代器失效第一种：扩容引起的，野指针
				                          //解决办法：提前记录pos和_start的距离
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_finish;
		}

解决erase导致的迭代器失效，返回一个指向下一个位置的迭代器，然后及时更新

		iterator erase(iterator pos)//返回被删除位置的下一个位置
		{
			assert(pos < _finish);
			assert(pos >= _start);

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

			return pos;
		}
		//结论：insert和erase以后迭代器都失效了，不能再访问

运算符重载

重载一个读的一个写的

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

		

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

			return _start[pos];
		}

整体代码

#define _CRT_SECURE_NO_WARNINGS
#include<assert.h>

namespace nzq
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;//typedef 受访问限定符限制
		typedef const T* const_iterator;

		const_iterator begin()const
		{
			return _start;
		}

		const_iterator end()const	
		{
			return _finish;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		/*vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{}*/

		vector()
		{}

		template<class InputIteraotr>//用迭代器做模板可以用其他各种迭代器
		vector(InputIteraotr first, InputIteraotr last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		} 

		vector(size_t n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		/*vector(int n, const T& val = T())
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}*/

		//v2(v1)
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

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

		}

		//v2 = v1
		vector<T>& operator=(vector<int> tmp)
		{
			swap(tmp);
			return *this;
		}

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);//浅拷贝
					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);//让reserve去检查
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

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

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

		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				//size_t sz = size();//提前存sz，避免后面因为size引发的指针问题
				//size_t cp = capacity() == 0 ? 4 : capacity() * 2;

				//T* tmp = new T[cp];
				//if (_start)
				//{
				//	memcpy(tmp, _start, sizeof(T) * sz);
				//	delete[] _start;
				//}
				///*_start = tmp;   error
				//_finish = _start + size();*/

				///*_finish = tmp + size();
				//_start = tmp;*/
				//_start = tmp;
				//_finish = _start + sz;
				// 
				//_endofstorage = _start + cp;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = x;
			++_finish;
		}

		void insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;//迭代器失效第一种：扩容引起的，野指针
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_finish;
		}

		iterator erase(iterator pos)//返回被删除位置的下一个位置
		{
			assert(pos < _finish);
			assert(pos >= _start);

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

			return pos;
		}
		//结论：insert和erase以后迭代器都失效了，不能再访问


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

		

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

			return _start[pos];
		}




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

	void test1()
	{
		vector<int> v;
		//v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		v.push_back(6);
		v.push_back(7);
		v.push_back(8);


		v.insert(v.begin(),1);
		v.insert(v.begin(),0);

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

		vector<int> v1(v);
		vector<int> v2(10, 0);
	}
	
}
niu_sama
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【C++详解】——vector模拟实现
weixin_69519040的博客
11-23 634
本文首先简单介绍了vector，随后模拟实现了vector。 解决了模拟实现过程中，reserve扩容时导致的问题，insert和erase过程中迭代器失效问题，构造函数复用迭代器构造以及构造n个val值时出现的问题，拷贝构造函数中对于自定义类型的处理。
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
C++ vector模拟实现
Wzs040810的博客
01-10 3379
C++ STL vector模拟实现
C++vector模拟实现增删改查
weixin_41368411的博客
04-27 1980
一.成员变量 vector的成员变量有三个，分别是三个类模板参数类型的指针_start，_finish，_endofstorage，它们分别指向vector数组的首个元素，结尾元素的下一个空间，空间末尾。 二.构造函数（默认构造，拷贝构造函数，赋值重载函数，迭代器实现构造函数） vector() :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) {} //使用迭代器完成构造函数，初.
【C++】vector模拟实现
VHhhbb的博客
07-15 907
【C++】vector模拟实现
[C++]vector模拟实现
weixin_52345097的博客
03-05 1086
C++vector模拟实现
【C++】vector 模拟实现
m0_51064412的博客
08-05 1266
文章目录一.vector介绍二. vector的模拟实现1. private成员变量及迭代器2. 容量操作接口2.1 size和capacity2.2 reserve2.2 resize3. 默认成员函数3.1 构造函数3.2 拷贝构造3.3 赋值重载4. 修改操作接口4.1 insert4.2 erase 一.vector介绍 vector是表示可变大小数组的序列容器 就像数组一样，vector也采用连续的存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不
C++vector的模拟实现
weixin_59112191的博客
04-29 1542
文章目录vector框架默认构造函数有参构造函数sizecapacity内置数据类型的构造函数const修饰的匿名对象reserveresize迭代器拷贝构造函数传统写法拷贝构造函数现代写法findinsert迭代器失效erase vector框架 template <class T> class vector { public: T _start;//(1) T _finsih;//(2) T _endofstorge;//(3) };   (1)(1)(1)指向当前空间的第一个
C++入门之vector的模拟实现
cls的博客
03-26 1036
vector源代码的大致框架,vector本质就是一个模板类 vector的成员变量不再是我们熟悉的size，capacity，而是变成了功能一致的三个指针 namespace pxl { template<class T> class vector { public: typedef T* iterator; private: iterator _start; iterator _finish; iterator _endofstora.
【C++】STL——vector模拟实现
M的博客
06-20 1319
vector的模拟实现
C++ vector实现
qq_53558968的博客
07-12 2030
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings.
C++模拟实现vector
03-07
C++模拟实现vector
模拟实现Vector的基本功能
05-26
用c++开发语言，模拟是下std标准库中的Vector基本的功能，复习下Vector标准库的相关知识，特留下此笔记
Vector各个接口模拟实现
08-27
Vector各个接口模拟实现
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 254
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 903
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 619
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
c++模拟实现vector
09-01
- *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值