(C++ STL)vector类的简单模拟实现与源码展示

于 2024-08-31 16:01:56 发布
阅读量648 收藏 21
点赞数 23
分类专栏： C++ STL 文章标签： c++ 学习 c++STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq3304968099/article/details/141729727
版权

vector类的简单模拟实现

以下代码环境为 VS2022 C++。

一、前言

vector类 本质上就是数据结构中的顺序表。(可参考：顺序表的讲解与实现)

接下来我们来简单实现 vector类 和 部分对应函数。

参考：legacy.cplusplus.com中的 std::vector

二、vector 的成员变量

在 vector.hpp 中：

namespace my
{
	template<class T>
	class vector
	{
        // Vector的迭代器是一个原生指针
        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;
        }

	private:

        iterator _start = nullptr;        // 指向数据块的开始
        iterator _finish = nullptr;       // 指向有效数据的尾
        iterator _endOfStorage = nullptr; // 指向存储容量的尾

	};
}

vector 的成员变量：

  1. vector 所存储数据的类型不确定，则使用模版。
  2. vector 的迭代器本质是指针变量，指向内存的地址。
  3. vector 有三个成员变量，_start、_finish、_endOfStorage，类型为 iterator。本质上都是指针变量，用来定位 vector 在内存上的位置。

vector 在内存中分布如图：

在这里插入图片描述

  1. 红色方块表示未开辟的空间，绿色方块表示有效数据，蓝色方块表示剩余存储容量。

  2. 这里采用 左闭右开 [ _start，_finish )，即 _start 开始就指向有效元素，_finish 指向最后一个元素的后面，_endOfStorage 同理。

三、vector 部分函数实现

size、capacity

vector 的有效长度和容量，是通过指针计算得到的。

指针 - 指针 得到的是中间的元素个数。

在 my::vector 中：

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

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

reserve

参考：std::vector::reserve

C++ 规定：

  1. 原空间 小于 需求空间 时，vector 扩容到需求空间或更多。

  2. 原空间 大于或等于 需求空间 时，vector 容量不变。

这里扩容严格按照 2 倍扩容。

在 vector.hpp 中：

template<class T>
void my::vector<T>::reserve(size_t n)
{
    if (n <= capacity())
    {
        return;
    }

    size_t newCapacity = capacity() == 0 ? MY_VECTOR_INIT_CAPACITY : capacity() * 2;

    while (newCapacity < n)
    {
        newCapacity <<= 1;
    }

    iterator newStart = new T[newCapacity];

    // 只能拷贝内置类型，如 string等非内置类型会失效
    //memcpy(newStart, _start, sizeof(T) * size());

    // 使用赋值拷贝
    for (int i = 0; i < size(); ++i)
    {
        newStart[i] = _start[i];
    }

    _finish = newStart + size();            // 指向代码不能交换位置
    _endOfStorage = newStart + newCapacity;

    delete[] _start;
    _start = newStart;
}

resize

参考：std::vector::resize

在 vector.hpp 中：

template<class T>
void my::vector<T>::resize(size_t n, const T& value)
{
    if (n > capacity())
    {
        reserve(n);

        iterator it = end();
        iterator over = begin() + n;

        while (it != over)
        {
            *it = value;
        }
    }

    _finish = begin() + n;
}

insert 与注意事项

参考：std::vector::insert

注意：
如果返回类型是在类里定义的，在类外使用时需要加上 typename 确定是类型，否则报错。

如 my::vector<T>::iterator 是类里 typedef 的一个类型，在类外使用时，编译器不能确定它是模版类的类型还是其静态变量，则会报错。

在 vector.hpp 中：

// 编译器不能分辨 my::vector<T>::iterator 是类型还是静态变量，
// 加上 typename 表示其为类型即可解决 
template<class T>   
typename my::vector<T>::iterator my::vector<T>::insert(my::vector<T>::iterator pos, const T& x)
{
    assert(_start <= pos && pos <= _finish);

    size_t sz = pos - begin();  // 考虑到扩容后 pos 可能失效，用中间值储存

    reserve(size() + 1);

    iterator it = nullptr;
    for (it = end(); it != begin() + sz; --it)
    {
        *it = *(it - 1);
    }
    *it = x;

    resize(size() + 1);

    return it + 1;
}

erase

参考：std::vector::erase

在 vector.hpp 中：

template<class T>
typename my::vector<T>::iterator my::vector<T>::erase(my::vector<T>::iterator pos)
{
    assert(size() != 0);
    assert(_start <= pos && pos < _finish);

    for (iterator it = pos; it != end() - 1; ++it)
    {
        *it = *(it + 1);
    }
    --_finish;

    return pos;
}

构造、析构、赋值拷贝

参考：std::vector::vector
参考：std::vector::~vector
参考：std::vector::operator=

在 my::vector 中：

        vector() = default; // default 后编译器会自动生成默认构造

        vector(size_t n, const T& value = T())
        {
            reserve(n);
            resize(n);

            for (auto& val : *this)
            {
                val = value;
            }
        }

        vector(int n, const T& value = T())
        {
            reserve(n);
            resize(n);

            for (auto& val : *this)
            {
                val = value;
            }
        }

        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push_back(*first);

                ++first;
            }
        }

        vector(const vector<T>& v)
        {
            reserve(v.capacity());
            for (auto& val : v)
            {
                push_back(val);
            }
        }

        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 != nullptr)
            {
                delete[] _start;
                _start = nullptr;
            }

            _finish = _endOfStorage = _start;
        }

四、vector 源代码

在 vector.hpp 中：

#pragma once

#include <iostream>
#include <cassert>

#define MY_VECTOR_INIT_CAPACITY 4

namespace my
{
    template<class T>
    class vector
    {
    public:

        // Vector的迭代器是一个原生指针
        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() = default; // default 后编译器会自动生成默认构造

        vector(size_t n, const T& value = T())
        {
            reserve(n);
            resize(n);

            for (auto& val : *this)
            {
                val = value;
            }
        }

        vector(int n, const T& value = T())
        {
            reserve(n);
            resize(n);

            for (auto& val : *this)
            {
                val = value;
            }
        }

        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push_back(*first);

                ++first;
            }
        }

        vector(const vector<T>& v)
        {
            reserve(v.capacity());
            for (auto& val : v)
            {
                push_back(val);
            }
        }

        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 != nullptr)
            {
                delete[] _start;
                _start = nullptr;
            }

            _finish = _endOfStorage = _start;
        }

        //--------------------------------------

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

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

        void reserve(size_t n);

        void resize(size_t n, const T& value = T());

        //--------------------------------------

        T& operator[](size_t pos)
        {
            return *(begin() + pos);
        }

        const T& operator[](size_t pos) const
        {
            return *(begin() + pos);
        }

        //--------------------------------------

        void push_back(const T& x)
        {
            insert(end(), x);
        }

        void pop_back()
        {
            erase(end() - 1);
        }

        iterator insert(iterator pos, const T& x);

        iterator erase(iterator pos);

    private:

        iterator _start = nullptr;        // 指向数据块的开始
        iterator _finish = nullptr;       // 指向有效数据的尾
        iterator _endOfStorage = nullptr; // 指向存储容量的尾
    };

}

template<class T>
void my::vector<T>::reserve(size_t n)
{
    if (n <= capacity())
    {
        return;
    }

    size_t newCapacity = capacity() == 0 ? MY_VECTOR_INIT_CAPACITY : capacity() * 2;

    while (newCapacity < n)
    {
        newCapacity <<= 1;
    }

    iterator newStart = new T[newCapacity];

    // 只能拷贝内置类型，如 string等非内置类型会失效
    //memcpy(newStart, _start, sizeof(T) * size());

    // 使用赋值拷贝
    for (int i = 0; i < size(); ++i)
    {
        newStart[i] = _start[i];
    }

    _finish = newStart + size();            // 指向代码不能交换位置
    _endOfStorage = newStart + newCapacity;

    delete[] _start;
    _start = newStart;
}

template<class T>
void my::vector<T>::resize(size_t n, const T& value)
{
    if (n > capacity())
    {
        reserve(n);

        iterator it = end();
        iterator over = begin() + n;

        while (it != over)
        {
            *it = value;
        }
    }

    _finish = begin() + n;
}

// 编译器不能分辨 my::vector<T>::iterator 是类型还是静态变量，
// 加上 typename 表示其为类型即可解决 
template<class T>   
typename my::vector<T>::iterator my::vector<T>::insert(my::vector<T>::iterator pos, const T& x)
{
    assert(_start <= pos && pos <= _finish);

    size_t sz = pos - begin();  // 考虑到扩容后 pos 可能失效，用中间值储存

    reserve(size() + 1);

    iterator it = nullptr;
    for (it = end(); it != begin() + sz; --it)
    {
        *it = *(it - 1);
    }
    *it = x;

    resize(size() + 1);

    return it + 1;
}

template<class T>
typename my::vector<T>::iterator my::vector<T>::erase(my::vector<T>::iterator pos)
{
    assert(size() != 0);
    assert(_start <= pos && pos < _finish);

    for (iterator it = pos; it != end() - 1; ++it)
    {
        *it = *(it + 1);
    }
    --_finish;

    return pos;
}
瞌睡不来
关注
  • 23
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AIGC从入门到实战：登录 DID
光剑书架上的书
06-20 538
以下是技术博客文章的正文内容： AIGC从入门到实战：登录 D-ID 1. 背景介绍 1.1 人工智能生成内容(AIGC)的兴起 人工智能生成内容(AIGC)是指利用人工智能技术生成文本、图像、音频、视频等
Watermark 原理与代码实例讲解
光剑书架上的书
07-09 726
Watermark 原理与代码实例讲解 1. 背景介绍 1.1 问题的由来 在数字内容创作与传播的过程中，确保版权归属和防伪成为了一个重要议题。水印（Watermark）技术作为解决这一问题的一种手段，主要用于在多媒体内容中嵌入不可见或不
zk-IMG：对抗虚假信息
mutourend的博客
07-10 1419
zk-IMG：对抗虚假信息
【国际数据保护日特别策划】十大厂商发声，数据安全如何才能“十全十美”...
01-28 1493
关注我们牛年牛气冲天每年的1月28日是“国际数据保护日”，亦称“数据隐私保护日”。该节日设置的目的是鼓励人们关注数据隐私，以实际行动保护在线个人信息安全，增强保护意识，了解基本权利，推动...
【2020GAN】对抗生成网络论文收录（1月-6月）
VictorFuture的博客
07-30 3676
【2020GAN】对抗生成网络论文收录（1月-6月）202001202002202003202004202005202006 202001 001 (2020-01-29) Simulation of electron-proton scattering events by a Feature-Augmented and Transformed Generative Adversarial Network (FAT-GAN) 基于特征增强和转换生成对抗网络(FAT-GAN)的电子质子散射事件模拟 htt
软考信息安全工程师备考笔记5：第五章应用系统安全基础备考要点
鹿鸣天涯
04-06 1089
第5章：应用系统安全基础 应用系统安全基础备考要点 https://www.moondream.cn/?p=1325 扫一扫加入信息安全工程师备考群 欢迎加入最棒的信息安全工程师社群，分享信息安全工程师备考干货资料。 备考交流QQ群：39460595 需要备考资料的考友，可以扫一扫加月梦助手微信。 考点1、Web安全 【考法分析】 本考点主要是对Web安全相关内容的考查。...
联盟链应用生态场景
lk2684753的博客
02-27 8786
联盟链：对特定的组织团体开放 区块链联盟链是指有若干个机构共同参与管理的区块链，每个机构都运行着一个或多个节点，其中的数据只允许系统内不同的机构进行读写和发送交易，并且共同来记录交易数据。私有链和联盟链之间的设计隐私权限会有不同，区块链联盟链中的权限设计要求往往会更为复杂。本质上联盟链属于私有链，只是私有化程度不同 联盟链主要用户群体 银行 保险 证券 商业 协会 集团公司 以及上下游企业等...
科技部：“网络空间安全”重点专项 2017年度项目申报指南建议
weixin_33912445的博客
08-19 665
“网络空间安全”重点专项2017年度项目申报指南建议 为落实《国家中长期科学和技术发展规划纲要(2006—2020年)》提出的任务，国家重点研发计划启动实施“网络空间安全”重点专项。根据本重点专项实施方案的部署，现提出2017年度项目申报指南建议。本重点专项总体目标是：聚焦网络安全紧迫技术需求和重大科学问题，坚持开放发展，着力突破网络空间安全基础理论和关键技术，研发一批关键技术装备和系统，逐步推动...
信息隐藏原理与技术复习
qq_41977843的博客
11-04 1929
信息隐藏：​ 确保宿主信息中隐藏的秘密信息不被改变或消除，从而在必要的时候提供那个有效的证明信息；信息伪装掩盖通信的存在。现代的信息隐藏技术：​ 在数字信息上的隐写，其基本原理是利用人在听觉、视觉系统 分辨率上的限制，以数字媒体信息为载体，将秘密信息隐藏其 中，从而掩盖秘密信息的存在2.信息隐藏的两个分支隐写术：物理上利用化学药水的密写、藏头诗（1）不可感知和不可检测性（2）秘密性：嵌入过程、嵌入方法是秘密的（3）足够大的信息量（4）算法计算复杂性低。
防伪查询系统
02-09
2. **数据存储**：这些防伪码会被安全地存储在数据库中，与相应产品的信息关联。数据的安全性和完整性是这个系统的基础，通常需要采用加密技术和备份策略来保障。 3. **查询接口**：消费者可以通过多种方式查询产品...
网络安全与应用：网络安全基础
网络安全是指通过采取一系列的网络安全措施，保护网络系统不受未经授权的访问、泄露、修改、破坏，确保网络系统运行正常、连续和可靠，防止网络系统遭受恶意攻击、干扰、破坏，从而达到保密性、完整性、可用性、可控...
网络安全入门指南：防护与渗透测试
网络安全的重要性体现在保护个人隐私、保护国家安全、保护网络经济以及保障信息基础设施的安全上。 ## 1.3 常见的网络安全威胁 网络安全威胁包括计算机病毒、恶意软件、网络钓鱼、勒索软件、数据泄露、拒绝服务攻击...
第135天：内网安全-横向移动&非约束委派&约束委派&数据库攻防
weixin_71529930的博客
08-24 566
非约束委派存在不安全性，所以微软在Windows server 2003中引入了约束委派，约束委派攻击主要利用被控主机设置了域控的CIFS服务的约束委派，则攻击者可以先使用S4u2seflt申请域管用户访问被控主机的ST1，然后使用S4u2Proxy以administrator身份访问域控的CIFS服务，即相当于控制了域控。攻击者拿到了一台配置非约束委派的机器权限，可以诱导域管来访问该机器，然后得到管。利用该身份就可以访问域控，记得用主机名去访问。（域控）访问具有非约束委派权限的机器。
终端防火墙软件功能 | 在终端设备上启用防火墙！终端安全小课堂开讲啦
2401_86434954的博客
08-24 580
终端设备的安全性直接关系到企业的整体网络安全，随着网络威胁的日益复杂和多样化，启用并合理配置终端防火墙软件是保障终端安全不可或缺的一环。今天，我们将走进终端安全小课堂，详细解析中的防火墙功能，为您揭开其保护终端安全的神秘面纱。
医院建筑的电气设计——保障医疗质量与安全的坚固基石
acrel002的博客
08-28 567
特别是那些与患者生命息息相关的1、2类场所，如急诊抢救室、手术室、重症监护室等，其供电系统更是被赋予了“特别重要负荷”的标签，要求在极短的时间内恢复供电，以确保医疗活动的连续性和患者的安全。随着一批批新建医院及既有医院的华丽蜕变，从社区医院到综合医院，再到医疗城、医疗集聚区的崛起，不仅彰显了政府对民生健康的深切关怀，也预示着我国医疗体系正迈向智能化、高效化的新时代。医院，作为生命与健康的守护者，其内部布满了各式各样的精密医疗设备与电子仪器，这些设备的稳定运行高度依赖于稳定、可靠的电力供应。
《云原生安全攻防》-- K8s攻击案例：组件未授权访问导致集群入侵
08-27 522
在本节课程中，我们将一起探讨K8s组件未授权访问导致集群入侵的攻击案例。K8s的组件的配置不安全，就有可能存在未授权访问的安全风险。如果攻击者能够成功进行未授权访问，就有可能导致整个集群节点遭受入侵。在这个课程中，我们将学习以下内容：K8s组件未授权访问：常见的K8s组件未授权访问漏洞介绍。K8s组件未授权攻击案例：深入分析K8s组件未授权访问的攻击案例。我们将重点介绍以下几个常见的组件未授权访问...
掌控安全CTF-2024年8月擂台赛-ez_misc
最新发布
ASD830的博客
08-28 493
用得到的密码（the_password_is_zkaq!）去解密 最后的秘密.zip 压缩包，可以得到一个key.txt和一个加密的flag.zip。这里我们没啥信息可用的了，返回去看看 最后的秘密.zip 压缩包有注释（我最喜欢和超人一起下棋了，哈哈哈哈哈哈！发现需要密钥，超人超人，猜测为“superman”，解密成功得到新的key：s1mple。找到了通往大千世界的旗帜，请提交你的旗帜，然后继续环游世界吧！我们就可以猜测为棋盘解密，找个解密网站（再往下我们又会找到rsa.txt。
“北京地铁系统中人脸识别技术的安全与效率问题研究”
matlabgoodboy的博客
08-28 548
综上所述，北京地铁系统中人脸识别技术的应用在提高安检和售检票效率方面具有显著优势，但同时也面临着数据隐私保护和滥用风险等安全问题。为了充分发挥人脸识别技术的优势并降低其风险，需要建立健全的法律法规和监管机制，并不断优化技术算法和管理手段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值