前言

在上一篇文章中，我们详细介绍了string类一些常用接口的使用，那这篇文章，我们将对string进行一个模拟实现，帮助大家理解的更加深刻。

1. string的基本结构

在上篇文章中我们了解：

string的底层其实就是一个支持动态增长的字符数组。那确定它的结构，接下来我们就开始模拟实现它。

首先新建一个头文件string.h，定义一个string类：

class string
{public ://成员函数private :char*  _str;size_t _size;size_t _capacity;
};

这里string类的三个成员变量，一个字符指针_str指向开辟的动态数组，_size标识有效数据个数，_capacity记录容量的大小（不包含’\0’）。

但是因为标准库里已经有string类，为了避免冲突，我们需要定义一个命名空间，把我们自己实现的string类放到自己的命名空间里面。

namespace w
{class string
{public ://成员函数private :char*  _str;size_t _size;size_t _capacity;};} 

2. 构造函数、析构函数

2.1 构造函数的实现

2.1.1带参构造函数

首先我们来模拟实现一个带参构造函数：

我们知道标准库里string类的构造函数有很多，这里我们只模拟实现最常用的：

在之前的文章中我们提到尽量使用初始化列表进行初始化，我们可以这样写：

但是这里你会发现程序报错了，因为如果像上图一样初始化，首先涉及到权限放大的问题（之前文章有讲过）char* str被const修饰，不能被修改，但是赋给_str，_str是char* 类型的，可以修改。其次用常量字符串去初始化也不能被修改。

那怎么办呢？ 我们这里不直接传参而是开空间，用strcpy去进行拷贝：

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

顺便这里我们提供一个接口用来返回字符串：

 const char* c_str(){return _str;}

我们在创建一个test.cpp文件用来测试我们写的接口：

2.2析构函数

这里我们直接顺便给出析构函数：

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

2.3无参构造函数

我们有的时候还会遇到这样的场景：

所以这里需要我们去实现一个无参的构造函数。

假设这里的无参构造函数我们这样实现：

那这样真的可行吗？
如果这里_str传空指针那么在刚刚实现的c_str函数就会返回空程序，程序会崩溃。并且在标准库里的c_str接口即使传空也是会有返回值的。

那这里应该怎么办呢？ 我们可以这样写：

  string():_str(new char[1]),_size(0),_capacity(0){_str[0] = '\0';}

这里我们给_str开辟一个空间，然后给这块空间给上'\0'。这样就不会出现上面的问题了。

2.4无参和带参构造函数合并

我们之前讲过无参和带参的可以用全缺省。

我们来看几种写法：

能这样写吗？答案是肯定不能这样写类型就不匹配，一个是字符一个是字符串。

能这样写吗？ 答案是肯定不能。这样写strlen里的str就是空串了。

其实应该这样写：

这里我们直接给一个空串，常量字符串末尾是默认有"\0"的

3. string的遍历

3.1 operator[ ]

我们知道在标准库中可以通过下标去访问字符串中的某一个字符，下面我们来实现对[]的重载。

首先我们需要实现size()接口：

接下来我们来实现一下[]的重载：


这里我们实现了两个版本普通版本对应普通对象，const版本对应const对象，且这两个函数构成函数重载。

下面我们来验证一下：

3.2迭代器模拟实现 (简单实现）

除了[]可以遍历访问string对象，我们还可以用迭代器进行访问。

那迭代器我们说了大家可以理解成一个像指针一样的东西，但是不一定是指针。
我们最开始介绍了STL有好几个版本，不同的版本实现可能是不一样的。
那其实vs下string的迭代器呢就不是使用指针实现的，而G++下使用的SGI版本是指针实现的。
那这里我们模拟实现就使用指针来实现:

下面我们来验证一下：

同样的我们还可以使用范围for进行遍历：

范围for的底层就是用的迭代器。
大家可以理解成范围for的语法其实就跟我们之前学过的宏有点类似，它会被替换成迭代器，相当于把*it赋值给ch。范围for的底层就是无脑替换。

3.3 const迭代器模拟实现

这里我们再实现const版本给const对象使用：

4. 数据的增删查改

首先我们来实现一下push_back()和append().这两个都是插入数据，既然插入数据那我们就必须考虑扩容的问题。

那这里如果扩容的话，我们一次扩多少呢？
对于push_back来说一次扩二倍没问题，但是append一次扩二倍有可能是不行的。
为什么？
如果当前的容量是10，现在追加一个长度为25的字符串，扩容到原来的两倍才
20，也是不够用的。

那这里我们通过string的另一个接口reserve，它可以改变容量为我们指定的大小，帮助我们扩容。
下面我们就先来实现一下reserve。

4.1 reserve

我们先来看一下reserve怎么实现：

这里当参数n的值小于_capacity，如果不加这个if判断这里就会缩容。但是我们知道，库里的接口是不会缩容的。所以需要加上这个条件判断。

4.2 push_back和append

那接下来有了reserve我们继续来实现push_back和append。

push_back这里我们直接选择两倍扩。

这里append最少扩容到_size + len.

下面我们来实现一下：

4.3 +=

我们虽然有push_back和append但是我们更喜欢用重载的+=。当然+=的底层也是可以用push_back和append实现的。

下面我们来实现一下：

4.4 insert

对于insert我们主要实现库里的这两个版本：

首先我们来实现一下在pos位置插入n个字符：
逻辑其实是比较简单的。首先判断一下，是否需要扩容，然后就插入数据，如果往中间插就需要挪动数据。

这样写有没有问题呢？ 我们来测试一下：

好像没什么问题啊。真的没问题吗？

我们来看一种特殊情况：当pos = 0 时插入数据：

程序这里挂了。那为什么呢？
这里当pos = 0时，end等于0时还会进入循环,end再- -会变成多少？ 是-1吗？

这里end的类型是szie_t，无符号整型，所以end为0后再- -并不是-1，而是整型最大值，发生越界，循环也没正常结束，所以程序崩了。

那怎么解决呢？把end改成int可行吗？

这里也是不可行的。end和pos比较，end变成int，但是pos是size_t类型，这里是会发生整型提升(C语言知识）。那我们应该如何解决呢？

这里解决方法有很多，我们采用其中一种利用我们之前文章中提到的npos解决：

我们再来测试一下：

刚才是插入一个字符，现在我们再来实现插入字符串的。那么逻辑和上面其实是一样的。只不过上面我们只需要挪出n个空间就可以了，那这里我们需要挪动数据腾出strlen(str)个空间。

下面我们来测试一下：

4.5 erase

那么接下来我们来实现一下erase，从pos位置删除len个字符：

对于erase首先第一种情况就是pos+len小于字符串的长度，那我们需要把pos位置开始的后len个字符删掉，但是仍然保留后续字符。那这里就是挪动后面的数据，把需要删除的覆盖掉就行。
那其它情况就是len比较大，pos+len直接大于等于字符串的长度，那就把pos后面的全部删掉。或者没有传pos这个参数，缺省值npos，那也要把后面的全删，所以这两种情况可以统一处理。这里只需要把pos位置给成“\0”就行了。

我们来测试一下：

当然为了和标准库里的一致我们这里也使用引用返回：

4.6 find

下面我们来实现一下find。find的实现其实很简单，遍历去找，找到了就返回下标，找不到就返回npos。

当然find还支持从pos位置开始查找一个字符串：在这里我们复用C语言中的strstr去查找。

下面我们来测试一下：

4.7 substr

下面我们再来实现一下substr。它的逻辑也是很简单的。

这里稍微需要注意的是我们需要条件判断当截取的字串足够长，我们截取的长度就是pos位置一直到字符串的末尾。

5. 拷贝构造

我们现在先来写一段这样的代码：

这里有一个拷贝构造，s2是s1拷贝构造而来的。

5.1 浅拷贝默认拷贝构造

在之前类和对象的文章中，我们知道，拷贝构造函数我们自己不写编译器是会默认生成的，这里我们直接运行上面的代码：

这里程序出错发生了一个经典的浅拷贝的问题。在之前的文章中我们也有讲过若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数拷贝对象 按内存存储字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝，就会出现问题。

5.2 深拷贝拷贝构造函数

这里就需要我们自己去实现拷贝构造函数，完成深拷贝：


下面我们来测试一下：

6. 源码(上部分)

6.1 string.h

#include <iostream>
using namespace std;
namespace w
{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 = ""):_str(new char[strlen(str)+1]),_size(strlen(str)),_capacity(strlen(str)){strcpy(_str, str);}string(const string& s){_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}const char* c_str() const{return _str;}size_t size() const{return _size;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}const 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){// 2倍扩容reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';}void append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){// 至少扩容到_size + lenreserve(_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;}void insert(size_t pos, size_t n, char ch){assert(pos <= _size);if (_size +n > _capacity){// 至少扩容到_size + lenreserve(_size + n);}// 添加注释最好size_t end = _size;while (end >= pos && end != npos){_str[end + n] = _str[end];--end;}for (size_t i = 0; i < n; i++){_str[pos + i] = ch;}_size += n;}void insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size + len > _capacity){// 至少扩容到_size + lenreserve(_size + len);}// 添加注释最好size_t end = _size;while (end >= pos && end != npos){_str[end + len] = _str[end];--end;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;}string& erase(size_t pos, size_t len = npos){assert(pos <= _size);if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;_str[_size] = '\0';}else{size_t end = pos + len;while (end <= _size){_str[pos++] = _str[end++];}_size -= len;}return *this;}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* ptr = strstr(_str + pos, str);if (ptr){return ptr - _str;}else{return npos;}}string substr(size_t pos = 0, size_t len = npos){assert(pos < _size);size_t n = len;if (len == npos || pos + len > _size){n = _size - pos;}string tmp;tmp.reserve(n);for (size_t i = pos; i < pos + n; i++){tmp += _str[i];}return tmp;}private :char*  _str;size_t _size;size_t _capacity;public:const static size_t npos;};const size_t string::npos = -1;
} 

6.2 test.cpp

#include "Mystring.h"void test_string1()
{w ::string s1("hello world");cout << s1.c_str() << endl;for (size_t i = 0; i < s1.size(); i++){cout << s1[i] << " ";}cout << endl;w ::string::iterator it = s1.begin();while (it != s1.end()){cout << *it << " ";++it;}cout <<endl;for (auto ch : s1){cout << ch <<" ";}cout <<endl;
}void test_string2()
{w::string s1("hello world");cout << s1.c_str() << endl;s1.push_back(' ');s1.push_back('#');s1.append("hello");cout << s1.c_str() << endl;w::string s2("hello world");cout << s2.c_str() << endl;s2 += ' ';s2 += '#';s2 += "hello code";cout << s2.c_str() << endl;}void test_string3()
{w::string s1("helloworld");cout << s1.c_str() << endl;s1.insert(5, 3, '#');cout << s1.c_str() << endl;s1.insert(0, 3, '#');cout << s1.c_str() << endl;w::string s2("helloworld");s2.insert(5, "%%%%%");cout << s2.c_str() << endl;}void test_string4()
{w::string s1("helloworld");cout << s1.c_str() << endl;s1.erase(5, 3);cout << s1.c_str() << endl;s1.erase(5, 30);cout << s1.c_str() << endl;s1.erase(2);cout << s1.c_str() << endl;
}void test_string5()
{w::string s1("helloworld");cout << s1.find('w',2) << endl;}void test_string6()
{w::string s1("hello world");w::string s2(s1);cout << s1.c_str() << endl;cout << s2.c_str() << endl;}int main()
{test_string6();return 0;
}

7. 总结

文章篇幅有限，剩余内容将在下篇进行讲解。