AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++STL精讲】string的模拟实现

2023-04-18 87
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C++STL精讲】string的模拟实现

0000000000000000000000000000000000000000000000000000000.png

目录

定义string类

构造函数

拷贝构造函数

赋值重载

析构函数

[]操作符重载

比较运算符重载

c_str、size、capacity

resize与reserve

添加数据 - push_back、append、+=重载

insert

erase

find

swap

clean

迭代器

>> 与 << 重载

完整源码


文章导读

本章我们将参照STL源码，来模拟实现string类，但不一定非要与库中完全相同。我们将其中重要的、常用的接口进行模拟实现，旨在加深string类的学习与记忆。


正文

定义string类


为了区别于标准库中的string类，我们使用自己的命名空间，在自己命名空间中模拟实现string类。

string类包含这三个基本成员：

  • char* _str 字符数组；
  • size_t _size 大小；
  • size_t _capacity 容量；

此外还需声明一个static成员npos，npos为将来实现的某些成员函数的缺省值，值位-1；

namespace hxy
{
  class string
  {
  public:
    //...
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
    //类中进行声明
    static const size_t npos;
  }
  //类外定义npos
  const size_t string::npos = -1;
}


构造函数


string类提供两种构造方法：

  • 直接构造；
string str;
• 1
  • 传字符串构造；
string str("hello world");
  • 对于传字符串构造的情况，我们可以实现用const char* str 来接收它；
  • 对于直接构造的情况，我们可以用缺省值来解决；
  //构造函数
  string(const char* str = "")  //使用缺省值
    :_size(strlen(str))
  {
    _capacity = _size == 0 ? 3 : _size;  //_capacity初始值不能为0
    _str = new char[_capacity + 1];  //为'\0'预留位置
    strcpy(_str, str);
  }

注意

  • _capacity的值不能初始化为0，因为扩容时可能出现0*n=0的情况。

拷贝构造函数


我们还会遇到用string类对象进行构造的情况：

string s1;
  string s2(s1);

拷贝构造虽然不写，编译器会自动实现，但是自动实现的拷贝构造为浅拷贝，对于string类中，成员变量会申请资源的情况，浅拷贝是行不通的，所以需要我们自己实现。

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


赋值重载


  string s1;
  string s2 = s1;

  //赋值重载
  string& operator=(const string& s)
  {
    if (this != &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()
  {
    delete[] _str;
    _str = nullptr;
    _size = _capacity = 0;
  }


[]操作符重载


注意应对const对象与非const对象须实现不同的重载函数。

  //用于const对象只读
  const char& operator[](size_t pos) const
  {
    assert(pos < _size);
    return _str[pos];
  }
  //用于普通对象可读可写
  char& operator[](size_t pos)
  {
    assert(pos < _size);
    return _str[pos];
  }


比较运算符重载


  //比较运算符重载
  bool operator>(const string& s) const
  {
    return strcmp(_str, s._str) > 0;
  }
  bool operator==(const string& s) const
  {
    return strcmp(_str, s._str) == 0;
  }
  bool operator>=(const string& s) const
  {
    return *this > s && *this == s;
  }
  bool operator<(const string& s) const
  {
    return !(*this >= s);
  }
  bool operator<=(const string& s) const
  {
    return !(*this > s);
  }
  bool operator!=(const string& s) const
  {
    return !(*this == s);
  }


c_str、size、capacity


  • c_str：返回C风格的字符串。
  • size：返回_size；
  • capacity：返回_capacity；
  const char* c_str()
  {
    return _str;
  }
  size_t size() const
  {
    return _size;
  }
  size_t capacity() const
  {
    return _capacity;
  }


resize与reserve


  • resize：扩容并初始化；
  • reserve：只扩容；
  void resize(size_t n, char ch = '\0')
  {
    if (n < _size)
    {
      _str[n] = '\0';
      _size = n;
    }
    else if (n > _size)
    {
      if (n > _capacity)
      {
        reserve(n);
      }
      size_t i = _size;
      while (i < n)
      {
        _str[i] = ch;
        ++i;
      }
      _size = n;
      _str[_size] = '\0';
    }
  }
  void reserve(size_t n)
  {
    if (n > _capacity)
    {
      char* tmp = new char[n + 1];
      strcpy(tmp, _str);
      delete _str;
      _str = tmp;
      _capacity = n;
    }
  }


添加数据 - push_back、append、+=重载


  • push_back：尾插一个字符；
  • append：尾插一个字符串；
  • +=：尾插一个字符或字符串；
  void push_back(char ch)
  {
    //考虑扩容
    if (_size + 1 > _capacity)
    {
      reserve(_capacity * 2);
    }
    _str[_size] = ch;
    _size++;
    _str[_size] = '\0';
  }
  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+=(char ch)
  {
    push_back(ch);
    return *this;
  }
  string& operator+=(const char* str)
  {
    append(str);
    return *this;
  }


insert


  • insert：在pos位置插入一个字符或字符串；
  string& insert(size_t pos, char ch)
  {
    assert(pos <= _size);
    if (_size + 1 > _capacity)
    {
      reserve(_capacity * 2);
    }
    size_t end = _size + 1;
    while (end > pos)
    {
      _str[end] = _str[end - 1];
      end--;
    }
    _str[pos] = ch;
    ++_size;
    return *this;
  }
  string& insert(size_t pos, const char* str)
  {
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
      reserve(_size + len);
    }
    //挪动数据
    size_t end = _size + len;
    while (end > pos + len - 1)
    {
      _str[end] = _str[end - len];
      end--;
    }
    strncpy(_str + pos, str, len);
    _size += len;
    return *this;
  }


erase


  • erase：删除pos位置向后的n个字符；
  string& erase(size_t pos, 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;
  }


find


  • find：从pos位置开始向后查找指定字符或字符串，并返回起始位置的下标。
  size_t find(char ch, size_t pos = npos)
  {
    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 = npos)
  {
    assert(pos < _size);
    char* p = strstr(_str, str);
    if (p == nullptr)
    {
      return npos;
    }
    else
    {
      return p - str;
    }
  }


swap


  • swap：交换两个对象的内容；
  void swap(string& s)
  {
    std::swap(_str, s._str);
    std::swap(_size, s._size);
    std::swap(_capacity, s._capacity);
  }


clean


  • clean：清理数据；
  void clean()
  {
    _str[0] = '\0';
    _size = 0;
  }


迭代器


有了迭代器，我们就能对自己实现的类使用范围for了。

  //迭代器
  typedef char* iterator;
  typedef const char* const_iterator;
  iterator begin()
  {
    return _str;
  }
  iterator end()
  {
    return _str + _size;
  }
  const_iterator begin() const
  {
    return _str;
  }
  const_iterator end()const
  {
    return _str + _size;
  }


>> 与 << 重载


注意这两个函数须定义在类外。

    ostream& operator<<(ostream& out, const string& str)
  {
    for (auto ch : str)
    {
      out << ch;
    }
    return out;
  }
  istream& operator>>(istream& in, string& str)
  {
    str.clean();
    char ch = in.get();
    char buff[128]; //避免因频繁扩容导致效率过低
    size_t i = 0;
    while (ch != ' ' && ch != '\n')
    {
      buff[i++] = ch;
      if (i == 127)
      {
        buff[127] = '\0';
        str += buff;
        i = 0;
      }
      ch = in.get();
    }
    if (i != 0)
    {
      buff[i] = '\0';
      str += buff;
    }
    return in;
  }


完整源码


#pragma once
#include<assert.h>
#include<iostream>
namespace hxy
{
  class string
  {
  public:
    //迭代器
    typedef char* iterator;
    typedef const char* const_iterator;
    iterator begin()
    {
      return _str;
    }
    iterator end()
    {
      return _str + _size;
    }
    const_iterator begin() const
    {
      return _str;
    }
    const_iterator end()const
    {
      return _str + _size;
    }
    //构造函数
    string(const char* str = "")  //使用缺省值
      :_size(strlen(str))
    {
      _capacity = _size == 0 ? 3 : _size;  //_capacity初始值不能为0
      _str = new char[_capacity + 1];  //为'\0'预留位置
      strcpy(_str, str);
    }
    //拷贝构造
    string(const string& s)
      :_size(s._size)
      , _capacity(s._capacity)
    {
      _str = new char[_capacity + 1];
      strcpy(_str, s._str);
    }
    //赋值重载
    string& operator=(const string& s)
    {
      if (this != &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()
    {
      delete[] _str;
      _str = nullptr;
      _size = _capacity = 0;
    }
    const char* c_str()
    {
      return _str;
    }
    //用于const对象只读
    const char& operator[](size_t pos) const
    {
      assert(pos < _size);
      return _str[pos];
    }
    //用于普通对象可读可写
    char& operator[](size_t pos)
    {
      assert(pos < _size);
      return _str[pos];
    }
    size_t size() const
    {
      return _size;
    }
    size_t capacity() const
    {
      return _capacity;
    }
    //比较运算符重载
    bool operator>(const string& s) const
    {
      return strcmp(_str, s._str) > 0;
    }
    bool operator==(const string& s) const
    {
      return strcmp(_str, s._str) == 0;
    }
    bool operator>=(const string& s) const
    {
      return *this > s && *this == s;
    }
    bool operator<(const string& s) const
    {
      return !(*this >= s);
    }
    bool operator<=(const string& s) const
    {
      return !(*this > s);
    }
    bool operator!=(const string& s) const
    {
      return !(*this == s);
    }
    void resize(size_t n, char ch = '\0')
    {
      if (n < _size)
      {
        _str[n] = '\0';
        _size = n;
      }
      else if (n > _size)
      {
        if (n > _capacity)
        {
          reserve(n);
        }
        size_t i = _size;
        while (i < n)
        {
          _str[i] = ch;
          ++i;
        }
        _size = n;
        _str[_size] = '\0';
      }
    }
    void reserve(size_t n)
    {
      if (n > _capacity)
      {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete _str;
        _str = tmp;
        _capacity = n;
      }
    }
    void push_back(char ch)
    {
      //考虑扩容
      if (_size + 1 > _capacity)
      {
        reserve(_capacity * 2);
      }
      _str[_size] = ch;
      _size++;
      _str[_size] = '\0';
    }
    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+=(char ch)
    {
      push_back(ch);
      return *this;
    }
    string& operator+=(const char* str)
    {
      append(str);
      return *this;
    }
    string& insert(size_t pos, char ch)
    {
      assert(pos <= _size);
      if (_size + 1 > _capacity)
      {
        reserve(_capacity * 2);
      }
      size_t end = _size + 1;
      while (end > pos)
      {
        _str[end] = _str[end - 1];
        end--;
      }
      _str[pos] = ch;
      ++_size;
      return *this;
    }
    string& insert(size_t pos, const char* str)
    {
      assert(pos <= _size);
      size_t len = strlen(str);
      if (_size + len > _capacity)
      {
        reserve(_size + len);
      }
      //挪动数据
      size_t end = _size + len;
      while (end > pos + len - 1)
      {
        _str[end] = _str[end - len];
        end--;
      }
      strncpy(_str + pos, str, len);
      _size += len;
      return *this;
    }
    string& erase(size_t pos, 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;
    }
    void swap(string& s)
    {
      std::swap(_str, s._str);
      std::swap(_size, s._size);
      std::swap(_capacity, s._capacity);
    }
    size_t find(char ch, size_t pos = npos)
    {
      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 = npos)
    {
      assert(pos < _size);
      char* p = strstr(_str, str);
      if (p == nullptr)
      {
        return npos;
      }
      else
      {
        return p - str;
      }
    }
    void clean()
    {
      _str[0] = '\0';
      _size = 0;
    }
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
    static const size_t npos;
  };
  //定义npos
  const size_t string::npos = -1;
  ostream& operator<<(ostream& out, const string& str)
  {
    for (auto ch : str)
    {
      out << ch;
    }
    return out;
  }
  istream& operator>>(istream& in, string& str)
  {
    str.clean();
    char ch = in.get();
    char buff[128];
    size_t i = 0;
    while (ch != ' ' && ch != '\n')
    {
      buff[i++] = ch;
      if (i == 127)
      {
        buff[127] = '\0';
        str += buff;
        i = 0;
      }
      ch = in.get();
    }
    if (i != 0)
    {
      buff[i] = '\0';
      str += buff;
    }
    return in;
  }
}
文章标签：
云数据库 ClickHouse
C++
编译器
关键词：
C++ string
C++ stl
String c++
C++ stl string
String stl
花想云
目录
相关文章
睡觉待开机
|
1月前
|
安全 编译器 C语言
【C++数据结构】string的模拟实现
【C++数据结构】string的模拟实现
睡觉待开机
31 3
兰雪簪轩
|
23天前
|
编译器 C++ 容器
【C++】String常见函数用法
【C++】String常见函数用法
兰雪簪轩
15 1
兰雪簪轩
|
23天前
|
存储 算法 编译器
[C++] STL简介
[C++] STL简介
兰雪簪轩
17 1
土木林森
|
29天前
|
存储 算法 C++
C++ STL应用宝典：高效处理数据的艺术与实战技巧大揭秘！
【8月更文挑战第22天】C++ STL（标准模板库）是一组高效的数据结构与算法集合，极大提升编程效率与代码可读性。它包括容器、迭代器、算法等组件。例如，统计文本中单词频率可用`std::map`和`std::ifstream`实现；对数据排序及找极值则可通过`std::vector`结合`std::sort`、`std::min/max_element`完成；而快速查找字符串则适合使用`std::set`配合其内置的`find`方法。这些示例展示了STL的强大功能，有助于编写简洁高效的代码。
土木林森
32 2
可能只会写BUG
|
16天前
|
存储 C++
C++(五)String 字符串类
本文档详细介绍了C++中的`string`类，包括定义、初始化、字符串比较及数值与字符串之间的转换方法。`string`类简化了字符串处理，提供了丰富的功能如字符串查找、比较、拼接和替换等。文档通过示例代码展示了如何使用这些功能，并介绍了如何将数值转换为字符串以及反之亦然的方法。此外，还展示了如何使用`string`数组存储和遍历多个字符串。
可能只会写BUG
12 0
chian-ocean
|
1月前
|
安全 程序员 C++
C++ --＞ string类的使用（详细介绍）
C++ --＞ string类的使用（详细介绍）
chian-ocean
37 5
chian-ocean
|
1月前
|
存储 编译器 C语言
C++ --＞ string类模拟实现（附源码）
C++ --＞ string类模拟实现（附源码）
chian-ocean
57 4
Liuqz2009
|
25天前
|
存储 C++
C++ dll 传 string 类 问题
C++ dll 传 string 类 问题
Liuqz2009
16 0
qq2108462953
|
30天前
|
存储 C++
【C/C++学习笔记】string 类型的输入操作符和 getline 函数分别如何处理空白字符
【C/C++学习笔记】string 类型的输入操作符和 getline 函数分别如何处理空白字符
qq2108462953
30 0
小狮子安度因1
|
1月前
|
安全 编译器 容器
C++STL容器和智能指针
C++STL容器和智能指针
小狮子安度因1
21 0