模拟实现c++中的vector模版

news2025/2/25 0:21:47

 

目录

一·vector简述：

二·vector的一些接口函数：

1·初始化：

2.vector增长：

3·vector增删查改：

三·vector模拟实现部分主要函数：

1.size,capacity,empty,clear接口： 

2.reverse的实现： 

3.resize的实现：

 4.访问运算符重载operator[]的实现：

5.push_back与pop_back的实现：

 6.erase的实现：

7.insert的实现：

8·swap的实现：

9.拷贝构造的实现：

10.赋值重载的实现：

11.构造和析构函数的实现：

12.vector以及容器通用打印的实现：

四·vector模拟实现过程中遇到的问题总结：

1.迭代器失效问题简述：

2.vector类内类型省略问题：

3.迭代器运算符问题：

五·模拟vector代码汇总：

一·vector简述：

它可以认为是一个动态容器，即一种顺序表。通过给这个模版实例化可以得到一种任意类型的顺序表，故可以放进去数据，则使用前应该先实例化类型。

二·vector的一些接口函数：

1·初始化：

无参构造：
vector<int> v1;

有参：
vector<int> v2(10,1);
v2拷贝构造给v3
vector<int>v3(v2);
迭代器初始化：
vector<int> v4(++v2.begin(),v2.end()--);//把v2部分范围给v4初始化

2.vector增长：

如：size；capacity（vs是1.5倍扩，g++为2倍）；empty；resize；reserve（不缩容）；等函数接口用法类似于上篇string用法。

3·vector增删查改：

如：push_back;pop_back;find(这时algorithm算法库内的函数，也是使用迭代器区间：找到了返回指向那个位置的迭代器，否则返回右区间)；insert;erase;swap;operator[],v.front;v.back等用法和string相差不大，可以说是string的下标换成vector的迭代器了。

注：这里对于vector的重载函数没有cin和cout。

三·vector模拟实现部分主要函数：

首先要知道这个模拟过程如图一样：

由于是类模版，一般定义和声明不能分文件，故可以都写在.h文件：

首先先不写构造，但是编译器默认生成的构造来，可能会给成员变量野指针，故给它一个缺省值为nullptr； 提前也要写好析构。

 

这里的iterator是迭代器类型可以粗略认为是指针，假设模版参数是T，故typedef一下：

typedef T* iterator;

typedef const T* const_iterator;

iterator begin() {
    return _start;
}

iterator end() {
    return _finish;
}

const_iterator cbegin()const {
    return _start;
}

const_iterator cend() const {
    return _finish;
}

分别对可以修改和不允许修改的对象都有了对应的迭代器。

1.size,capacity,empty,clear接口： 

 

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

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

bool empty()
{
    return _start == _finish;
}

void clear()
{
    _finish = _start;
}

2.reverse的实现： 

注：①这里用了一个oldsize记录为扩容之前的size；因为假设进行第一次扩容 ，_start更新后;_finish+的size（）（_finish-_start）就会不是原来的size了；故需要保存一下这个相对位置。

②这里一开始用的是string.h里的memcpy ，利用的是浅拷贝，如果让里面的类型是自定义（有资源申请已经释放的）发现浅拷贝这样会出问题，故后面改正。

3.resize的实现：

 void resize(size_t n, const T& value = T()) {
     if (n < size()) {
         size_t tmp = size();
         while (tmp > n) {
             _finish--;
             tmp--;
         }

     }
     else {
         reserve(n);
         for (size_t i = size(); i < n; i++)
         {
             push_back(value);
         }
     }
 }

如果size小于给的n，就扩大size（capacity()也要跟上）；后面用value填充，如果大于就相当于截断。对于缺省参数：如果未给值就会掉此类型默认构造（T（）为匿名对象）,对于内置类型如：char，int等这就是'\0',0。如果是自定义类型：就是它的默认构造函数构造出的对象。

 4.访问运算符重载operator[]的实现：

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

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

分别对应的是const类型对象和普通对象的调用。

5.push_back与pop_back的实现：

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

     *_finish = x;
     _finish++;
   }

 void pop_back() {
     assert(!empty());
     _finish--;

     }

 

 6.erase的实现：

iterator erase(iterator pos) {
    assert(pos < _finish&&pos>=_start);
    iterator end = pos + 1;
    while (end < _finish) {
        *(end - 1) = *end;
        end++;
    }
    _finish--;
    return pos;
    }

7.insert的实现：

这里以insert的实现为例子，把它进行类内声明，类外定义；

//类内：
    iterator insert(iterator pos, const T& x);



//类外：
template<class T>
typename vec::vector<T>::iterator vec::vector<T>::insert(typename vec::vector<T>::iterator pos, const T& x) 
//类模版未初始化不能进类内确定它是静态成员变量还是类型，故若是类型要typename一下


{
    size_t len = 0;
    if (_finish == _end_of_storage)
    {
        len = pos - _start;//迭代器失效：由于空间变了，pos无法找到指向原来空间，而数据早已被移到了新空间，原来的也被释放
        reserve(capacity() == 0 ? 4 : capacity() * 2);
    }
    if (len != 0) {
        pos = _start + len;
    }
    iterator end = _finish;
    while (end >= pos) {
        *end = *(end - 1);
        end--;
    }
    *pos = x;
    _finish++;
    return pos;
}

这里和erase一样涉及迭代器失效问题于后面总结进行讲解。

8·swap的实现：

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);
      }

9.拷贝构造的实现：

  //拷贝构造：：
 vector(const vector<T>& v) {
     reserve(v.capacity);
     for(auto a:v ){
         push_back(a);
   }

        }

可能前面写的函数程序都运行正常，当写完这个拷贝构造发现编译器会报错：

 

原因：其实拷贝构造函数也是一种构造函数，而当我们写了拷贝构造，编译器自己就不会生成它的默认构造了（普通构造也没写）；因此他会走这个拷贝构造，但发现参数不匹配，就会报错，因此这时要再把默认构造或者传参的构造写上就可以了。 

10.赋值重载的实现：

  //s1=s3
  vector<T>& operator= (vector<T> v) {
      swap(v);//如果不引用参数，则会进行拷贝再swap，这时候s3给s1赋值后它自身不会变。
      return *this;

         }

11.构造和析构函数的实现：

     //默认构造1：
/*vector() {
     
   }*//如果这个默认构造{}内可以没有，只用它的初始化列表，但也有缺省值了就可以这么写。
   //  默认构造2：（c++11）
     vector() = default;

     vector(int n, const T& value = T()) {
         reserve(n);
         for (size_t i = 0; i < n; i++)
         {
             push_back(value);
         }
     }
//迭代器区间初始化：
     //模版函数，可以用别的类型的函数，故完成一个容器数据到另一个容器转换
      template<class InputIterator>
      vector(InputIterator first, InputIterator last) {
          while (first != last) {
              push_back(*first);//一个容器数据放另一个，数据类型要匹配，否则进不去。
              first++;
          }
      }




//析构：
 ~vector() {
     if (_start)
     {
         delete[] _start;
         _start = _finish = _end_of_storage = nullptr;
     }
        }

这里用了类模版内套着模版函数：方便了不同类型 的迭代器区间去放入这个容器，如list：

12.vector以及容器通用打印的实现：

//vector专属的打印：
template<class x>
void  Print(const vec::vector<x>& t) {
    //未实例化的模版无法去访问内部，区分不了是静态成员变量还是类型
   //typename vec::vector <x>::const_iterator it = t.cbegin();
    auto it = t.cbegin();
    while (it != t.cend())
    {
        std::cout << *it << " ";
        ++it;
    }
    std::cout << std::endl;
}
template<typename C>
void Print_container(const C &cr ) {
    auto it = cr.cbegin();
    while (it != cr.cend())
    {
        std::cout << *it << " ";
        ++it;
    }
    std::cout << std::endl;

}

 

四·vector模拟实现过程中遇到的问题总结：

1.迭代器失效问题简述：

失效分为两种，第一种是迭代器指向无效内存了即空间变化了，第二种是所引用的对象发生变化了，都是迭代器失效。这时候建议不要在对它这个位置迭代器进行访问了；否则程序崩溃。

这里举erase和insert的例子：

这里如果对insert插入如果没有空间开辟也可以认为迭代器失效，但是有的时候可以继续访问，但是一般建议用返回值重新赋值再使用，而开辟空间了则一定失效，必然要重新赋值。

erase的迭代器如果此位置对象被删除，也要重新赋值再用此迭代器。

例子：

这里就涉及到了erase造成的迭代器失效：前面正常打印当到0；之后由于继续访问就崩掉了。

 

这时候要想正常需要利用它的返回值来重新赋值进行后面的访问：

 

2.vector类内类型省略问题：

如果在类内那么对于类型vector<T>可以在类内变成vector等价代替，但是如果在类外就不可能了。

3.迭代器运算符问题：

这里如果first和last如果是迭代器的话那么为什么不用大于小于呢，理论上针对vector是可以的，但是比如它空间不是连续的list链表就是反例，这时候大于小于就没概念了。前提还得是空间要连续。 

五·模拟vector代码汇总：

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

namespace vec

{

    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 cbegin()const {
            return _start;
        }

        const_iterator cend() const {
            return _finish;
        }




        //默认构造1：
   /*vector() {
        
      }*/
      //  默认构造2：（c++11）
        vector() = default;

        vector(int n, const T& value = T()) {
            reserve(n);
            for (size_t i = 0; i < n; i++)
            {
                push_back(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 a:v ){
                push_back(a);
          }

               }
        //s1=s3
        vector<T>& operator= (vector<T> v) {
            swap(v);//如果不引用参数，则会进行拷贝再swap，这时候s3给s1赋值后它自身不会变。
            return *this;

               }

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



            //    // capacity

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

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

        bool empty()
        {
            return _start == _finish;
        }

        void clear()
        {
            _finish = _start;
        }
        void reserve(size_t n) {
            if (n > capacity()) {
                size_t oldsize = size();//开辟空间前后导致指针指向空间不同
                T * tmp = new T [n];
               // memcpy(tmp, _start, sizeof(T) * size());一个个字节的浅拷贝
                for (int i = 0; i < size(); i++) {
                    tmp[i] = _start[i];//利用string库里的赋值运算符重载
                }//自定义类型使用深拷贝
                delete[]_start;
                _start = tmp;
                _finish = tmp + oldsize;//防止_start已经更新，而这里要的是以前的相对位置，故保存一下
                _end_of_storage = _start + n;
            }
        }

        void resize(size_t n, const T& value = T()) {
            if (n < size()) {
                size_t tmp = size();
                while (tmp > n) {
                    _finish--;
                    tmp--;
                }

            }
            else {
                reserve(n);
                for (size_t i = size(); i < n; i++)
                {
                    push_back(value);
                }
            }
        }



        //    ///access///

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

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



        //    ///modify/

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

            *_finish = x;
            _finish++;
          }

        void pop_back() {
            assert(!empty());
            _finish--;

            }

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

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

        iterator erase(iterator pos) {
            assert(pos < _finish&&pos>=_start);
            iterator end = pos + 1;
            while (end < _finish) {
                *(end - 1) = *end;
                end++;
            }
            _finish--;
            return pos;
            }

    private:

        iterator _start = nullptr; // 指向数据块的开始

        iterator _finish = nullptr; // 指向有效数据的尾

        iterator _end_of_storage = nullptr; // 指向存储容量的尾

    };

}


template<class T>
typename vec::vector<T>::iterator vec::vector<T>::insert(typename vec::vector<T>::iterator pos, const T& x) 
//类模版未初始化不能进类内确定它是静态成员变量还是类型，故若是类型要typename一下


{
    size_t len = 0;
    if (_finish == _end_of_storage)
    {
        len = pos - _start;//迭代器失效：由于空间变了，pos无法找到
        reserve(capacity() == 0 ? 4 : capacity() * 2);
    }
    if (len != 0) {
        pos = _start + len;
    }
    iterator end = _finish;
    while (end >= pos) {
        *end = *(end - 1);
        end--;
    }
    *pos = x;
    _finish++;
    return pos;
}

//vector专属的打印：
template<class x>
void  Print(const vec::vector<x>& t) {
    //未实例化的模版无法去访问内部，区分不了是静态成员变量还是类型
   //typename vec::vector <x>::const_iterator it = t.cbegin();
    auto it = t.cbegin();
    while (it != t.cend())
    {
        std::cout << *it << " ";
        ++it;
    }
    std::cout << std::endl;
}
template<typename C>
void Print_container(const C &cr ) {
    auto it = cr.cbegin();
    while (it != cr.cend())
    {
        std::cout << *it << " ";
        ++it;
    }
    std::cout << std::endl;

}

 

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

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

相关文章

青少年科普平台-计算机毕业设计源码76194

青少年科普平台-计算机毕业设计源码76194

摘 要 对于搭建一个青少年科普平台&#xff0c;您可以考虑使用Spring Boot作为后端框架。Spring Boot是一个能够简化Spring应用开发的框架&#xff0c;能够帮助您快速搭建稳定、高效的后端服务。您可以利用Spring Boot的特性来构建一个可靠的数据服务&#xff0c;用于展示和传播…
阅读更多...
docker镜像下载

docker镜像下载

1、搜索镜像 [rootlocalhost ~]# docker search ubuntu 2、下载ubuntu系统镜像(容器架构与宿主机相同) [rootlocalhost ~]# docker pull ubuntu #选择stars值最高镜像下载&#xff0c;默认为latest版 [rootlocalhost ~]# docker images 3、查看镜像支持的架构 [rootlocalh…
阅读更多...
1143. 最长公共子序列（详细版）

1143. 最长公共子序列（详细版）

目录 dp解法&#xff1a; 1.状态代表什么&#xff1a; 2. 状态转移方程 3.初始化 3. so为什么要这样&#xff1f; 代码实现&#xff1a; 给定两个字符串 text1 和 text2&#xff0c;返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 &#xff0c;返回 0…
阅读更多...
protobuf2.5升级protobuf3.14.0

protobuf2.5升级protobuf3.14.0

这个升级搞得心力憔悴&#xff0c;我VS2010升级到了VS2017&#xff0c;所有的库都要编译一下&#xff0c;想着顺便把其他的三方库也升级了。搞了好几天&#xff0c;才升级完&#xff0c;因为不仅要搞windows还要搞linux版本各种库的升级。hpsocket的升级&#xff0c;jsoncpp的升…
阅读更多...
stm32h7串口发送寄存器空中断

stm32h7串口发送寄存器空中断

关于stm32串口的发送完成中断UART_IT_TC网上资料挺多的&#xff0c;但是使用发送寄存器空中断UART_IT_TXE的不太多 UART_IT_TC 和 UART_IT_TXE区别 UART_IT_TC 和 UART_IT_TXE 是两种不同的 UART 中断源&#xff0c;用于表示不同的发送状态。它们的主要区别如下&#xff1a; …
阅读更多...
安卓单机游戏：龙之矛内置菜单，【免费分享】白嫖!

安卓单机游戏：龙之矛内置菜单，【免费分享】白嫖!

龙之矛是一款传统的横版卷轴RPG游戏。在游戏中玩家将探索被梦魇蹂躏的世界&#xff0c;和朋友一起猎杀强大的BOSS&#xff0c;如果你杀死了boss&#xff0c;那么你可以制作具有boss力量的装备。游戏内所有装备都有独特的外观&#xff0c;你可以用各种华丽的装备打扮你的角色。英…
阅读更多...
并发基础——Java全栈知识（37）

并发基础——Java全栈知识（37）

1、并发基础 1、进程和线程的区别 程序由指令和数据组成&#xff0c;但这些指令要运行&#xff0c;数据要读写&#xff0c;就必须将指令加载至 CPU&#xff0c;数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。当…
阅读更多...
【LLM】-10-部署llama-3-chinese-8b-instruct-v3 大模型

【LLM】-10-部署llama-3-chinese-8b-instruct-v3 大模型

目录 1、模型下载 2、下载项目代码 3、启动模型 4、模型调用 4.1、completion接口 4.2、聊天&#xff08;chat completion&#xff09; 4.3、多轮对话 4.4、文本嵌入向量 5、Java代码实现调用 由于在【LLM】-09-搭建问答系统-对输入Prompt检查-CSDN博客 关于提示词注入…
阅读更多...
GPT-4o Mini 模型的性能与成本优势全解析

GPT-4o Mini 模型的性能与成本优势全解析

GPT-4o Mini 模型的性能与成本优势全解析 &#x1f4c8; &#x1f31f; GPT-4o Mini 模型的性能与成本优势全解析 &#x1f4c8;摘要引言正文内容GPT-4o Mini 模型简介 &#x1f680;性能测试与对比 &#x1f4ca;应用场景 &#x1f310;自然语言处理对话系统内容生成 ✍️ &am…
阅读更多...
Lesson 51 A pleasant climate

Lesson 51 A pleasant climate

Lesson 51 A pleasant climate 词汇 Greece n. 希腊 Greek a. 希腊的&#xff0c;希腊语 搭配&#xff1a;Greek gift 不怀好意的礼物 例句&#xff1a;他的电脑是不怀好意的礼物。 　　　His computer is a Greek gift. climate n. 气候 长时间&#xff0c;不容易更改的 we…
阅读更多...
生成式AI和LLM的革命：Transformer架构

生成式AI和LLM的革命：Transformer架构

近年来&#xff0c;随着一篇名为“Attention is All You Need”论文的出现&#xff0c;自然语言处理&#xff08;NLP&#xff09;领域经历了一场巨大的变革。2017年&#xff0c;在谷歌和多伦多大学发表了这篇论文后&#xff0c;Transformer架构出现了。这一架构不仅显著提升了N…
阅读更多...
.net 连接达梦数据库开发环境部署

.net 连接达梦数据库开发环境部署

.net 开发环境部署 1. 环境准备 测试工具 Visual Studio2022 数据库版本 dm8 2. 搭建过程 1 &#xff09;创建新项目 2 &#xff09;选择创建空项目 3 &#xff09;配置新项目 4 &#xff09;右键 DM1 新建一个项 5 &#xff09;加 载 驱 动 &#xff0c; 新 建 …
阅读更多...
移动恶意软件的崛起

移动恶意软件的崛起

一.介绍 随着手机的出现&#xff0c;我们的日常生活发生了变化&#xff0c;无论是我们的工作方式还是我们过去相互交流的方式&#xff0c;一切都随着移动技术的进步而改变。但是&#xff0c;随着技术的进步&#xff0c;恶意软件也被引入&#xff0c;随着时间的推移它也变得更加…
阅读更多...
用excel能做出这些报表吗？

用excel能做出这些报表吗？

用excel能做出这些报表吗&#xff1f; 有什么办法不安装OFFICE也能显示出来&#xff1f;
阅读更多...
免费【2024】springboot 城市交通管理系统的设计与实现

免费【2024】springboot 城市交通管理系统的设计与实现

博主介绍&#xff1a;✌CSDN新星计划导师、Java领域优质创作者、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行前辈交流✌ 技术范围&#xff1a;SpringBoot、Vue、SSM、HTML、Jsp、PHP、Nodejs、Python、爬虫、数据可视化…
阅读更多...
labview四字节转浮点数

labview四字节转浮点数

1.labview四字节转浮点数 2.Labview怎么把串口接收到的数据转换成浮点数&#xff1f; Labview怎么把串口接收到的数据转换成浮点数&#xff1f;
阅读更多...
SeaCMS海洋影视管理系统远程代码执行漏洞复现

SeaCMS海洋影视管理系统远程代码执行漏洞复现

SeaCMS海洋影视管理系统远程代码执行漏洞复现 Ⅰ、环境搭建Ⅱ、漏洞复现Ⅲ、漏洞分析 免责声明&#xff1a;请勿利用文章内的相关技术从事非法测试&#xff0c;由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&…
阅读更多...
maven引入了jar包但在class文件里找不到jar包里的类

maven引入了jar包但在class文件里找不到jar包里的类

在工作当中遇到的这个问题&#xff0c;别人引入的jar包&#xff0c;我代码里报错 maven clean 和 maven install 都不管用 检查过了pom文件 检查了maven仓库路径下是否有这个cn.hutool的jar包 都没有找到问题 最终解决办法是手动引入 步骤一&#xff1a;点击左上角file->…
阅读更多...
湖仓一体架构解析：数仓架构选择（第48天）

湖仓一体架构解析：数仓架构选择（第48天）

系列文章目录 1、Lambda 架构 2、Kappa 架构 3、混合架构 4、架构选择 5、实时数仓现状 6、湖仓一体架构 7、流批一体架构 文章目录 系列文章目录前言1、Lambda 架构2、Kappa 架构3、混合架构4、架构选择5、实时数仓现状6、湖仓一体架构7、流批一体架构 前言 本文解析了Lambd…
阅读更多...
【leetcode】两数之和【简单】( 注释详解：C++map/ C哈希表）

【leetcode】两数之和【简单】( 注释详解：C++map/ C哈希表）

本题为函数题&#xff0c;函数头固定如下&#xff1a; C: vector<int> twoSum(vector<int>& nums, int target)C: int* twoSum(int* nums, int numSize, int target, int* returnSize) 下面是时间复杂度为O&#xff08;n&#xff09;的代码 CAC代码&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023