模拟实现my_string

已于 2022-03-04 14:09:25 修改
阅读量97 收藏
点赞数 4
分类专栏： C++ 文章标签： 蓝桥杯 c++ 散列表
于 2022-03-01 15:13:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52012656/article/details/123206765
版权

实现一个my_string

前言

在实现string类之前我们需要知道string是表示字符串的字符串类，在命名空间std中，若直接定义string会造成命名冲突，所以我们需要重新定义一个命名空间，在这个命名空间中去写自己的string,例：

namespace ztl{
    calss string{
    public:
        //下面实现的功能都是放在这的
    private：
        char* _str;        //字符串指针
        size_t _capacity;  //字符串容量
        size_t _size;      //字符串有效字符个数
    };
}

初始化与清理

构造函数

string(const char* str="")
    :_size(strlen(str))
    ,_capacity(strlen(str))
{
    _str=new char[_capacity+1]; //申请连续空间，但是要额外给\0留一个空间
    strcpy(_str,str);  //拷贝字符串内容（值拷贝）
}

析构函数

~string()
{
    delete[] _str;
    _str=nullptr;
    _size=_capacity=0;
}

拷贝构造

注意这里牵扯到了一个新概念，深浅拷贝，拷贝构造不能使用编译器默认生成的，否则运行时会崩溃,必须使用深拷贝。

浅拷贝也叫作值拷贝，比如说一个指针对象使用浅拷贝拷贝的话，就会存在两个指针指向同一块空间，在出了作用域之后，会自动调用析构函数就会存在两个析构函数取释放同一块空间。

深拷贝的话就是把指针指向的空间一块拷贝一份，然后各自指向各自的空间，就不会出现上面浅拷贝的情况。

//传统写法
string (const string& s)
{
    char* tmp=new char[s._capacity+1];
    strcpy(tmp,s._str);
    delete[] _str;
    _str=tmp;
    _size=s._size;
    _capacity=s._capacity;
}
//现代写法
string (const string& s)
    :_str(nullptr)
    ,_size(s.size)
    ,_capacity(s._capacity)
{
    char* tmp=s._str;
    swap(_str,tmp);
}

这里传统写法与现代写法的区别在于传统写法是自己动手完成工作，而现代写法则是创建了一个临时变量，让它帮我完成，我只需要在它完成之后，让它与我交换。

清除

void clear()
{
    _str[0]='\0';
    _size=0;
}

这里只需要将首字符设置为\0；然后修改字符个数，容量不变，clear的功能只是将字符串清空，并不删除容量。

运算符重载

赋值运算符

它与拷贝构造函数一样要实现深拷贝。

//传统写法
string& operator=(string& s)
{
    char* tmp=new char[s._capacity+1];
    strcpy(tmp,s._str);
    delete[] _str;
    _str=tmp;
    _size=s._size;
    _capacity=s._capacity;
    return *this;
}
//现代写法
//注意这里不能够传引用，否则会改变原字符串
string& operator=(string s)
{
    swap(_str,s._str);
    _size=s._size;
    _capacity=s.capacity;
    return *this;
}

其他运算符

//这里比较字符串的重载如果是在类里面定义的就可以使用strcmp函数会方便很多，但是在类外的话就不行了，主要要调用私有成员变量。

    //<运算符
    bool operator<(const String& s){
        size_t i = _size;
        size_t c = s._size;
        if (i == 0 && c == 0){
            return false;
        }
        size_t num = 0;
        while (i&&c){
            if (_str[num] < s._str[num]){
                return true;
            }
            else if(_str[num]>s._str[num]){
                return false;
            }
            else{
                i--;
                c--;
                num++;
            }
        }
        if (i == 0&&c!=0){
            return true;
        }
        return false;
    }
​
//在类里定义，下面自己类推。
    bool operator<(const String& s){
        return strcmp(_str,s._str)<0;
    }
​
​
    //==运算符
    bool operator==(const String& s){
        size_t i = _size;
        size_t c = s._size;
        int num = 0;
        while (i&&c){
            if (_str[num] != s._str[num]){
                return false;
            }
            i--;
            c--;
            num++;
        }
        if (c || i){
            return false;
        }
        return true;
    }
    //<=运算符
    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);
    }
    //+=字符运算符
    String& operator+=(char c){
        PushBack(c); //尾插
        return *this;
    }
    //+=字符串运算符
    String& operator+=(const char* str){
        Append(str);   //尾插字符串
        return *this;
    }
    //[]运算符
    char& operator[](size_t index){
        return _str[index];
    }
    const char& operator[](size_t index)const{
        return _str[index];
    }

迭代器

迭代器

在string中的迭代器就是一个指针，但是在后面学习的vector等就不单纯是一个指针了。

typedef char* iterator
iterator begin()
{
    return _str;
}
iterator end()
{
    return _str+_size;
}

const迭代器

typedef const char* const_iterator;
const_iterator begin()const{
    return &_str[0];
}
const_iterator end()const{
    return &_str[_size];
}

其他操作

扩容

//容量扩容
void reserver(size_t n)
{
    if(n>_capacity)
    {
        char* tmp=new char[n+1];
        strcpy(tmp,_str);
        delete[] _str;
        
        _str=tmp;
        _capacity=n;
    }
}
​
//大小扩容
void resize(size_t n.char ch="\0")
{
    if(n<_size)
    {
        _size=n;
        _str[_size]='\0';
    }
    else
    {
        if(n>_capacity)
        {
            reverse(n);
        }
        memset(_str+_size,ch,n-size);
        _size=n;
        _str[_size]='\0';
    }
}

插入，删除字符/字符串

//插入一个字符
string& insert(sizt_t pos,char ch)
{
    assert(pos<=_size);
    
    if(_size==_capacity)
    {
        reserver(_capacity==0?16:_capacity*2);
    }
    //挪动一格将pos位置之后的数据
    size_t end=_size+1;
    
    while(end>pos)
    {
        _str[end]=_str[end-1];
        --end;
    }
    _str[pos]=ch;
    ++_size;
    return *this;
}
​
//插入一个字符串
string& insert(sizt_t pos,const char* s)
{
    assert(pos<=_size);
    size_t len=strlen(s);
    if(_size+len>_capacity)
    {
        reserve(_size+len);
    }
    //挪动len将pos位置之后的数据
    size_t end=_size+len;
    
    while(end>pos)
    {
        _str[end]=_str[end-len];
        --end;
    }
    strncpy(_str+pos,s,len);
    _size+=len;
    return *this;
}
​
//尾插一个字符
void push_back(char s)
{
    if(_size>=_capacity){
        size_t new_c=_capacity==0?16:_capacity*2;
        reserve(new_c);
    }
    _str[_size++]=s;
    _str[_size]='\0';
}
​
//尾插字符串
void appent(char* str)
{
    size_t len=strlen(str);
    if(_size+len>=_capacity)
    {
        reserve(_size+len);
    }
    for(size_t i=0;i<len;i++)
    {
        push_back(str[i]);
    }
}
//删除pos位置上的字符
string& erase(size_t pos=0,size_t len=npos)
{
    assert(pos<_size);
    if(len==npos||pos+len>=_size)
    {
        _str[pos]='\0';
        _size=pos;
    }
    else{
        strcpy(_str+pos,_str+pos+len);
        _size-=len;
    }
    return *this;
}

查找

//返回字符c在字符串中第一次出现的位置
size_t find(char c,size_t pos=0)
{
    while(pos<_size)
    {
        if(_str[pos]==c)
        {
            return pos;
        }
        pos++;
    }
    return npos;
}
​
//返回字符串s在字符串中出现的位置
size_t find(const char* s,size_t pos)
{
    const char* ptr=strstr(_str+pos,s);
    if(ptr==nullptr)
        return npos;
    else
        return ptr-_str;
}

判空以及其他接口的实现

bool enpty()
{
    return _size==0;
}
​
//有效字符个数
size_t size()
{
    return _size;
}

重载输入输出符

class string{
public:
    friend ostream& operator<<(ostream& _cout,const string &s);
    friend istream& operator>>(istream& _cin,string& s);
}
ostream& operator<<(ostream& _cout,const string &s)
{
    _cout<<s._str;
    return _cout;
}
istream& operator>>(istream& _cin,string& s)
{
    _cin>>s._str;
    return _cin;
}

源码：

#pragma once
#include<iostream>
#include<cassert>
#include<string>
namespace ztl
{
    using namespace std;
    class string
    {
        friend ostream& operator<<(ostream& _cout, const ztl::string& s);
        friend istream& operator>>(istream& _cin, ztl::string& s);
    public:
        typedef char* iterator;
    public:

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

        //拷贝构造（现代写法）
        string(const string& s)
            :_size(strlen(s._str))
            , _capacity(_size)
        {
            _str = nullptr;
            string tem(s._str);
            swap(tem);
        }
        //复制拷贝
        string& operator=(const string& s)
        {
            if (this != &s)
            {
                string tmp(s);
                swap(tmp);
            }
            return *this;
        }
        //析构函数
        ~string()
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }

        // iterator正向迭代器

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }
        //扩容
        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];//给\0留一个空间
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }

        // modify
        void push_back(char c)
        {
            if (_size == _capacity)
            {
                reserve(_capacity == 0 ? 15 : _capacity * 2);
            }
            _str[_size] = c;
            ++_size;
            _str[_size] = '\0';
            //insert(_size, c);
        }

        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }

        void append(const char* str)
        {
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve(_size + len);
            }
            strcpy(_str + _size, str);
            _size += len;
        }

        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }

        void clear()
        {
            _str[0] = '\0';
            _size = 0;
        }

        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }

        const char* c_str()const
        {
            return _str;
        }

        // capacity

        size_t size()const
        {
            return _size;
        }

        size_t capacity()const
        {
            return _capacity;
        }

        bool empty()const
        {
            if (_str[0
            ] != '\0')
            {
                return false;
            }
            return true;
        }

        void resize(size_t n, char c = '\0')
        {
            if (n <= _size)
            {
                _size = n;
                _str[_size] = '\0';
            }
            else
            {
                if (n > _capacity)
                {
                    reserve(n);
                }
                memset(_str + _size, c, n - _size);
                _size = n;
                _str[_size] = '\0';
            }
        }

        //void reserve(size_t n)
        //{
        //    if (n > _capacity)
        //    {
        //        char* tmp = new char[n + 1];//给\0留一个空间
        //        strcpy(tmp, _str);
        //        delete[] _str;
        //        _str = tmp;
        //        _capacity = n;
        //    }
        //}

        // access

        char& operator[](size_t index)
        {
            assert(index < _size);
            return *(_str + index);
        }

        const char& operator[](size_t index)const
        {
            assert(index < _size);
            return *(_str + index);
        }

        //relational operators

        bool operator<(const string& s)
        {
            if (strcmp(_str, s._str) < 0)
                return true;
            return false;
        }

        bool operator<=(const string& s)
        {
            if (strcmp(_str, s._str) <= 0)
                return true;
            return false;
        }

        bool operator>(const string& s)
        {

        }

        bool operator>=(const string& s)
        {
            if (strcmp(_str, s._str) >= 0)
                return true;
            return false;
        }

        bool operator==(const string& s)
        {
            if (strcmp(_str, s._str) == 0)
                return true;
            return false;
        }

        bool operator!=(const string& s)
        {
            if (strcmp(_str, s._str) != 0)
                return true;
            return false;
        }



        // 返回c在string中第一次出现的位置
        size_t npos = -1;
        size_t find(char c, size_t pos = 0) const
        {
            for (size_t i = 0; i < _size; ++i)
            {
                if (c == _str[i])
                {
                    return i;
                }
            }

            return npos;
        }

        // 返回子串s在string中第一次出现的位置

        size_t find(const char* s, size_t pos = 0) const
        {
            char* ptr = strstr(_str + pos, s);
            if (ptr == nullptr)
            {
                return npos;
            }
            else
                return ptr - _str;
        }

        // 在pos位置上插入字符c/字符串str，并返回该字符的位置

        string& insert(size_t pos, char c)
        {
            assert(pos <= _size);
            if (pos == _capacity)
            {
                reserve(_capacity == 0 ? 15 : _capacity * 2);
            }
            size_t end = _size + 1;
            while (end > pos)
            {
                _str[end] = _str[end - 1];
                end--;
            }
            _str[pos] = c;
            _size++;
            return *this;
        }

        string& insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            size_t len = strlen(str);
            if ((pos + len) > _capacity)
            {
                reserve(_size + len);
            }
            size_t end = _size + len;
            while (end > pos + len)
            {
                _str[end] = _str[end - len];
                end--;
            }
            strncpy(_str + pos, str, len);
            return *this;
        }
        // 删除pos位置上的元素，并返回该元素的下一个位置

        string& erase(size_t pos, size_t len)
        {
            assert(pos < _size);
            if (len == pos || pos + len > _capacity)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
            return *this;

        }

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

    ostream& operator<<(ostream& _cout, const ztl::string& s)
    {
        cout << s._str;
        return _cout;
    }
    //可以cin给string赋值
    istream& operator>>(istream& _cin, ztl::string& s)
    {
        //如果原来的字符串有内容，就先干掉
        if (s._str != NULL)
        {
            delete[] s._str;
            s._str = NULL;
            s._size = 0;
        }
        //设置缓存
        char temp[2048] = { 0 };
        cout << "输入字符串:" << endl;
        cin >> temp;
        int len = strlen(temp);
        s._str = new char[len + 1];
        //拷贝字符串
        for (int i = 0; i <= len; i++)
        {
            s._str[i] = temp[i];
        }
        s._size = len;
        return _cin;
    }
    void test1()
    {
        ztl::string s1("hello");
        cout << s1 << endl;
        ztl::string s2("uuuu");
        cout << s2 << endl;
        s2 = s1;
        cout << s2 << endl;
        s1.clear();
        string s3(s1);
        cout << s3 << endl;
        s2.push_back('a');
        s2.insert(0,'a');
        cout << s2 << endl;
    }

};

m0_52012656
关注
专栏目录
string的模拟实现
qq_65285898的博客
12-11 953
STL首个类的模拟实现
模拟实现string库函数
RONIN_WZ的博客
04-21 983
01 模拟实现strlen函数 02 模拟实现strcpy函数 03 模拟实现strncpy函数 04 模拟实现strcat函数 05 模拟实现strncat函数 06 模拟实现strcmp函数 07 模拟实现strncmp函数
初识《string》及手搓模拟实现《string》
weixin_72917087的博客
03-31 1118
在之前的学习中，我们初步了解到了模板的概念，而接下来又对于C++的标准模板库（STL）也有了基本的概念。对于C++的武器，我们不得不进行学习，日后有了这些STL武器的帮助，对于大部分题目我们都能游刃有余。以上就是string的部分内容，在这里我只对于重要的部分进行讲解，string这个库有许多自带的函数，下来可以自己动手尝试尝试实现。
C语言：模拟实现printf函数——my_printf函数哦
peter——wang的博客
11-14 2812
#define _CRT_SECURE_NO_WARNINGS 10 #include<stdio.h> #include<stdarg.h> #include<stdlib.h> #include<assert.h> #include<string.h>//int printf( const char *format [, argument]... ); //模拟实现printf函数，可以实现my
用reverse_string实现字符串的逆置
qq_42627691的博客
02-22 574
用reverse_string实现字符串的逆置 1.非递归实现 #include<assert.h> int my_Strlen(const char* str)//模拟实现strlen { int count = 0; assert(str != NULL);//断言 while (*str++ != '\0') { count++; } return count; ...
C语言string.h函数详解及部分模拟实现
m0_73900674的博客
03-23 8211
一键获取string.h函数解析
C语言实现各类string函数
qq_43632625的博客
06-21 5316
1.实现strcpy（字符串复制） 函数原型：char strcpy(char dest, const char src); strcpy把含有’\0’结束符的字符串复制到另一个地址空间，返回值的类型为char。 代码： #include<stdio.h> #include<windows.h> #include<assert.h> char* my_st...
(C++ STL)string类的简单模拟实现与源码展示
瞌睡不来的博客
08-29 894
string类的简单模拟实现与源码展示
自己模拟strcpy库函数写的功能函数my_strcpy实现strcpy的功能，完整代码
桔子
10-04 1250
#include <string.h> #include <stdio.h> #include <windows.h> #include <assert.h> char * my_srecpy(char *pdest,const char *psrc) { char *ret = pdest; assert(pdest!=NULL); assert(psrc != NULL)
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5302
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
常见字符串函数和内存函数模拟实现
m0_62171658的博客
02-27 433
本章目的： 模拟实现字符串函数：strlen、strcmp、strcat、strcpy、strstr、strncmp、strncat、strncpy 介绍strtok、strerror的使用 模拟实现内存函数：memcpy、memmove、memset、memcmp strlen模拟实现 size_t my_strlen(const char* str) { assert(str); if (*str == '\0') { return 0; } return 1 + strl
string.h的部分函数使用及模拟实现
m0_64238771的博客
01-18 289
strlen strcpy strncpy strcat strncat strcmp strncmp strstr strtok strerror perror memcpy memmove memcmp memset
js string format 模拟实现c++
08-09
const formattedString = format('My name is {0} and I am {1} years old.', name, age); console.log(formattedString); // 输出: "My name is John and I am 30 years old." ``` 在这个示例中，我们传递了两个...
some 蓝桥杯题
最新发布
2301_80160438的博客
10-02 1337
【代码】some 蓝桥杯题。
蓝桥杯【物联网】零基础到国奖之路:十六. 扩展模块之矩阵按键
weixin_74769854的博客
10-01 800
进行了扩展模块矩阵按键的练习
蓝桥杯:求平均年龄
aqua3535742358的博客
09-29 264
printf("平均年龄：%.2f", sum/num);printf("请输入总人数: ");
蓝桥杯—STM32G431RBT6(IIC通信--EEPROM(AT24C02)存储器进行通信)
JK03820的博客
10-02 908
IIC （IIC 是半双工通信总线。半双工意味着数据在某一时刻只能沿一个方向传输，即发送数据的时候不能接收数据，接收数据的时候不能发送数据）即集成电路总线（Inter-Integrated Circuit），是一种多主机的串行通信总线.它由飞利浦公司在 20 世纪 80 年代开发，主要用于连接微控制器及其外围设备。IIC 总线具有简单、高效、支持多设备连接等特点，在电子电路设计中被广泛应用。“一主多从” 是一种通信架构模式。在这种模式中，有一个主要的设备（称为主设备），它具有控制和发起通信的能力；
24.2.29蓝桥杯|单位换算--8道题
weixin_47011416的博客
09-29 587
本篇或者本系列文章使用蓝桥云课平台，借助CSDN梳理思路，给自己做一个电子笔记。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值