STL之string模拟实现

面试题：简易版string(深拷贝与浅拷贝的问题)

如果要实现简易版的string 无需涉及增容问题，成员变量可以不用存储容量和元素个数

构造函数

错误示范


class string
{
    string()
    : _str(nullptr)
    {}
    string(const char* str)
    : _str(str)
    {}
    char& operator[](size_t i)
    {
        return _str[i];
    }
    size_t size()
    {
        return strlen(_str);
    }
    private:
        char* _str;
}
void test
{
    string s1;
    string s2("world");
    for(size_t i = 0; i < s2.size();++i)
    {
        s2[i]+=1;
        cout << s2[i] << endl;
       //这个循环中会报内存错误，为什么呢？
    }
}

以上的代码会报错，我们具体来分析一下

首先在构造s2的时候我们传过去了一个常量字符串，而常量位于操作系统的代码段中，无法被修改，当传过去以后指针str接收，于是str就指向了代码段中的’w‘这个字符，但无法修改，以至于造成内存错误

图1

以上还带来的其他问题：假如待会要插入字符串，空间不够无法实现怎么办？(如果不是简易版的话怎么办？)

正确示范

思路：通过图1我们可知常量字符串是在代码段的，所以才无法修改，那我们把它放在其他可以修改的地方不就可以了吗？那具体放在哪呢？既然要支持动态增容，那么放在堆上(既可以扩容，又可以修改)是最好的！而s1的构造函数也不能直接把成员变量置为空，因为如果置为空了，那么就无法进行扩容及遍历：string对象创建出来即使没有有效字符也要有一个空间来存放'\0'


class string//正确示范
{
    
    string(const char* str = '')
    : _str(new char[strlen(str)+1])//多出来一个空间是为了存储'\0的'
    {
        strcpy(_str,str);
        
    }

    char& operator[](size_t i)
    {
        return _str[i];
    }
    size_t size()
    {
        return strlen(_str);
    }
    private:
        char* _str;
}
void test
{
    string s1;
    string s2("world");
    for(size_t i = 0; i < s2.size();++i)
    {
        s2[i]+=1;
        cout << s2[i] << endl;
    }
}

图2

析构函数


class string
{
    //....
    ~string()//这里是析构函数
    {
        delete [] _str;
        _str = nullptr;
    }
    //....
    private:
        char* _str;
}

拷贝构造

如果我们不写拷贝构造，那么编译器会自动运行默认的拷贝构造，那么这个拷贝构造有什么问题吗？


class string
{
//...省略这个string类，假如这个类里没有拷贝构造
}
void test
{
    string s1("world");
    string s2(s1);
}

假如是以上代码，编译器会怎么执行呢？

编译器会把s1中的成员指针变量指向的地址给s2，并让他们两个指向同一块地址。这也就是所谓的浅拷贝/值拷贝。在执行前期不会出现什么内存问题，但是当执行到s1的析构函数时会造成同一块空间被释放了两次。

图3

解决办法就是：在构造s2时，重新在堆上开一块空间，再把s1的内容拷贝至s2即可

图4


class string
{
//....
    string(const string& s
        : _str(new char[strlen(s._str)+1])
    {
        strcpy(_str,s._str);
    }
//....
    private:
        char* _str;
}

第二种写法：深拷贝

这种写法就是通过swap函数把要拷贝的string对象的值和当前string对象的值进行交换


string(const string& s)
    :_str(nullptr)//如果不置为空tmp交换完以后就是随机值，析构会报错
{
    string tmp(s._str);
    swap(_str,tmp._str);
}

赋值函数（operator=）

思路：这里的思路是先创建一个空间存放右操作数并拷贝，再把成员变量指向那个空间所指向的地方，并记得释放原来的空间


class string
{
    public:
    //...
      string& operator=(const string& s)
       {
            char* tmp = new char[strlen(s._str)+1];
            strcpy(tmp,s._str)
            delete [] _str;
            _str = tmp;
        }
    //这里的返回值是为了支持连等，例如s1 = s2 = s3,就是s3先赋给s2，s2再赋给s1
     private:
     char* _str;
}

到这里，这个简易版的string就已经实现了，下面让我们看看支持增删查改的string是如何实现的吧

代码区


class string
    {
    public:
        string(const char* str ="")//构造函数
            :_str(new char[strlen(str)+1])
        {
            strcpy(_str, str);
        }


        string(const string& s)//拷贝构造
            : _str(new char[strlen(s._str)+1])
        {
            strcpy(_str, s._str);
        }

        ~string()//析构函数
        {
            delete [] _str;
            _str = nullptr;
            
        }

        string& operator=(const string& s)
        {

          char* tmp = new char[strlen(s._str) + 1];
          strcpy(tmp, _str);
          delete[]_str;
          _str = tmp;
          return *this;
        }
        
        size_t size()
        {
            return strlen(_str);
        }


        char& operator[](size_t i)
        {
            return _str[i];
        }

    private:
        char* _str;
    };

完整版string实现

成员变量的变化以及原因

当涉及到增的问题时，就需要有两个变量，一个控制能存多少有效字符，一个控制当前有效字符个数。以及对简易版进行优化


class string
{
    public:
    
    private:
        char* _str;
        size_t _capacity;
        size_t _size;
}

string的构造函数、析构函数、拷贝构造、赋值

这里直接放代码了，不懂看前面


class string
    {
    public:
        string(const char* str = "")//构造函数
        {
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity+1];
            strcpy(_str, str);
        }

        ~string()//析构函数
        {
            delete [] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }

        string(const string& s)//拷贝构造
            :_str(new char[s._capacity+1])
        {
            strcpy(_str, s._str);
        }

        string& operator=(const string& s)//赋值
        {
            char* tmp = new char[s._capacity + 1];
            strcpy(tmp, s._str);
            delete[]_str;
            _str = tmp;
            return *this;
        }
        size_t size()
        {
            return _size;
        }

        size_t capacity()
        {
            return _capacity;
        }

        char& operator[](size_t i)
        {
            assert (i >= 0);
            return _str[i];
        }

        const char* c_str()
        {
            return _str;
        }

    private:
        char* _str;
        size_t _capacity;
        size_t _size;
    };

operator<<


ostream& operator<<(ostream& out, const string& s)//opeartor<<
    {
        for (size_t i = 0; i < s.size(); ++i)
        {
            cout << s[i];
        }
        return out;
    }

operator+=

这里分为三种：①+=常量字符

②+=常量字符串

③+=对象

思想就是：在_size位置直接插入字符，因为把原来的'\0'覆盖了，而c++中字符串的结束标准就是'\0'所以最后在尾上补上'\0'即可，插入字符都要考虑空间，于是封装一个increase用来扩容


class string
{
    public:
        //....
       char*& increase(size_t n)//传参数时直接传插入后有效字符的个数
        {
            //扩容
            size_t newcapacity = n;
            char* tmp = new char[n + 1];
            _capacity = newcapacity;
            //拷贝原数组
            strcpy(tmp, _str);
            return tmp;
        }

        string& operator+=(const char* str)//+=字符串
        {
            size_t len = strlen(str);
            //扩容及直接插入
            while (*str != '\0')
            {
                //判断是否扩容
                if (_capacity == _size)
                {
                    char* tmp = increase(_capacity+len);
                    delete[] _str;
                    _str = tmp;
                }
                //插入
                _str[_size] = *str;
                ++_size;
                ++str;
            }
            //补上'\0';
            _str[_size] = '\0';    
            return *this;
        }

        string& operator+=(const char ch)//+=字符
        {
            //判断是否扩容
            if (_size == _capacity)
            {
                char* tmp = increase();
                delete[] _str;
                _str = tmp
            }
            //插入字符
            _str[_size] = ch;
            _size++;
            //补上'\0'
            _str[_size] = '\0';
            return *this;
        }

        string& operator+=(const string& s)//+=对象
        {
            size_t len = s._size;
            //扩容
            if (_size + len > _capacity)
            {
                char* tmp = increase(_capacity+len);
                delete[] _str;
                _str = tmp;
            }
            //赋值，转化为operator(const char* ch)
            *this += (s._str);
            return *this;
        }
        //....
     }
    private:
        char* _str;
        size_t _capacity;
        size_t _size;
}

operator>>


    istream& operator>>(istream& in, string& s) 
    {
        char ch = in.get();//先获取一个字符
        while (ch == '\n'|| ch ==' ')//如果获取的字符是空格或换行则跳出循环 
        {
            s += ch;
            ch = in.get();//这里继续获取，反复进入while循环的判断
        }
            return in;
    }

任意位置的插入与删除(insert)

这里实现两个：

①字符串在pos位置的插入

②字符在pos位置的插入

这里用两种思想，一种是先插入后挪动(字符常量用的是这种)，一种是先挪动再插入(字符串用的是这种)


        string& insert(size_t pos, char ch)
        {
            assert(pos<size)
            //插入
            *this += ch;
            int end = _size - 1;
            //挪动数据
            while (end >= pos)
            {
                _str[end + 1] = _str[end];
                --end;
            }
            //插入及补上'\0'
            _str[end+1] = _str[_size];
            _str[_size] = '\0';
            return *this;
        }
        
        string& insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            //判断扩容
            size_t len = strlen(str);
            if (_size + pos > _capacity)
            {
                _str = increase(_size + pos);
            }
            //挪动数据
            int end = _size;
            while (end >= (int)pos)
            {
                _str[end + len] = _str[end];
                --end;
            }
            //插入数据
            for (size_t i = 0; i < len; ++i)
            {
                _str[pos++] = str[i];
            }
            _size += len;
            return *this;
        }

迭代器(iterator)

string的迭代器比较简单，本质就是一个指针


class string
{
    public:
        typedef char* iterator//定义迭代器 
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        //....
    private:
        char* _str;
}
//测试迭代器
    void test()
    {
        string s1("hello");
        string::iterator it = s1.begin();
        while (it != s1.end())
        {
            cout << *it << ' ';
            ++it;
        }
    }

查找(find)

查找字符


        size_t find(char ch, size_t pos = 0)//从pos位置开始往后找，找到返回下标
        {
            assert(pos >= 0);
            size_t i = pos;
            //找到返回下标
            while (i < _size)
            {
                if (_str[i] == ch)
                {
                    return i;
                }
                ++i;
            }
            //没找到返回npos，npos是静态成员变量默认值为-1
            return npos;
        }
        
          return npos;
        }
        size_t find(const char* str, size_t pos = 0)
        {
            assert (pos >= 0);
            char* tmp = strstr(_str + pos, str);
            if (tmp == NULL)
                return npos;
            else
                return tmp - _str; 
        }

operator<,==,<=,>,>=,!=


bool operator<(const string& s)
        {
            int i = strcmp(_str, s._str);
            if (i >= 0)
                return false;
            else
                return true;
        }
        bool operator==(const string& s)
        {
            int i = strcmp(_str, s._str);
            if (i == 0)
                return true;
            else
                return false;
        }
        bool operator<=(const string& s)
        {
            return *this < s || *this == s;
        }
        bool operator>(const string& s)
        {
            return !(* this <= s);
        }
        bool operator>=(const string& s)
        {
            return !(* this < s);
        }
        bool operator!=(const string& s)
        {
            return !(*this == s);
        }

删除(erase)


        void erase(size_t pos, size_t len = npos)//从pos位置开始删，删除len个字符
        {
            //第二种情况
            if (len >= _size - pos)//如果
            {
                _str[pos] = '\0';
                _size = pos;
            }
            //第一种情况
            else
            {
                for (size_t i = pos + len; i <= _size; ++i)
                {
                    _str[i - len] = _str[i];
                }
                _size -= len;
            }
        }

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

HBase详解（2）

HBase详解（2）

HBase 结构 HRegion 概述 在HBase中&#xff0c;会从行键方向上对表来进行切分&#xff0c;切分出来的每一个结构称之为是一个HRegion 切分之后&#xff0c;每一个HRegion会交给某一个HRegionServer来进行管理。HRegionServer是HBase的从节点&#xff0c;每一个HRegionServ…
阅读更多...
鸿蒙内核源码分析 (双向链表篇) | 谁是内核最重要结构体

鸿蒙内核源码分析 (双向链表篇) | 谁是内核最重要结构体

双向链表是什么&#xff1f; 谁是鸿蒙内核最重要的结构体 &#xff1f; 一定是: LOS_DL_LIST(双向链表)&#xff0c; 它长这样。 typedef struct LOS_DL_LIST {struct LOS_DL_LIST *pstPrev; /**< Current nodes pointer to the previous node | 前驱节点(左手)*/struct L…
阅读更多...
【开发环境搭建篇】安装Anaconda

【开发环境搭建篇】安装Anaconda

本文收录于 《Python编程入门》专栏&#xff0c;从零基础开始&#xff0c;介绍Python编程入门相关的内容&#xff0c;欢迎关注&#xff0c;谢谢&#xff01; 文章目录 一、前言二、下载三、安装四、配置环境变量五、创建虚拟环境六、总结 一、前言 学习Python编程&#xff0c;…
阅读更多...
什么是MQ ？为什么用MQ？

什么是MQ ？为什么用MQ？

什么是MQ&#xff1f; MQ(message queue)&#xff08;消息队列&#xff09;&#xff0c;从字面意思上看&#xff0c;本质是个队列&#xff0c;FIFO先入先出&#xff0c;只不过队列中存放的内容是message而已&#xff0c;还是一种跨进程的通信机制&#xff0c;用于上下游传递消息…
阅读更多...
C++分析程序各模块耗时-perf火焰图

C++分析程序各模块耗时-perf火焰图

C分析程序各模块耗时-perf火焰图 1. 简介2. 安装3. 测试示例4. 从火焰图可以获得的信息5. 生成火焰图常见问题 Reference: Perf Wiki【性能】perf 火焰图分析软件性能瓶颈【火焰图&#x1f525;】Linux C/C性能优化分析工具Perf使用教程 perf: Linux profiling with perform…
阅读更多...
如何用Java后端处理JS.XHR请求

如何用Java后端处理JS.XHR请求

Touching searching engine destroies dream to utilize php in tomcat vector.The brave isn’t knocked down&#xff0c;turn its path to java back-end. Java Servlet Bible schematic of interaction between JS front-end and Java back-end Question 如何利用Java…
阅读更多...
SKF的便携式分析系统简介

SKF的便携式分析系统简介

1.系统简介 SKF是知名的轴承供应商。它的行业知识文档非常丰富。这里摘录一下它的当前的振动分析系统。可以在构建自己的振动分析系统时参考。它的手机应用不知道是否与传感器绑定。国内下载不方便&#xff0c;我回头找找上传后把App链接留在这里。 SKF的振动分析系统&#x…
阅读更多...
JAVA—抽象—定义抽象类Converter及其子类WeightConverter

JAVA—抽象—定义抽象类Converter及其子类WeightConverter

同样&#xff0c;我们由这道题引出抽象类&#xff0c;抽象方法这个概念。 按下面要求定义类Converter及其子类WeightConverter 定义抽象类&#xff1a;Converter&#xff1a; 定义一个抽象类Converter&#xff0c;表示换算器&#xff0c;其定义的如下&#xff1a; 一个私有…
阅读更多...
SV学习笔记（五）

SV学习笔记（五）

文章目录 线程的使用程序和模块什么是线程线程的概念澄清 线程的控制fork并行线程语句块fork…joinfork…join_any等待所有衍生线程停止单个线程停止多个线程停止被多次调用的任务 线程的通信写在前面event事件通知的需求semaphore旗语mailbox信箱三种通信的比较和应用 参考资料…
阅读更多...
免疫检查点信号转导和癌症免疫治疗（文献）

免疫检查点信号转导和癌症免疫治疗（文献）

目录 基础 介绍 免疫检查点的表面调控&#xff08;细胞膜层面&#xff09; ​编辑 PD-1调节 PD-L1调节 CTLA-4 调节 检查点信号通路 关于靶点研究 展望 Immune checkpoint signaling and cancer immunotherapy - PubMed (nih.gov) 基础 【中英字幕】肿瘤免疫疗法之免…
阅读更多...
Java开发测试(第一篇)：Java测试框架JUnit5

Java开发测试(第一篇)：Java测试框架JUnit5

目录 1.基本介绍 2.maven中安装JUnit5 3.使用 4.JUnit5命名规则 5.JUnit5常用注解 6.JUnit5断言 7.JUnit5多个类之间的继承关系 8.JUnit5参数化 &#xff08;1&#xff09;使用场景&#xff1a; &#xff08;2&#xff09;使用前需在pom.xml文件中导入依赖 &#xff…
阅读更多...
蓝桥杯刷题-13-子矩阵-二维滑动窗口 ಥ_ಥ

蓝桥杯刷题-13-子矩阵-二维滑动窗口 ಥ_ಥ

给定一个 n m &#xff08;n 行 m 列&#xff09;的矩阵。 设一个矩阵的价值为其所有数中的最大值和最小值的乘积。求给定矩阵的所有大小为 a b &#xff08;a 行 b 列&#xff09;的子矩阵的价值的和。 答案可能很大&#xff0c;你只需要输出答案对 998244353 取模后的结果。…
阅读更多...
电力行业智能升级：IEC104网关在电网中的作用

电力行业智能升级：IEC104网关在电网中的作用

IEC104是国际电工委员会&#xff08;IEC&#xff09;制定的一套用于电力自动化的通信协议。通过IEC104规约可以实现实时监测电力系统的状态、采集各种数据、控制设备的运行和保护等功能&#xff0c;为电力系统的安全稳定运行提供了重要的支持。 钡铼技术IEC104网关可实现对IEC-…
阅读更多...
Java零基础入门-综合案例(File类+递归)

Java零基础入门-综合案例(File类+递归)

一、概述 java零基础教学也讲了一阵子了&#xff0c;从jdk安装到第一个java程序再到如今的java File类&#xff0c;递归思想等&#xff0c;不知道你们对于此教学有没有啥建议&#xff0c;毕竟看着浏览量不是很可人&#xff0c;所以在开启此篇前&#xff0c;我想统计一下&#x…
阅读更多...
MyBatis操作数据库(1)

MyBatis操作数据库(1)

前言 在应用分层的学习时, 我们了解到web应用程序一般分为三层,即Controller, Service, Dao. 之前的案例中, 请求流程如下: 浏览器发起请求, 先请求Controller, Controller接受到请求后,调用Service进行业务逻辑处理, Service再调用Dao, 但是Dao层的数据是Mock的, 真实的数据…
阅读更多...
JavaWeb后端——Mybatis

JavaWeb后端——Mybatis

概述 Mybatis&#xff1a;Java程序来对数据库进行操作&#xff0c;一款优秀的持久层框架&#xff0c;用于简化JDBC的开发 SSM&#xff1a;SpringMVC、Spring、Mybatis 快速入门 步骤2&#xff1a;注意数据库连接的四要素 application.properties&#xff1a;springboot 的默…
阅读更多...
pytorch 演示 tensor并行

pytorch 演示 tensor并行

pytorch 演示 tensor并行 一.原理二.实现代码 本文演示了tensor并行的原理。如何将二个mlp切分到多张GPU上分别计算自己的分块,最后做一次reduce。 1.为了避免中间数据产生集合通信,A矩阵只能列切分,只计算全部batch*seqlen的部分feature 2.因为上面的步骤每张GPU只有部分featu…
阅读更多...
布隆过滤器详解及java实现

布隆过滤器详解及java实现

什么是布隆过滤器&#xff1f; 布隆过滤器&#xff08;Bloom Filter&#xff09;是一种数据结构&#xff0c;用于判断一个元素是否属于一个集合。它的特点是高效地判断一个元素是否可能存在于集合中&#xff0c;但是存在一定的误判率。 布隆过滤器的基本原理是使用一个位数组…
阅读更多...
【STL学习】（4）vector的模拟

【STL学习】（4）vector的模拟

前言 本文将模拟实现vector的常用功能&#xff0c;目的在于更深入理解vector。 一、前置知识 在模拟之前先对vector的结构和常用接口学习&#xff0c;有一个大致了解。看源码&#xff0c;本文参考的源码是SGI版本的stl3.0。 技巧&#xff1a; 看源码不要一行一行的看&#xff…
阅读更多...
Severt

Severt

severt是让我们自己写一些类,然后把这些类给加载Tomcat中&#xff0c;后续Tomcat收到HTTP请求(来自于浏览器)&#xff0c;就会执行到咱们上面写的代码.从而通过这些代码,完成一定的业务逻辑. 创建项目 此处创建的是一种新的项目的形式称为Maven项目,Maven是Java 中的一个的构建…
阅读更多...
最新文章

Copyright @ 2022~2023