愿所有美好如期而遇
前言
我们模拟实现string类不是为了去实现他，而是为了了解他内部成员函数的一些运行原理和时间复杂度，在将来我们使用时能够合理地去使用他们。
为了避免我们模拟实现的string类与全局上的string类冲突(string类也在std命名空间中)，我们用自己的命名空间包起来。
namespace A { class string { static void test() { } } } int main() { A::string::test(); }
接下来我们开始模拟实现string类。
私有的成员变量，我们设计无符号整型计算有效字符数量的_size，以及记录空间大小的_capacity,最后就是字符指针，我们将来开辟好一块空间后存放字符串，将由他来指向。
namespace A { class string { private: size_t _size; size_t _capacity; char* _str; } }
构造函数：
默认是空串，并且我们默认比有效字符多开一个字节的空间，之后进行拷贝。
string(const char* str = "") { _size = _capacity = strlen(str); _str = new char[_capacity + 1]; strcpy(_str, str); }
拷贝构造函数:
我们模拟实现string类，一定会有空间的开辟，一但对象涉及到拷贝，就不能是浅拷贝，否则会出现一块空间两次释放，直接崩掉。
string(const string& str) { _capacity = str._capacity; _size = str._size; _str = new char[_capacity + 1]; strcpy(_str, str.c_str()); }
赋值运算符重载：
同拷贝构造，对象也是不能值拷贝，否则会出现一块空间释放两次。
string& operator=(const string& str) { if (this != &str) { _capacity = str._capacity; _size = str._size; char* tmp = new char[_capacity + 1]; strcpy(tmp, str.c_str()); delete[] _str; _str = tmp; } return *this; }
析构函数：
~string() { delete[] _str; _str = nullptr; _capacity = _size = 0; }
将string转换为const char*，我们会在strlen等C的接口处使用，比如strlen(s.c_str())，因为strlen他的参数是const char*类型的。
const char* c_str() const { return _str; }
四个迭代器
只有物理地址空间连续才可以像这样，如果是链表，我们不能这样做。
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; }
尾插单个字符,_capacity和_size都是只考虑有效字符，我们在创建空间时默认开空间比_capacity大一。
void push_back(char ch) { if (_size == _capacity) { _capacity = 0 ? 4 : _capacity * 2; char* tmp = new char[_capacity + 1]; strcpy(tmp, _str); delete[] _str; _str = tmp; } _str[_size++] = ch; _str[_size] = '\0'; }
reserve函数，我们使用reserve重新开空间，也是只考虑有效字符。
我们实现的reserve不可以缩容。
void reserve(size_t n) { if (n > _capacity) { char* tmp = _str; //比需求多开一个字节的空间 _str = new char[n + 1]; strcpy(_str, tmp); //别忘记_capacity _capacity = n; delete[] tmp; } }
尾插字符串
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+=(const string& str) { append(str.c_str()); return *this; } string& operator+=(const char* str) { append(str); return *this; } string& operator+=(char ch) { push_back(ch); return *this; }
成员函数swap
//不用进行深拷贝，直接交换地址和大小 void swap(string& s) { std::swap(_size, s._size); std::swap(_capacity, s._capacity); std::swap(_str, s._str); }
清空字符串函数
void clear() { memset(_str, 0, _size); }
返回有效字符数量 ，判断是否为空
size_t size()const { return _size; } bool empty()const { return _size == 0; }
重载[]运算符，我们重载两个版本的，重载const版本是因为我们有时候只读，不写，所以需要这样的重载。
char& operator[](size_t index) { return _str[index]; } const char& operator[](size_t index)const { return _str[index]; }
find函数，找到后返回下标。strstr找到后返回的是找到的字符串的首地址，否则返回空。
size_t find(char c, size_t pos) const { for (size_t i = pos; i < _size; i++) { if (_str[i] == c) { return i; } } return npos; } //hello world size_t find(const char* s, size_t pos = 0) const { char* tmp = strstr(_str, s); if (tmp == nullptr) { return npos; } return tmp - _str; }
insert函数，从pos位置插入单个字符，以及字符串
string& insert(size_t pos, char c) { assert(pos <= _size); if (_size == _capacity) { _capacity = 0 ? 4 : _capacity * 2; char* tmp = new char[_capacity + 1]; strcpy(tmp, _str); delete[] _str; _str = tmp; } int end = _size; while (end >= (int)pos) { _str[end + 1] = _str[end]; end--; } _str[pos] = c; _size++; return *this; } //pos是下标 string& insert(size_t pos, const char* str) { assert(pos <= _size); int len = strlen(str); if (len + pos > _capacity) { reserve(len + pos); } int end = _size; while (end >= (int)pos) { _str[end + len] = _str[end]; end--; } strncpy(_str + pos, str, len); _size += len; return *this; }
erase函数，删除从pos节点开始的len个字符
string& erase(size_t pos, size_t len) { //如果pos == size就和没删除一样，相当于删\0 assert(pos < _size); //从pos位置删除len个字符,也就是pos后的字符全部删掉 //传的len值接近npos,pos+len可能溢出，也会有未知错误 if (len == npos || pos + len >= _size) { _str[pos] = '\0'; _size = pos; } else { strcpy(_str + pos, _str + pos + len); _size -= len; } return *this; }
substr，截取从pos位置开始长度为len的字符串 ，在他返回时，就是对象的值拷贝，会有临时对象产生，临时对象就需要我们自己写的拷贝构造函数了。
string substr(size_t pos = 0, size_t len = npos) { assert(pos < _size); int end; string str; //hello world 2 3 if (len == npos || pos + len > _size) { end = _size; } else { end = pos + len; } //记得给str扩容 str.reserve(end - pos); while (end > pos) { str += _str[pos++]; } return str; }
