上次介绍了标准库里的string类以及常用接口：【C++】String类：标准库介绍-CSDN博客
本次就来亲自动手来模拟实现下
目录
一.基本结构
二.构造函数（constructor）
1.构造函数
2.拷贝构造
3.c_str()
三.析构函数（destructor）
四.operator=
五.迭代器（iterator）
六.容量操作（capacity）
七.修改操作（modify）
八.访问操作（access）
九.查找操作（find）
十.插入和删除（insert and erase）
十一.关系比较运算符（relational operators）
十二.流操作重载
一.基本结构
根据string标准库的文档：string - C++ Reference (cplusplus.com)
可以看见string类大致分为这么几个部分，那么我们的实现也根据这些功能来大致实现
此时，可以创建头文件：string.h 实现文件：string.cpp 测试文件：test.cpp
在自定义的命名空间内创建string类，配上基本结构：
namespace zyh
{class string{public://各种函数private:char* _str;//没有设计成模板，直接使用char数组size_t _size;//有效字符的个数size_t _capacity;//分配空间的大小static const size_t npos;//在外初始化为-1};
}
二.构造函数（constructor）
1.构造函数
无参的构造函数，构造的是空字符串，但空字符串不代表什么都没有，只要是字符串，哪怕是空，也存在\0，这是字符串的标志，因此无参构造时也要开辟出一个char的空间并用\0来初始化
//无参
string():_str(new char[1]{'\0'}),_size(0) ,_capacity(0)
{}//有参
string(const char* str)
{_size = strlen(str);_capacity = _size;//capactiy不包含'\0'_str = new char[_capacity + 1];strcpy(_str, str);
}当然也可以合二为一，直接使用缺省参数
string(const char* str = "")
{_size = strlen(str);_capacity = _size;//capactiy不包含'\0'_str = new char[_capacity + 1];strcpy(_str, str);
}2.拷贝构造
传统写法：
string(const string& s)
{_size = s._size;_capacity = s._capacity;_str = new char[_capacity + 1];strcpy(_str, s._str);
}现代写法：使用中转站临时对象tmp来交换得到
要使用s1来拷贝构造s3,那么只需要使用s1的字符串来构造一个临时对象tmp，再将s3的内容与tmp进行交换即可
void swap(String& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}string(const string& s)
{string tmp(s._str);swap(tmp);
}3.c_str()
目前还没有对string类进行流操作的重载，因此想要打印字符串，此处提供c_str()方法来得到成员_str，以此来进行打印
const char* c_str()const
{return _str;
}三.析构函数（destructor）
~string()
{delete[] _str;_str = nullptr;_size = _capacity = 0;
}四.operator=
注意=（赋值运算）是有返回值的，返回值就是它本身，因此返回值类型为string&，同时为了防止自身给自身赋值，加入判断this是否指向参数，否则会出错
string& operator=(const string& s)
{if (this != &s){//清除旧空间delete[] _str;_size = s._size;_capacity = s._capacity;//开辟新空间_str = new char[_capacity + 1];//并且复制strcpy(_str, s._str);}return *this;
}五.迭代器（iterator）
这里我们使用指针来模拟迭代器，那么就将char*类型的指针重命名为iterator
同理，那么const_iterator是针对常量的，那么就是对应const char*
//迭代器
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{return &_str[0];
}
iterator end()
{return &_str[_size];
}
const_iterator begin()const
{return _str;
}
const_iterator end()const
{return _str + _size;
}六.容量操作（capacity）
//capacity
size_t size()const
{return _size;
}
size_t capacity()const
{return _capacity;
}
bool empty()const
{return (_size == 0);
}
void reserve(size_t n)
{if (n > _capacity){char* tmp = new char[n + 1];_capacity = n;strcpy(tmp, _str);delete[] _str;_str = tmp;}
}
void resize(size_t n, char c)
{if (n > _size){int i = n - _size;while (i--){push_back(c);}}_size = n;
}七.修改操作（modify）
void push_back(char c)
{//扩容if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);//考虑空的情况}_str[_size++] = c;_str[_size] = '\0';
}
string& operator+=(char c)
{push_back(c);return *this;
}
void append(const char* str)
{size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}strcpy(_str + _size, str);_size = _size + len;
}
string& operator+=(const char* str)
{append(str);return *this;
}
void clear()
{char* tmp = new char[_capacity + 1];tmp[0] = '\0';_str = tmp;_size = 0;
}八.访问操作（access）
//access
char& operator[](size_t pos)
{assert(pos < _size);return _str[pos];
}
const char& operator[](size_t pos)const
{assert(pos >= 0 && pos < _size);return _str[pos];
}九.查找操作（find）
size_t find(char c, size_t pos) const
{assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == c){return i;}return npos;}
}
size_t find(const char* s, size_t pos) const
{assert(pos < _size);const char* ptr = strstr(_str + pos, s);if (ptr == nullptr){return npos;}else{return ptr - _str;}
}十.插入和删除（insert and erase）
//在pos位置上插入字符c
string& insert(size_t pos, char c)
{assert(pos <= _size);if (_size == _capacity){reserve((_capacity == 0) ? 4 : 2 * _capacity);}//向后移动size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];end--;}_str[pos] = c;_size++;return *this;
}//在pos位置上插入字符串str
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--;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;return *this;
}string& erase(size_t pos, size_t len)
{assert(pos < _size);if (len >= _size - pos){_str[pos] = '\0';_size = pos;}else{for (size_t i = pos + len; i <= _size; i++){_str[i - len] = _str[i];}_size -= len;}return *this;
}十一.关系比较运算符（relational operators）
//使用strcmp实现两个即可，此处实现了小于和等于
//其余的使用已实现的逻辑即可
bool operator<(const string& s)
{return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s)
{return (*this < s) || (*this == s);
}
bool operator>(const string& s)
{return !(*this <= s);
}
bool operator>=(const string& s)
{return !(*this < s);
}
bool operator==(const string& s)
{return strcmp(_str, s._str) == 0;
}
bool operator!=(const string& s)
{return !(*this == s);
}十二.流操作重载
注意必须是全局声明，为什么？因为如果是成员函数，那么只需用this指针即可，但这样的话，就必须要string<<cout ( string.operator<<(cout) )了，很明显与平时使用的顺序不同，为了调整参数位置使得其按正确顺序，就必须声明在全局而不使用this指针，这一点友元就能做到。
还有值得注意的一点是返回值，必须是ostream&，这是为了能够连续的使用流操作符
//在外部实现，内部声明友元类
ostream& operator<<(ostream& _cout, const zyh::string& s)
{for (auto ch : s){_cout << ch;}return _cout;
}
istream& operator>>(istream& _cin, zyh::string& s)
{s.clear();//防止频繁扩容const int N = 256;char buff[N];int i = 0;char ch = _cin.get();while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == N - 1){buff[i] = '\0';s += buff;i = 0;}//s += ch;ch = _cin.get();}buff[i] = '\0';s += buff;return _cin;
}
