0
0

C++ string类的模拟实现

文章目录

前言：模拟实现string类之前先思考下需要实现哪些接口功能呢？

1.string类的迭代器。

2.string类的构造函数、析构函数、拷贝构造函数、赋值运算符重载。

3.管理字符串的数组，可以增删查改，具体包括reverse、resize、push_back、append、insert、erase、find、clear、getline接口的实现。

4.[]、+=、<、<=、==、>、>=、！=、<<、>>运算符重载。

提示：重点是string类的四个默认成员函数以及增删查改的实现。

string类的结构定义

class string
{
public:

private:
    char* _str;

    size_t _size;
    size_t _capacity;

    static const size_t npos;
};

补充下npos是什么，简单理解就是无符号整型中的-1

image-20220212232830084

1.string类迭代器的实现

这里string类的迭代器完全可以简单理解成指针实现、包括vector也是类似，但是到了后边的容器会有所不同。

这里只需要注意一下end( )代表什么：

image-20220213131213547

class string
{
public:
    typedef char* iterator;
        typedef const char* const_iterator;

        iterator begin()
        {
            return _str;
        }

        const_iterator begin() const
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

        const_iterator end() const
        {
            return _str + _size;
        }
        
};

2.string类的构造、析构、拷贝构造、赋值运算符重载

2.1 string类的构造函数

string(const char* str = "")
{
    _size = strlen(str);
    _capacity = _size;
    _str = new char[_capacity + 1];//给_str一个strlen(s)+1长度的空间

    strcpy(_str, str);//拷贝
}

2.2 string类的析构函数

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

2.3 string类的拷贝构造函数

传统和现代两种写法

// s1.swap(s2);
void swap(string& s)
{
    //交换_s和tmp._s,就相当于给this->_s开辟了一块空间,当拷贝函数结束,tmp就会被自动释放
    ::swap(_str, s._str);
    ::swap(_size, s._size);
    ::swap(_capacity, s._capacity);
}

//传统写法
//s2(s1)
string(const string& s)
    :_str(new char[strlen(s._str)+1])
{
    strcpy(_str, s._str);
}

// s2(s1)  现代写法
string(const string& s)
    :_str(nullptr)//必须置空,因为_str开始是个随机数,交换给tmp._str后,释放会引起问题
    , _size(0)
    , _capacity(0)
{
    string tmp(s._str);//直接利用构造函数,给tmp对象开辟了一块空间

    //this->swap(tmp);
    swap(tmp);
}

2.4 string类的赋值运算符重载

传统和现代两种写法

// s1 = s3 传统写法
string& operator=(const string& s)
{
    if (this != &s) // s1 = s1
    {
        delete[] _str;
        _str = new char[strlen(s._str) + 1];
        strcpy(_str, s._str);
    }

    return *this;
}

// s1 = s3 现代写法
string& operator=(string s)
{
    swap(s);//这个swap是咱们自己写的哦

    return *this;
}

3.管理字符串的数组，可以增删查改

具体包括reverse( )、resize( )、push_back( )、append( )、insert( )、erase( )、find( )、clear( )、getline( )、size( )、c_str( )接口的实现。

3.1 reverse( ) 接口实现

// 开空间，扩展capacity
void reserve(size_t n)
{
    if (n > _capacity)
    {
        char* tmp = new char[n + 1];//注意哦~,这里必须要多开一个空间存储\0
        strncpy(tmp, _str, _size + 1);//多开的那个空间存储位置
        delete[] _str;

        _str = tmp;
        _capacity = n;
    }
}

3.2 resize( ) 接口实现

resize( ) 分为三种情况

  • 当n小于size,则size等于n.
  • 当n>size但是小于capacity时,size仍等于n,但是这个时候即使你传入另一个参数ch,也没有用
  • 当n大于size时候,会增容,然后多出的空间会用ch初始化,ch如果不传,就是\0,最后size等于n,
// 开空间+初始化，扩展capacity 并且初始化空间。size也要动
void resize(size_t n, char val = '\0')
{
    if (n < _size)
    {
        _size = n;
        _str[_size] = '\0';
    }
    else
    {
        if (n > _capacity)
        {
            reserve(n);
        }

        for (size_t i = _size; i < n; ++i)
        {
            _str[i] = val;
        }
        _str[n] = '\0';
        _size = n;
    }
}

image-20220213004714481

3.3 push_back( ) 接口实现

push_back( ) 针对的是字符

void push_back(char ch)
{
    if (_size == _capacity)
    {
        //这一步是为了防止_capacity如果为0,开不了空间
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    _str[_size] = ch;
    _str[_size + 1] = '\0';//给字符串末尾加\0
    ++_size;

    //insert(_size, ch);  //或者直接调用insert()
}

3.4 append( ) 接口实现

append( )针对的是字符串

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

    strcpy(_str + _size, str);
    _size = len;*/

    insert(_size, str);
}

image-20220213004750650

3.5 insert( ) 接口实现

包括字符和字符串的插入，需要写两个版本。

//插入字符
string& insert(size_t pos, char ch)
{
    assert(pos <= _size);
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
    }
    // 类型强制转换成int，使用size_t的话，就永远走不出循环了（因为无符号整型的-1）
    /*int end = _size;
    while (end >= (int)pos)
    {
        _str[end + 1] = _str[end];
        --end;
    }*/

    char* end = _str + _size;
    while (end >= _str + pos)
    {
        *(end + 1) = *end;
        --end;
    }

    _str[pos] = ch;
    _size++;

    return *this;
}

//在pos位置之前插入字符串
string& insert(size_t pos, const char* str)
{
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        reserve(_size + len);
    }

    // 挪动数据
    char* end = _str + _size;
    while (end >= _str + pos)
    {
        *(end + len) = *end;
        --end;
    }

    strncpy(_str + pos, str, len);
    _size += len;

    return *this;
}

3.6 erase( ) 接口实现

image-20220213004834914

从

pos

位置开始删除,

len

个,如果

len

不写,末尾删除

pos

后的全部

string& erase(size_t pos, size_t len = npos)
{
    assert(pos < _size);
    size_t leftLen = _size - pos;
    // 1、剩余的字符长度小于要删的长度  （后面全部删完）
    // 2、剩余的字符长度大于要删的长度
    if (len >= leftLen)
    {
        _str[pos] = '\0';
        _size = pos;
    }
    else
    {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
    }

    return *this;
}

3.7 find( ) 接口实现

image-20220213004853130

包括字符和字符串的查找，需要写两个版本。

size_t find(char ch, size_t pos = 0)
{
    assert(pos < _size);

    for (size_t i = pos; i < _size; ++i)
    {
        if (_str[i] == ch)
        {
            return i;
        }
    }

    return npos;
}

size_t find(const char* str, size_t pos = 0)
{
    assert(pos < _size);

    const char* ret = strstr(_str + pos, str);
    if (ret)
    {
        return ret - _str;
    }
    else
    {
        return npos;
    }
}

3.8 clear( ) 接口实现

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

3.9 getline( ) 接口实现

istream& getline(istream& in, string& s)
{
    s.clear();

    char ch;
    ch = in.get();
    while (ch != '\n')
    {
        s += ch;
        ch = in.get();
    }

    return in;
}

3.10 size( ) 接口实现

size_t size() const
{
    return _size;
}

3.11 c_str( ) 接口实现

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

4.[]、+=、<、<=、==、>、>=、！=、<<、>>运算符重载。

4.1 [] 运算符重载

image-20220213004909361

在c++中,string的operator[]有两个重载,分别是:

  • char& operator[] (size_t pos); //支持读和写
  • const char& operator[] (size_t pos) const; //只支持读
// 读
const char& operator[](size_t i) const
{
    assert(i < _size);

    return _str[i];
}

// 可读，可写
char& operator[](size_t i)
{
    assert(i < _size);

    return _str[i];
}

4.2 == 运算符重载

inline bool operator==(const string& s1, const string& s2)
{
    return strcmp(s1.c_str(), s2.c_str()) == 0;
}

4.3 += 运算符重载

image-20220213004814071

// s1 += 'x'  针对字符
string& operator+=(char ch)
{
    push_back(ch);
    return *this;
}

// s1 += "xxxxx" 针对字符串
string& operator+=(const char* str)
{
    append(str);
    return *this;
}

4.4 < 运算符重载

inline bool operator<(const string& s1, const string& s2)
{
    return strcmp(s1.c_str(), s2.c_str()) < 0;
}

4.4 <= 运算符重载

inline bool operator<=(const string& s1, const string& s2)
{
    return s1 < s2 || s1 == s2;
}

4.5 > 运算符重载

inline bool operator>(const string& s1, const string& s2)
{
    return !(s1 <= s2);
}

4.6 >= 运算符重载

inline bool operator>=(const string& s1, const string& s2)
{
    return !(s1 < s2);
}

4.7 != 运算符重载

inline bool operator!=(const string& s1, const string& s2)
{
    return !(s1 == s2);
}

4.8 << 运算符重载

ostream& operator<<(ostream& out, const string& s)
{
    for (auto ch : s)
    {
        out << ch;
    }

    return out;
}

4.9 >> 运算符重载

istream& operator>>(istream& in, string& s)
{
    s.clear();

    char ch;
    ch = in.get();
    while (ch != ' ' && ch != '\n')
    {
        s += ch;
        ch = in.get();
    }

    return in;
}

5.代码仓库

源码链接

小结一下：

image-20220213125458196

感谢您的阅读！！！如果内容对你有帮助的话，记得给我三连（点赞、收藏、关注）——做个手有余香的人。

标签： c++ 开发语言 后端
本文转载自: https://blog.csdn.net/weixin_48953972/article/details/122908123
版权归原作者 林慢慢脑瓜子嗡嗡的 所有， 如有侵权，请联系我们删除。
登录后发布评论

“C++ string类的模拟实现”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航