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

一、string类

1、 string是表示字符串的字符串类。

2、该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

3、 string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string。

4、不能操作多字节或者变长字符的序列。在使用string类时，必须包含#include<string>头文件以及using namespace std。

那么接下来我们就来模仿标准库里的string类来进行一个模拟实现，进而更深层次地理解string容器。 (为了与标准库区分，我们在自己的命名空间里来实现)

首先根据源码，我们可以知道string中的主义成员变量我们可以写成 char* _str（字符数组），size_t _size（数据个数），size_t _capacity（容量大小）。

二、构造函数、拷贝构造函数及析构函数

1、构造函数

string的构造函数分为无参构造和有参构造，通过无参构造的对象会被默认生成一个空字符串，因此我们可以带一个缺省值。没有参数时就直接构造一空串。

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

注：在开空间时，我们需要多开一个空间，因为strlen算出的大小不包含 ‘\0’ ，因此我们需要给 ‘\0’留一个空间。

2、拷贝构造函数

拷贝构造函数是默认成员函数，如果不写编译器会自动生成，对于内置类型完成浅拷贝，对于自定义类型调用其拷贝构造函数完成拷贝。对于string类型来说，如果不自己写拷贝构造函数会导致浅拷贝问题。

如果仅仅依靠编译器自己提供的拷贝构造函数，就会像上图一样两个对象指向同一块空间。这就是我们所说的浅拷贝，浅拷贝有两大缺点：1、两个对象在析构时都会调用自己的析构函数，这样同一块空间就会被析构两次；2、一个对象的数据改变，另一个对象的数据也改变了。

因此我们自己实现一个拷贝构造函数尤为重要。我们需要进行深拷贝。

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

上面的这种实现方法是比较常见的一种写法，但是我们还有一种更加简便的写法。我们可以通过已经实现了的构造函数传一个常量字符串，即下面的 str . _str，来创建一个l临时对象，然后将这个临时对象的成员与自己交换，这样也完成了拷贝构造。

void swap(string& s)
{
  ::swap(_str, s._str);
  ::swap(_size, s._size);
  ::swap(_capacity, s._capacity);
}
string(const string& str)
  :_str(nullptr)
  ,_size(0)
  ,_capacity(0)
{
  string tmp(str._str);
    swap(tmp);
}

但是，为了写成这个拷贝构造函数我们还写了一个swap函数，这这么就简便了呢？

那是因为通过查阅标准库我们发现swap函数也是一个string类中提供了的函数，因此我们不仅简便了拷贝构造函数的写法，还又完成了一个函数的实现。并且，因为tmp是一个局部对象，因此在出作用域后就会自动调用析构函数，所以交换后还可以清理掉原来的空间，一举两得。

注：蓝色的swap函数是我们自己写的，而黄色的，前面写明了域的swap函数是C++库中的一个现成的函数。这两个一定要区别开来。

3、析构函数

我们可以使用delete直接释放掉 _str的空间。

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

三、string类中对容量操作的成员函数

1、size

它的功能是返回字符串有效字符的长度。我们可以直接返回其成员变量中的 _size。

size_t size()const
{
  return _size;
}

2、capacity

它的功能是返回返回空间总大小 。我们可以直接返回其成员变量中的 _capacity

size_t capacity()const
{
  return _capacity;
}

3、reserve

它的功能是为字符串预留空间

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

4、resize

它的功能是将有效字符的个数改成n个，多出的空间用字符 ch 填充。

_size < n <_capacity 先预留 n 大小的空间。直接用字符 ch 填充 n - _size 位置，记住要在最后加上 ‘\0’

_size > n 直接将 n 位置的置成 ’\0‘

n > _capacity 先预留 n 大小的空间，剩下的空间用字符 ch 填充，记住要在最后加上 ‘\0’。

void resize(size_t n, char ch = '\0')
{
  if (n > _size)
  { 
    reserve(n);
    for (size_t i = _size; i < n; i++)
    {
      _str[i] = ch;
    }
    _size = n;
    _str[_size] = '\0';
  }
  else
  {
      //删除数据
    _str[n] = '\0';
    _size = n;
  }
}

5、clear

它的作用是清空有效字符

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

6、empty

它的作用是检测字符串释放为空串，是返回true，否则返回false

bool empty()const
{
    return _size == 0;
}

四、string类中对象的增删查改操作

1、push_back

在字符串后尾插字符c

void push_back(char ch)
{
  if (_size == _capacity)
  {
    reserve(_capacity == 0 ? 4 : _capacity * 2);
  }
  _str[_size] = ch;
  _size++;
  _str[_size] = '\0';
}

2、append

在字符串后追加一个字符串

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

3、c_str

返回C格式字符串

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

补充：C语言字符串和 string类字符串的区别(下面我们来通过一段代码来看看他们的区别)

void test_string8()
{
  string s1("hello");
  s1 += '\0';
  s1 += "De Bruyne";
  cout << s1 << endl;
  cout << s1.c_str() << endl;
}

代码运行结果如下：

通过上面的运行结果我们可以看出C语言的字符串一定是通过 ’\0‘ 结束的；而string 的字符串中 ’\0‘ 不一定就是字符串结束的标志。

4、find

npos是string类的静态成员变量，静态成员变量要在类外定义的。我们一般将它设为公共权限，并赋值为 -1。

在字符串中寻找一个字符

size_t find(char ch, size_t pos = 0)const
{
  assert(pos < _size);
  for (size_t i = pos; i < _size; i++)
  {
    if (ch == _str[i])
    {
      return i;
    }
  }
  return npos;
}

在字符串中寻找字符串

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

5、substr

它的作用是在str中从pos位置开始，截取n个字符，然后将其返回

string substr(size_t pos, size_t len = npos)const//取子串
{
  assert(pos < _size);
  size_t reallen = len;
  if (reallen == npos || reallen + pos > _size)
  {
    reallen = _size - pos;
  }
  string sub;
  for (size_t i = pos; i < reallen + pos; i++)
  {
    sub += _str[i];
  }
  return sub;
}

6、insert

插入一个字符

string& 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++;
  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 (pos + len <= end)
  {
    _str[end] = _str[end - len];
    end--;
  }
  strncpy(_str + pos, str, len);
  _size += len;
  return *this;
}

7、erase

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

五、string对于重要的运算符重载

1、赋值运算符的重载

编译器默认生成的赋值重载也会导致浅拷贝，所以我们需要实现深拷贝。

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

和拷贝构造函数一样，我们也可以用简便写法来实现赋值运算符的重载。（注意不要自己给自己赋值）。

string& operator=(const string& str)
{
  if (this != &str)
  {
      string tmp(str);
    swap(tmp);
  }
  return *this;
}

2、流插入 <<

类外定义

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

3、流提取 >>

istream& operator>>(istream& in, string& s)
{
  s.clear();
  char ch;
  ch = in.get();
  const size_t N = 32;
  char buff[N];
  size_t i = 0;
  while (ch != ' ' && ch != '\n')
  {
    buff[i++] = ch;
    if (i == N - 1)
    {
      buff[i] = '\0';
      s += buff;/*先将输入的字符存在buff数组中，然后一次性+=到s中，这样就避免了输入的
              字符串过大，使s频繁扩容的现象。*/
      i = 0;
    }
    ch = in.get();
  }
  buff[i] = '\0';
  s += buff;
  return in;
}

4、下标访问 [ ]

普通对象：可读可写

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

const对象：可读不可写

char operator[](size_t pos) const
{
  assert(pos < _size);
  return _str[pos];
}

5、加等一个字符 +=

我们可以直接复用push_back来实现一个字符的加等

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

6、加等字符串 +=

我们可以直接复用append来实现字符串的加等

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

7、大于 >

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

8、等于 ==

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

9、小于 <

bool operator<(const string& s)const
{
  return !(_str > s._str) && !(_str == s._str);
}

10、大于等于 >=

bool operator>=(const string& s)const
{
  return !(_str < s._str);
}

11、小于等于 <=

bool operator<=(const string& s)const
{
  return !(_str > s._str);
}

12、不等于 !=

bool operator!=(const string& s)const
{
  return !(_str == s._str);
}

六、迭代器与范围for

1、迭代器

迭代器作为STL的六大组件之一，它的作用十分重要。而在string中迭代器的本质就是一个 char* 或 const char* 的指针。

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

2、范围for

范围for是C++11支持的更简洁的新遍历方式。但是其实它没有什么高大上的，它的本质还是去调用迭代器来实现遍历的。因此我们只要实现了迭代器后，就可以直接使用范围for，根本不用自己去实现。

我们从下面的汇编代码的红色标记处可以看出范围for和迭代器的底层实现都是去call的begin()和end()，因此范围for的底层就是迭代器。

3、结果对比

void test_string9()
{
  string s("hello world");
  string::iterator it = s.begin();
  while (it != s.end())
  {
    cout << *it << " ";
    it++;
  }
  cout << endl;
  for (auto e : s)
  {
    cout << e << " ";
  }
    cout << endl;
}

七、完整代码

string.h

#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<iostream>
using namespace std;
#include<cstring>
#include<cassert>
namespace zdl
{
  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;
    }
    void swap(string& s)
    {
      ::swap(_str, s._str);
      ::swap(_size, s._size);
      ::swap(_capacity, s._capacity);
    }
    //构造函数
    string(const char* str = "")
      :_str(new char[strlen(str) + 1])
      , _size(strlen(str))
      , _capacity(strlen(str))
    {
      strcpy(_str, str);
    }
    /*string()
      :_str(new char[1])
      , _size(0)
      , _capacity(0)
    {
      _str[0] = '\0';
    }*/
    //拷贝构造函数:要深拷贝
    string(const string& str)
      :_str(new char[str._capacity+1])
      ,_size(str._size)
      ,_capacity(str._capacity)
    {
      strcpy(_str, str._str);
    }
    /*简便写法 string(const string& str)
          :_str(nullptr)
          ,_size(0)
          ,_capacity(0)
        {
          string tmp(str._str);
          swap(tmp);
        }*/
    //赋值
    string& operator=(const string& str)
    {
      if (this != &str)
      {
        char* tmp = new char[str._capacity + 1];
        strcpy(tmp, str._str);
        delete[] _str;
        _str = tmp;
        _size = str._size;
        _capacity = str._capacity;
      }
      return *this;
    }
      /*简便写法  string& operator=(const string& str)
      {
        if (this != &str)
        {
          string tmp(str);
          swap(tmp);
        }
        return *this;
      }  */
    //析构函数
    ~string()
    {
      delete[] _str;
      _str = nullptr;
      _size = _capacity = 0;
    }
    const char* c_str()const
    {
      return _str;
    }
    size_t size()const
    {
      return _size;
    }
    size_t capacity()const
    {
      return _capacity;
    }
    char& operator[](size_t pos) const
    {
      assert(pos < _size);
      return _str[pos];
    }
    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)
      {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
      }
      _str[_size] = ch;
      _size++;
      _str[_size] = '\0';
    }
    void append(const char* str)
    {
      size_t len = strlen(str);
      if (_capacity < len + _size)
      {
        reserve(len + _size);
      }
      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 == _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++;
      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 (pos + len <= end)
      {
        _str[end] = _str[end - len];
        end--;
      }
      strncpy(_str + pos, str, len);
      _size += len;
      return *this;
    }
    void erase(size_t pos, size_t len = npos)
    {
      assert(pos < _size);
      if (len == npos || len >= _size)
      {
        _str[pos] = '\0';
        _size = pos;
      }
      else
      {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
      }
    }
    void clear()
    {
      _str[0] = '\0';
      _size = 0;
    }
    size_t find(char ch, size_t pos = 0)const
    {
      assert(pos < _size);
      for (size_t i = pos; i < _size; i++)
      {
        if (ch == _str[i])
        {
          return i;
        }
      }
      return npos;
    }
    size_t find(const char* sub, size_t pos = 0)const
    {
      assert(pos < _size);
      const char* ptr = strstr(_str + pos, sub);
      if (ptr == nullptr)
      {
        return npos;
      }
      else
      {
        return ptr - _str;
      }
    }
    string substr(size_t pos, size_t len = npos)const//取子串
    {
      assert(pos < _size);
      size_t reallen = len;
      if (reallen == npos || reallen + pos > _size)
      {
        reallen = _size - pos;
      }
      string sub;
      for (size_t i = pos; i < reallen + pos; i++)
      {
        sub += _str[i];
      }
      return sub;
    }
    void resize(size_t n, char ch = '\0')
    {
      if (n > _size)
      {
        reserve(n);
        for (size_t i = _size; i < n; i++)
        {
          _str[i] = ch;
        }
        _size = n;
        _str[_size] = '\0';
      }
      else
      {
        //删除数据
        _str[n] = '\0';
        _size = n;
      }
    }
    bool operator>(const string& s)const
    {
      return strcmp(_str, s._str) > 0;
    }
    bool operator==(const string& s)const
    {
      return strcmp(_str, s._str) == 0;
    }
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
  public:
    static size_t npos;
  };
  size_t string::npos = -1;
  ostream& operator<<(ostream& out, const string& s)
  {
    for (size_t i = 0; i < s.size(); i++)
    {
      out << s[i];
    }
    return out;
  }
  istream& operator>>(istream& in, string& s)
  {
    s.clear();
    char ch;
    ch = in.get();
    const size_t N = 32;
    char buff[N];
    size_t i = 0;
    while (ch != ' ' && ch != '\n')
    {
      buff[i++] = ch;
      if (i == N - 1)
      {
        buff[i] = '\0';
        s += buff;/*先将输入的字符存在buff数组中，然后一次性+=到s中，这样就避免了输入的字符串过大，使s频繁扩容的现象。*/
        i = 0;
      }
      ch = in.get();
    }
    buff[i] = '\0';
    s += buff;
    return in;
  }
  void test_string1()
  {
    string s1("hello world");
    string s2(s1);
    string s3;
    cout << "s1: " << s1 << endl;
    cout << "s2: " << s2 << endl;
    cin >> s3;
    cout << "s3: " << s3 << endl;
    string s4("ZD");
    s4 += 'L';
    cout << "s4: " << s4 << endl;
    s4 += " ";
    s4 += "and";
    s4 += " ";
    s4 += "De Bruyne";
    cout << "s4: " << s4 << endl;
  }
  void test_string2()
  {
    string s5("hello");
    s5.append("ZDL 17");
    cout << "s5: " << s5 << endl;
  }
  void test_string3()
  {
    string s6("hello");
    s6.insert(0, '#');
    cout << "s6: " << s6 << endl;
  }
  void test_string4()
  {
    string s7("hello");
    s7.insert(2, "ZDL");
    cout << "s7: " << s7 << endl;
  }
  void test_string5()
  {
    string s8("helloeeeeeelllooo");
    s8.erase(2, 2);
    cout << "s8: " << s8 << endl;
  }
  void test_string6()
  {
    string s9("hello world ZDL waiting for love");
    string s10 = s9.substr(6, 5);
    cout << "s10: " << s10 << endl;
  }
  void test_string7()
  {
    string s11("hello world ZDL waiting for love");
    string s12("shfshf");
    cout << "比较: " << (s11 > s12) << endl;
    string s13("De Bruyne");
    string s14("De Bruyne");
    cout << "s13 与 s14: " << (s13 == s14) << endl;
  }
  void test_string8()
  {
    string s1("hello");
    s1 += '\0';
    s1 += "De Bruyne";
    cout << s1 << endl;
    cout << s1.c_str() << endl;
  }
  void test_string9()
  {
    string s("hello world");
    string::iterator it = s.begin();
    while (it != s.end())
    {
      cout << *it << " ";
      it++;
    }
    cout << endl;
    for (auto e : s)
    {
      cout << e << " ";
    }
    cout << endl;
  }
}

test.cpp

#include"string.h"
int main()
{
  zdl::test_string1();
  cout << "------------------------------" << endl;
  zdl::test_string2();
  cout << "------------------------------" << endl;
  zdl::test_string3();
  cout << "------------------------------" << endl;
  zdl::test_string4();
  cout << "------------------------------" << endl;
  zdl::test_string5();
  cout << "------------------------------" << endl;
  zdl::test_string6();
  cout << "------------------------------" << endl;
  zdl::test_string7();
  cout << "------------------------------" << endl;
  zdl::test_string8();
  cout << "------------------------------" << endl;
  zdl::test_string9();
  return 0;
}

string的模拟实现