string类的模拟实现-阿里云开发者社区

上一篇博客我们对string类函数进行了讲解，今天我们就对string类进行模拟实现，以便于大家更加深入地了解string类函数的应用

由于C++的库里面本身就有一个string类，所以我们为了不让编译器混淆视听，我们可以首先将我们自己模拟实现的string类放入一个我们自己定义的命名空间内，这里我将命名空间命名为jh（本人名字首字母缩写）：

namespace jh
{
  class string
  {
  };
}

然后就是我们将string类的类的成员进行定义：

string类实际就是字符串，它的几个成员有capacity（容量），size（字符拆串当前字符个数），str（字符串的指针）

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

下面我们就对string类的大部分经常使用的成员函数进行模拟实现：

构造函数

首先定义一个构造函数，用于创建string类，这里大家用到了strlen和strcpy函数，所以要带上头文件string.h

还有一个需要注意的点：

这里为_str开辟空间我们需要开辟capacity+1个字符的空间，因为要为\0预留一个字符的空间

string(const char* str = "")
{
  _size = strlen(str);
  _capacity = _size;
  _str = new char[_capacity + 1];
  strcpy(_str, str);
}

拷贝构造函数

string类的拷贝构造函数也很简单：

和构造函数差不多

string(const string& s)
{
  _str = new char[s._capacity + 1];
  _size = s._size;
  _capacity = s._capacity;
  strcpy(_str, s._str);
}

析构函数

析构函数也很简单，直接将size和capacity置零，指针置为空，将str的空间用delete删除，记得带上[]，方便通用语字符和字符串

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

赋值操作符重载

赋值操作符是一个很常用的操作符，我们的前提两个字符串不相等，如果相等就没必要进行操作，直接返回*this

不相等的情况下我们首先开辟一个tmp的空间将字符串拷贝进去，将tmp赋予_str，然后将size和capacity赋值，这样就完成了赋值操作符的重载

string& operator=(const string& s)
{
  if (this != &s)
  {
    char* tmp = new char[s._capacity + 1];
    strcpy(tmp, s._str);
    _str = tmp;
    _capacity = s._capacity;
    _size = s._size;
  }
  return *this;
}

返回字符串函数

很简单，但是要记得在函数前加上const修饰函数返回值，函数后加上const修饰_str,避免权限的放大

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

返回size函数

同样很简单，返回_size，加上const避免权限的放大

size_t size() const
{
  return _size;
}

下标访问符号重载

下标访问在字符串中很常用，我们需要将其进行断言，如果pos大于size就毫无意义，需要注意的就是带上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];
}

迭代器

迭代器主要分为const和非const

我们用typedef将char*命名为iterator

begin函数就直接返回_str

end函数就直接返回 str+size

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

reserve函数

reserve函数是一个扩容函数，但是他只是改变capacity，不会改变size，并且不会缩容，缩容很是麻烦，所以只有当n>capacity时才会进行扩容

void reserve(size_t n)
{
  if(n>_capacity)
  {
    char* tmp = new char[n + 1];
    strcpy(tmp, _str);
    delete[] _str;
    _str = tmp;
    _capacity = n;
  }
}

resize函数

resize函数和reserve函数的区别就是resize改变capacity的同时也会改变size，但是当n时小于等于size的时候不会缩容，但是\0的位置被放到了n位置

当size小于n的时候我们就需要把后面的n-size个位置的元素置为ch（\0），同时size也进行改变

void resize(size_t n, char ch = '\0')
{
  if (n <= _size)
  {
    _str[n] = '\0';
    _size = n;
  }
  else
  {
    reserve(n);
    while (_size < n)
    {
      _str[_size] = ch;
      _size++;
    }
    _str[_size] = '\0';
  }
}

追加函数

追加函数分为两种，一种是追加字符的pushback，一种时追加字符串的append，我们要注意append加上const，避免权限的放大，当追加后容量不够我们就要进行扩容

void pushback(char ch)
{
  if (_size == _capacity)
  {
    size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
  }
  _str[_size] = ch;
  _size++;
  _str[_size] = '\0';
}
void append(const char* str)
{
  size_t len = strlen(str);
  if (len > +_size > _capacity)
  {
    reserve(_capacity+len);
  }
  strcpy(_str + _size, str);
  _size += len;
}

+=操作符重载

这个我们就可以复用pushback和append

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

find函数

同样的find函数分为字符串和字符类型

这里的pos就用到缺省值，没有给就是0，找不到就是返回-1，也就是通常所说的npos

size_t find(char ch, size_t pos = 0)
    {
      for (size_t i = pos; i < _size; i++)
      {
        if (_str[i] == ch)
        {
          return i;
        }
      }
      return npos;
    }
    size_t find(const char* sub, size_t pos = 0)
    {
      const char* p = strstr(_str + pos, sub);
      if (p)
      {
        return p - _str;
      }
      else
      {
        return npos;
      }
    }

substr函数

substr函数时去字符串

它有两个参数，一个是pos一个是len，表示从pos位置开始取len长度的字符串，当len+pos大于字符串长度时有多少取多少，开辟空间进行追加即可

npos就是-1，给了默认缺省值

string substr(size_t pos, size_t len = npos)
    {
      string s;
      size_t end = pos + len;
      if (len == npos || pos + len >= _size) // 有多少取多少
      {
        len = _size - pos;
        end = _size;
      }
      s.reserve(len);
      for (size_t i = pos; i < end; i++)
      {
        s += _str[i];
      }
      return s;
    }

insert函数

insert函数也同样分为插入字符串和插入字符，第一步就是进行断言，如果插入位置pos是大于等于size，那么就毫无意义

当size和capacity已经相等时就需要扩容，为了减少扩容，所以我们一次性扩容两倍

当size加上插入字符串长度len大于capacity时，我们也需要扩容，直接扩容size+len即可，这里我为了方便大家的理解画一张图：

大家可以根据数据结构的知识构思一下我所说的bug

并且在字符串插入我们要用strncpy，而不是strcpy，因为strcpy时遇到\0才终止拷贝字符串，但是我们这里拷贝字符串不需要把\0拷进去，考进去的话会引发错误，所以我们要用ncpy来拷贝len个字符，不包括\0

void insert(size_t pos, char ch)
{
  assert(pos <= _size);
  if (_size == _capacity)
  {
    reserve(_capacity == 0 ? 4 : _capacity * 2);
  }
  size_t end = _size + 1;
  while (end > pos)
  {
    _str[end] = _str[end - 1];
    end--;
  }
  _str[pos] = ch;
  _size++;
}
void 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;
  while (end >= pos)
  {
    _str[end + len] = _str[end];
    end--;
  }
  strncpy(_str + pos, str, len);
  _size += len;
}

erase函数

首先要做的还是断言，pos是要小于size的

当长度len时负数时或者pos+len大于等于size时，有多少删除多少，直接将pos位置置为\0

当长度足够时，我们就需要将pos+len后面的字符移动到pos到pos+len的区间内来：

请看图：

void erase(size_t pos, size_t len = -1)
{
  assert(pos < _size);
  if (len == -1 || pos + len >= _size)
  {
    _str[pos] = '\0';
    _size = pos;
  }
  else
  {
    size_t begin = pos + len;
    while (begin <= _size)
    {
      _str[begin - len] = _str[begin];
      begin++;
    }
    _size -= len;
  }

操作符重载

操作符重载很简单，我们用strcmp函数，并且可以进行复用

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

clear函数

直接将0位置置为\0，同时size置0

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

流插入和流提取

流插入和提取要放到模拟实现string类的外面，但是要放入命名空间jh内

流插入很简单，直接用语法糖

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

流提取就需要理解透彻一点：

首先提取时我们会有一个缓冲区，所以我们每次提取之前需要用clear清理一次缓冲区

其次为了减少扩容，我们适当地开辟空间，等到该空间满了直接用+=赋予字符串s

这里需要用get函数来提取字符

然后用while循环，当当前位置的字符ch不等于空格并且不等于换行符时才能放入开辟好的buff空间里，当i等于128时，我们将i位置置为\0，将buff空间存储的字符串用+=放入string类对象s，同时i置为0，再进行一次get提取，判断输入的in对象是否还有（例如：输入xy yz，如果不用whie循环的条件和再次get的话，xy yz就只能提取xy）

当i不等于0时我们也需要将i位置置为\0，并且将buff+=给s

istream& operator>>(istream& in, string& s)
{
  s.clear();
  char buff[129];
  size_t i = 0;
  char ch;
  ch = in.get();
  while (ch != ' ' && ch != '\n')
  {
    buff[i++] = ch;
    if (i == 128)
    {
      buff[i] = '\0';
      s += buff;
      i = 0;
    }
    ch = in.get();
    if (i != 0)
    {
      buff[i] = '\0';
      s += buff;
    }
    return in;
  }
}

好了，今天的分享到这里就结束了，感谢大家的支持！

完整代码如下：

#include<iostream>
#include<assert.h>
using namespace std;
namespace jh
{
  class string
  {
  public:
    string(const char* str = "")
    {
      _size = strlen(str);
      _capacity = _size;
      _str = new char[_capacity + 1];
      strcpy(_str, str);
    }
    string(const string& s)
    {
      _str = new char[s._capacity + 1];
      _size = s._size;
      _capacity = s._capacity;
      strcpy(_str, s._str);
    }
    ~string()
    {
      delete[] _str;
      _str = nullptr;
      _size = 0;
      _capacity = 0;
    }
    string& operator=(const string& s)
    {
      if (this != &s)
      {
        char* tmp = new char[s._capacity + 1];
        strcpy(tmp, s._str);
        _str = tmp;
        _capacity = s._capacity;
        _size = s._size;
      }
      return *this;
    }
    const char* c_str() const
    {
      return _str;
    }
    size_t size() const
    {
      return _size;
    }
    const char& operator[](size_t pos)const
    {
      assert(pos <= _size);
      return _str[pos];
    }
    char& operator[](size_t pos)
    {
      assert(pos <= _size);
      return _str[pos];
    }
    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;
    }
    
    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 == _capacity)
      {
        size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
      }
      _str[_size] = ch;
      _size++;
      _str[_size] = '\0';
    }
    void append(const char* str)
    {
      size_t len = strlen(str);
      if (len > +_size > _capacity)
      {
        reserve(_capacity+len);
      }
      strcpy(_str + _size, str);
      _size += len;
    }
    void resize(size_t n, char ch = '\0')
    {
      if (n <= _size)
      {
        _str[n] = '\0';
        _size = n;
      }
      else
      {
        reserve(n);
        while (_size < n)
        {
          _str[_size] = ch;
          _size++;
        }
        _str[_size] = '\0';
      }
    }
    string& operator+=(char ch)
    {
      push_back(ch);
      return *this;
    }
    string& operator+=(const char* str)
    {
      append(str);
      return *this;
    }
    size_t find(char ch,size_t pos=0)
    {
      for (size_t i = pos; i < _size; i++)
      {
        if (_str[i] == ch)
          return i;
      }
      return -1;
    }
    size_t find(const char* str, size_t pos = 0)\
    {
      char* p = strstr(_str+pos, str);
      if (p)
      {
        return p - _str;
      }
      else
      {
        return -1;
      }
    }
    string substr(size_t pos, size_t len=-1)
    {
      string s;
      size_t end = pos + len;
      if (len == -1 || pos+len >= _size)
      {
        len = _size - pos;
        end = _size;
      }
      s.reserve(len);
      for (size_t i = pos; i < end; i++)
      {
        s += _str[i];
      }
      return s;
    }
    void insert(size_t pos, char ch)
    {
      assert(pos <= _size);
      if (_size == _capacity)
      {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
      }
      size_t end = _size + 1;
      while (end > pos)
      {
        _str[end] = _str[end - 1];
        end--;
      }
      _str[pos] = ch;
      _size++;
    }
    void 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;
      while (end >= pos)
      {
        _str[end + len] = _str[end];
        end--;
      }
      strncpy(_str + pos, str, len);
      _size += len;
    }
    void erase(size_t pos, size_t len = -1)
    {
      assert(pos < _size);
      if (len == -1 || pos + len >= _size)
      {
        _str[pos] = '\0';
        _size = pos;
      }
      else
      {
        size_t begin = pos + len;
        while (begin <= _size)
        {
          _str[begin - len] = _str[begin];
          begin++;
        }
        _size -= len;
      }
    }
    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 clear()
    {
      _str[0] = '\0';
      _size = 0;
    }
  private:
    size_t _capacity;
    size_t _size;
    char* _str;
  public:
    const static size_t npos;
  };
  const size_t string::npos = -1;
  ostream& operator<<(ostream& out, const string& s)
  {
    for (auto ch : s)
      out << ch;
    return out;
  }
  istream& operator>>(istream& in, string& s)
  {
    s.clear();
    char buff[129];
    size_t i = 0;
    char ch;
    ch = in.get();
    while (ch != ' ' && ch != '\n')
    {
      buff[i++] = ch;
      if (i == 128)
      {
        buff[i] = '\0';
        s += buff;
        i = 0;
      }
      ch = in.get();
      if (i != 0)
      {
        buff[i] = '\0';
        s += buff;
      }
      return in;
    }
  }
}

string类的模拟实现

构造函数

拷贝构造函数

析构函数

赋值操作符重载

返回字符串函数

返回size函数

下标访问符号重载

迭代器

reserve函数

resize函数

追加函数

+=操作符重载

find函数

substr函数

insert函数

erase函数

操作符重载

clear函数

流插入和流提取

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

string类的模拟实现

构造函数

拷贝构造函数

析构函数

赋值操作符重载

返回字符串函数

返回size函数

下标访问符号重载

迭代器

reserve函数

resize函数

追加函数

+=操作符重载

find函数

substr函数

insert函数

erase函数

操作符重载

clear函数

流插入和流提取

热门文章

最新文章

相关电子书

相关实验场景