vector【2】模拟实现（超详解哦）

vector

  • 引言（实现概述）
  • 接口实现详解
    • 默认成员函数
      • 构造函数
      • 析构函数
      • 赋值重载
    • 迭代器
    • 容量
      • size与capacity
      • reserve
      • resize
      • empty
    • 元素访问
    • 数据修改
      • insert
      • erase
      • push_back与pop_back
      • swap
  • 模拟实现源码概览
  • 总结

引言（实现概述）

在前面，我们介绍了vector的使用：
戳我康vector介绍与使用

在本篇文章中将重点介绍vector的接口实现，通过模拟实现可以更深入的理解与使用vector。
在这里插入图片描述

我们可以在网上搜索到vector的实现源码， 与string中使用一个指针指向存储数据的空间，两个整型来刻画size与capacity不同，vector中是通过三个迭代器 _start、_finish、_endOfStorage分别指向数据块的起始位置、有效数据末尾的下一个位置、存储容量末尾的下一个位置来管理数据的。vector中迭代器就是原生指针，本质上就是使用三个指针来管理动态申请的存储数据的空间。

在这里插入图片描述

vector是一个类模板，其声明与定义不能分离。我们将模拟实现的vector放在我们创建的命名空间内，以防止与库发生命名冲突。

在vector的模拟实现中，我们只实现一些主要的接口，包括默认成员函数、迭代器、容量、元素访问与数据修改：

接口实现详解

默认成员函数

构造函数

构造函数的模拟实现包括无参构造、n个指定元素构造、迭代器区间构造与拷贝构造：

无参构造：即首先在初始化列表中，将三个属性全部初始化为空指针即可：

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

n个指定元素构造：

这个重载版本有两个参数，第一个是int，第二个是const T&，表示用n个value构造vector，第二个参数缺省值为其默认构造T()

首先new一块大小为n个元素大小的空间，将其赋值给_start；
然后_finish的值就是_start + n， _endOfStorage的值与_finish相同；
最后for循环将n个value写入空间中：

    vector(int n, const T& value = T())   //{_start = new T[n];_finish = _start + n;_endOfStorage = _finish;for (int i = 0; i < n; ++i){*(_start + i) = value;}}

迭代器区间构造：

使用迭代器区间的构造，是一个函数模板，即可以使用其他容器的迭代器区间来构造vector。

这个重载版本的实现有许多方式，这里的实现是偷懒版本的，即首先将三个属性初始化为空指针后，再复用push_back（后面实现）来将迭代器区间中的元素尾插到新vector中：

    template<class InputIterator>vector(InputIterator first, InputIterator last): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){while (first < last){push_back(*first);++first;}}

拷贝构造：

拷贝构造时，首先将三个属性都初始化为空指针；
然后使用reserve（后面会实现）将新vector扩容与原vector一致；
最后循环将原vector中的数据拷贝到新vector中即可：

    vector(const vector<T>& v): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){int sz = v.size();reserve(sz);for (int i = 0; i < sz; ++i){*(_start + i) = v[i];}}

析构函数

析构函数即释放动态申请的资源，即delete[] _start即可，同时可以顺便将三个属性均置空：

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

赋值重载

在实现赋值运算符重载时，存在深浅拷贝的问题，为了简便我们使用现代版本：

现代版本的参数类型为vector<T>，而不是引用，这就使得vector对象在传参时会生成一个临时对象，我们将这个临时对象与要替换的对象*this互换，就实现了将一个对象赋值到了*this，最后返回*this即可，临时对象会在函数栈帧销毁时析构（swap后面实现）。

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

迭代器

vector的迭代器本质上就是原生指针，所以我们只需要将T* 重命名为iterator即可实现迭代器，并且具有原生指针的++、--、+、-、指针相减等的属性：

	typedef T* iterator;typedef const T* const_iterator;

与string部分相同，我们暂时只实现begin与end，关于反向迭代器的实现在后面会详细介绍。
begin返回首元素的地址，end返回尾元素下一个位置的地址，他们分别重载有const版本：

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

容量

size与capacity

之前讲到vector迭代器的底层是原生指针，支持指针减指针的操作。
对于size即元素的个数，_finish - _start的值即空间中数据的末尾的下一个位置的指针减首元素位置的指针，即元素个数；
对于capacity即容量的大小，_endOfStorage - _start的值即空间末尾下一个位置的指针减首元素位置的指针，即容量大小：

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

reserve

reserve用于扩容
对于C++而言，使用new扩容时，必须进行重新开辟空间，将原空间中的元素转移至新空间，最后释放原空间的操作。这样的过程将是十分影响效率的：

在库实现中，当传参的n大于原容量时，reserve会实现扩容，小于原容量时，reserve不进行缩容操作。所以我们模拟实现时，先判断n是否大于原容量，当大于原容量时在再进行后续操作；
首先new一块大小为n个元素大小的空间；
然后就需要挪动数据，需要注意的是，不能使用memcpy来拷贝数据到新空间中，因为memcpy是逐字节拷贝，而自定义类型是会有动态申请的资源的，这样在释放原空间时就会使新空间中的属性为野指针，当生命周期结束时释放资源时就会释放野指针从而崩溃。所以我们需要调用operator=逐一拷贝数据到新空间中，并释放原空间；
最后令_start指向新空间的首元素，_finish指向数据的结尾（可以在释放前记录size的值，此时加上即可），_endOfStorage指向空间的结尾，即_start + n：

 void reserve(size_t n){if (n > capacity()){T* temp = new T[n];int sz = size();if (sz != 0){ //当T为自定义类型时，memcpy为浅拷贝，temp中的自定义类型的数据与*this是相同的，delete调析构释放原空间就会使temp中数据为野指针//memcpy(temp, cbegin(), sizeof(T) * size()); for (size_t i = 0; i < size(); ++i){*(temp + i) = *(_start + i);}delete[] _start;}_start = temp;_finish = _start + sz;_endOfStorage = _start + n;}}

resize

resize用于改变元素个数
当n小于元素个数时，删除多于的元素；n大于元素个数时，使用指定的元素value补足（value为缺省参数，缺省值为T()）

首先判断n是否大于元素个数，当大于元素个数时还需要进一步判断n是否大于容量需要扩容；
之后逐一用value补足，这里同样需要是用operator=，来避免浅拷贝带来的问题，并调整_finish的指向；
当小于元素个数时，直接将_finish的值调整为_start + n即可：

    void resize(size_t n, const T& value = T()){if (n > size()){if (n > capacity()){reserve(n);}int oldSize = size();_finish = _start + n;for (size_t i = oldSize; i < n; ++i){*(_start + i) = value;}}else{_finish = _start + n;}}

empty

empty用于判断vector是否为空，为空返回true，否则返回false。这里复用size即可，当size返回0时即为空：

    bool empty(){if (size() == 0){return true;}return false;}

元素访问

元素访问即实现operator[]，可以实现通过下标访问元素：
有两个重载版本即普通对象与const对象。

首先判断pos是否越界，因为pos为无符号整型，所以只需要判断_start + pos 是否小于 _finish即可；
然后直接返回_start + pos的解引用即可：

    T& operator[](size_t pos){assert(_start + pos < _finish);return *(_start + pos);}const T& operator[](size_t pos) const{assert(_start + pos < _finish);return *(_start + pos);}

数据修改

insert

insert用于在pos位置插入数据，模拟实现insert时，我们只实现在pos位置（迭代器）插入一个元素的情况：

首先判断pos是否越界，没有越界时还需要再判断是否需要扩容；
这里就存在一个问题，在上一篇文章提到了迭代器失效的问题：扩容后，指向原来空间的迭代器pos就会成为野指针而失效。为解决这个问题，我们可以事先计算pos对于_start的相对位置sz，从而在释放原空间后通过这个相对位置在新空间中重新找到pos，即_start + sz；
然后就可以循环将pos位置及以后的元素逐一向后移动一个元素。这个过程是十分影响效率的；
最后将要插入的元素放在pos位置，并++_finish：

  	iterator insert(iterator pos, const T& x) //pos传参，在reserve后会出现迭代器失效{assert(pos >= _start && pos <= _finish);int sz = pos - _start;  if (size() >= capacity()){reserve(capacity() == 0 ? 10 : capacity() * 2);pos = _start + sz;  //解决迭代器失效}vector<T>::iterator it = end() - 1;while (it >= pos){*(it + 1) = *it;--it;}*pos = x;++_finish;return _start;}

erase

erase用于删除一段数据，这里只模拟实现删除pos位置（迭代器）的一个元素：

首先判断pos是否越界，如果没有越界再判断容器是否为空，为空就直接返回_start；
然后循环将pos后面的元素逐一向前移动一个元素（从后向前覆盖）；
最后--_finish，并返回_start：

    iterator erase(iterator pos){assert(pos >= _start && pos < _finish);if (empty()){return _start;}vector<T>::iterator it = pos + 1;while (it < _endOfStorage){*(it - 1) = *it;++it;}--_finish;return _start;}

push_back与pop_back

由于在任意位置插入与删除十分影响效率，头插与头删更甚，所以库中只提供了尾插与尾删的接口，不用挪动数据使得其效率很高：

模拟实现时其实只需要调用上面实现的insert与erase即可：
push_back即在end()的位置插入一个元素x；
pop_back即在end() - 1的位置删除一个元素：

    void push_back(const T& x){insert(end(), x);}void pop_back(){erase(end() - 1);}

swap

swap函数用于交换两个对象的数据：

使用算法库中的swap通过创建临时变量交换的话，就会发生多次深拷贝，十分影响效率。
对于vector对象的交换，只需要逐一交换他们的三个属性即可：

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

模拟实现源码概览

（关于反向迭代器的实现在后面会详细介绍，现在可以暂时忽略）

#include<iostream>
#include<cassert>
#include"my_reverse_iterator.h"namespace qqq
{template<class T>class vector{public:/ iterator /////vector的迭代器是一个原生指针 typedef T* iterator;typedef const T* const_iterator;typedef ReverseIterator<iterator, T&, T*> reverse_iterator;typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;iterator begin(){return _start;}iterator end(){return _finish;}const_iterator cbegin() const{return _start;}const_iterator cend() const{return _finish;}reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}/// construct and destroy //vector(): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){}vector(int n, const T& value = T())   //{_start = new T[n];_finish = _start + n;_endOfStorage = _finish;for (int i = 0; i < n; ++i){*(_start + i) = value;}}template<class InputIterator>vector(InputIterator first, InputIterator last): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){while (first < last){push_back(*first);++first;}}//vector(const vector<T>& v)//{//    _start = new T[v.size()];//    _finish = _start + v.size();//    _endOfStorage = _start + v.capacity();// //    memcpy(begin(), v.cbegin(), sizeof(T) * v.size());//}vector(const vector<T>& v): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){int sz = v.size();reserve(sz);for (int i = 0; i < sz; ++i){*(_start + i) = v[i];}}vector<T>& operator= (vector<T> v){swap(v);return *this;}~vector(){if (_start != nullptr){delete[] _start;_start = _finish = _endOfStorage = nullptr;}} capacity ///size_t size() const{return _finish - _start;}size_t capacity() const{return _endOfStorage - _start;}bool empty(){if (size() == 0){return true;}return false;}void reserve(size_t n){if (n > capacity()){T* temp = new T[n];int sz = size();if (sz != 0){ //当T为自定义类型时，memcpy为浅拷贝，temp中的自定义类型的数据与*this是相同的，delete调析构释放原空间就会使temp中数据为野指针//memcpy(temp, cbegin(), sizeof(T) * size()); for (size_t i = 0; i < size(); ++i){*(temp + i) = *(_start + i);}delete[] _start;}_start = temp;_finish = _start + sz;_endOfStorage = _start + n;}}void resize(size_t n, const T& value = T()){if (n > size()){if (n > capacity()){reserve(n);}int oldSize = size();_finish = _start + n;for (size_t i = oldSize; i < n; ++i){*(_start + i) = value;}}else{_finish = _start + n;}}///accessT& operator[](size_t pos){assert(_start + pos < _finish);return *(_start + pos);}const T& operator[](size_t pos) const{assert(_start + pos < _finish);return *(_start + pos);}///modify/void push_back(const T& x){insert(end(), x);}void pop_back(){erase(end() - 1);}void swap(vector<T>& v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_endOfStorage, v._endOfStorage);}iterator insert(iterator pos, const T& x)//pos传参，在reserve后会出现迭代器失效{assert(pos >= _start && pos <= _finish);int sz = pos - _start;  if (size() >= capacity()){reserve(capacity() == 0 ? 10 : capacity() * 2);pos = _start + sz;  //解决迭代器失效}vector<T>::iterator it = end() - 1;while (it >= pos){*(it + 1) = *it;--it;}*pos = x;++_finish;return _start;}iterator erase(iterator pos){assert(pos >= _start && pos < _finish);if (empty()){return _start;}vector<T>::iterator it = pos + 1;while (it < _endOfStorage){*(it - 1) = *it;++it;}--_finish;return _start;}private:iterator _start;        // 指向数据块的开始iterator _finish;       // 指向有效数据的尾iterator _endOfStorage; // 指向存储容量的尾};
}

总结

到此，关于vector的主要接口实现就结束了
相信通过接口的模拟实现可以使我们更深入的了解vector
关于STL容器的介绍才刚刚开始，欢迎大家持续关注哦

如果大家认为我对某一部分没有介绍清楚或者某一部分出了问题，欢迎大家在评论区提出

如果本文对你有帮助，希望一键三连哦

希望与大家共同进步哦

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

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

相关文章

分布式定时任务系列5：XXL-job中blockingQueue的应用

分布式定时任务系列5：XXL-job中blockingQueue的应用

传送门 分布式定时任务系列1&#xff1a;XXL-job安装 分布式定时任务系列2&#xff1a;XXL-job使用 分布式定时任务系列3&#xff1a;任务执行引擎设计 分布式定时任务系列4&#xff1a;任务执行引擎设计续 Java并发编程实战1&#xff1a;java中的阻塞队列 引子 这篇文章的…
阅读更多...
MATLAB计算一组坐标点的相互距离（pdist、squareform、pdist2函数）

MATLAB计算一组坐标点的相互距离（pdist、squareform、pdist2函数）

如果有一组坐标P(X,Y)&#xff0c;包含多个点的X和Y坐标&#xff0c;计算其坐标点之间的相互距离 一、坐标点 P[1 1;5 2;3 6;8 8;4 5;5 1; 6 9];二、pdist函数 输出的结果是一维数组&#xff0c;获得任意两个坐标之间的距离&#xff0c;但没有对应关系 Dpdist(P)三、square…
阅读更多...
JavaWeb-Servlet服务连接器(二)

JavaWeb-Servlet服务连接器(二)

目录 Request&#xff08;获取请求信息&#xff09; 1.获取请求行内容 2.解决乱码问题 3.获取请求头部分 4.获取请求体 5.其他功能 Request&#xff08;获取请求信息&#xff09; 工作流程&#xff1a; 1.通过请求的url的资源路径&#xff0c;tomcat会生成相应的Servlet实…
阅读更多...
【单片机】DS2431，STM32，EEPROM读取与写入

【单片机】DS2431，STM32，EEPROM读取与写入

芯片介绍&#xff1a; https://qq742971636.blog.csdn.net/article/details/132164189 接线 串口结果&#xff1a; 部分代码&#xff1a; #include "sys.h" #include "DS2431.h"unsigned char serialNb[8]; unsigned char write_data[128]; unsigned cha…
阅读更多...
STM32入门学习之定时器输入捕获

STM32入门学习之定时器输入捕获

1.定时器的输入捕获可以用来测量脉冲宽度或者测量频率。输入捕获的原理图如下&#xff1a; 假设定时器是向上计数。在图中&#xff0c;t1~t2之间的便是我们要测量的高电平的时间(脉冲宽度)。首先&#xff0c;设置定时器为上升沿捕获&#xff0c;如此一来&#xff0c;在t1时刻可…
阅读更多...
AI 绘画Stable Diffusion 研究（九）sd图生图功能详解-老照片高清修复放大

AI 绘画Stable Diffusion 研究（九）sd图生图功能详解-老照片高清修复放大

大家好&#xff0c;我是风雨无阻。 通过前面几篇文章的介绍&#xff0c;相信各位小伙伴&#xff0c;对 Stable Diffusion 这款强大的AI 绘图系统有了全新的认知。我们见识到了借助 Stable Diffusion的文生图功能&#xff0c;利用简单的几个单词&#xff0c;就可以生成完美的图片…
阅读更多...
阿里云OSS对象存储的核心概念与购买应用

阿里云OSS对象存储的核心概念与购买应用

文章目录 1.OSS对象存储基本介绍1.1.OSS对象存储概念1.2.NAS与OSS存储的不同1.3.OSS的应用场景1.4.OSS术语对应表 2.购买OSS存储资源包3.KodCloud云盘接入OSS对象存储3.1.创建Bucket存储空间3.2.创建子用户用于管理Bucket3.3.获取用户的AccessKey3.3.为用户设置权限3.4.将Bucke…
阅读更多...
MySQL和Redis如何保证数据一致性

MySQL和Redis如何保证数据一致性

MySQL与Redis都是常用的数据存储和缓存系统。为了提高应用程序的性能和可伸缩性&#xff0c;很多应用程序将MySQL和Redis一起使用&#xff0c;其中MySQL作为主要的持久存储&#xff0c;而Redis作为主要的缓存。在这种情况下&#xff0c;应用程序需要确保MySQL和Redis中的数据是…
阅读更多...
软件测试常用工具总结（测试管理、单元测试、接口测试、自动化测试、性能测试、负载测试等）

软件测试常用工具总结（测试管理、单元测试、接口测试、自动化测试、性能测试、负载测试等）

前言 在软件测试的过程中&#xff0c;多多少少都是会接触到一些测试工具&#xff0c;作为辅助测试用的&#xff0c;以提高测试工作的效率&#xff0c;使用好了测试工具&#xff0c;能对测试起到一个很好的作用&#xff0c;同时&#xff0c;有些公司&#xff0c;也会要求掌握一…
阅读更多...
__ob__: Observer 后缀的数组的取值方式

__ob__: Observer 后缀的数组的取值方式

开发中&#xff0c;经常从接口、父组件中&#xff0c;拿到数组然后给新的数组使用&#xff0c; 但是&#xff0c;有时候会发现带有 __ob__: Observer 后缀的数组&#xff0c;对这种数组来说&#xff0c;你是无法取到这个数组的值的&#xff0c; 而且&#xff0c;离谱的是consol…
阅读更多...
【深度学习--RNN 循环神经网络--附LSTM情感文本分类】

【深度学习--RNN 循环神经网络--附LSTM情感文本分类】

deep learning 系列 --RNN 循环神经网络 什么是序列模型 包括了RNN LSTM GRU等网络模型&#xff0c;主要用途是自然语言处理、语音识别等方面&#xff0c;比如生成乐曲&#xff0c;音频转换为文字&#xff0c;文本情感分类&#xff0c;机器翻译等等 标准模型的缺陷 以往的标…
阅读更多...
flutter 常见的状态管理器

flutter 常见的状态管理器

flutter 常见的状态管理器 前言一、Provider二、Bloc三、Redux四、GetX总结 前言 当我们构建复杂的移动应用时&#xff0c;有效的状态管理是至关重要的&#xff0c;因为应用的不同部分可能需要共享数据、相应用户交互并保持一致的状态。Flutter 中有多种状态管理解决方案&#…
阅读更多...
0143 串

0143 串

目录 4.串 4.1串的定义和实现 4.2串的模式匹配 部分习题 4.串 4.1串的定义和实现 4.2串的模式匹配 部分习题 1.设有两个串S1和S2&#xff0c;求S2在S1中首次出现的位置的运算称为&#xff08;&#xff09; A.求字串 B.判断是否相等 C.模式匹配 D.连…
阅读更多...
Vue2（组件开发）

Vue2（组件开发）

目录 前言一&#xff0c;组件的使用二&#xff0c;插槽slot三&#xff0c;refs和parent四&#xff0c;父子组件间的通信4.1&#xff0c;父传子 &#xff1a;父传子的时候&#xff0c;通过属性传递4.2&#xff0c;父组件监听自定义事件 五&#xff0c;非父子组件的通信六&#x…
阅读更多...
麦肯锡发布《2023年度科技报告》！

麦肯锡发布《2023年度科技报告》！

在经历了 2022 年技术投资和人才的动荡之后&#xff0c;2023 年上半年&#xff0c;人们对技术促进商业和社会进步的潜力重新燃起了热情。生成式人工智能&#xff08;Generative AI&#xff09;在这一复兴过程中功不可没&#xff0c;但它只是众多进步中的一个&#xff0c;可以推…
阅读更多...
总说绿幕直播抠像抠不干净？很有可能是你不知道这个神器！

总说绿幕直播抠像抠不干净？很有可能是你不知道这个神器！

在绿幕直播的时候&#xff0c;你是不是座位、绿幕、灯光都摆对了&#xff0c;但主播轮廓仍然有绿边和虚化的情况发生&#xff1f;这种很大可能就是你使用的直播抠像软件有问题。今天小编把市面上的常见直播软件来和vLive虚拟直播的抠像做一个对比&#xff0c;让你直观感受下他们…
阅读更多...
机器学习笔记 - 基于PyTorch + 类似ResNet的单目标检测

机器学习笔记 - 基于PyTorch + 类似ResNet的单目标检测

一、获取并了解数据 我们将处理年龄相关性黄斑变性 (AMD) 患者的眼部图像。 数据集下载地址，从下面的地址中，找到iChallenge-AMD，然后下载。 Baidu Research Open-Access Dataset - DownloadDownload Baidu Research Open-Access Datasethttps://ai.baidu.com/bro…
阅读更多...
基于ACF,AMDF算法的语音编码matlab仿真

基于ACF,AMDF算法的语音编码matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 matlab2022a 3.部分核心程序 .......................................................................... plotFlag …
阅读更多...
函数递归专题（案例超详解一篇讲通透）

函数递归专题（案例超详解一篇讲通透）

函数递归 前言1.递归案例:案例一&#xff1a;取球问题案例二&#xff1a;求斐波那契额数列案例三&#xff1a;函数实现n的k次方案例四&#xff1a;输入一个非负整数&#xff0c;返回组成它的数字之和案例五&#xff1a;元素逆置案例六&#xff1a;实现strlen案例七&#xff1a;…
阅读更多...
服务器遭受攻击之后的常见思路

服务器遭受攻击之后的常见思路

哈喽大家好&#xff0c;我是咸鱼 不知道大家有没有看过这么一部电影&#xff1a; 这部电影讲述了男主是一个电脑极客&#xff0c;在计算机方面有着不可思议的天赋&#xff0c;男主所在的黑客组织凭借着超高的黑客技术去入侵各种国家机构的系统&#xff0c;并引起了德国秘密警察…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023