前言：在C语言中，我们经常使用字符串进行一系列操作，经常使用的函数如下：增删改查
（自己造轮子），C++中设计出string容器，STL库中为我们提供了以上函数，所以我们使用string容器时，就不用造轮子了
参考网站：https://legacy.cplusplus.com/reference/string/string/?kw=string
底层实现，这里我用的是VS的编译器（window）（简化版本），linux（g++）这里使用计数引用（这里不采用计数引用实现）
constructor（构造函数）
第一个（第四个）：是无参构造
#include<string>
#include<iostream>
using namespace std;
int main()
{string s;return 0;
}
s中只含有'\0'（无参构造时）
底层实现：（运用全缺省构造）
string(const char* arr = "")
{int len = strlen(arr);_str = new char[len + 1];// '\0'要单独开空间strcpy(_str, arr);_size = len;_capacity = len;
}第二个：拷贝构造（将 str 中的所有成员变量全部赋值给*this）
string(const string& s)
{_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;
}第三个：将str中的字符串从下标为pos ,拷贝字符的个数为npos
（注意npos 为默然时，则为字符串能存储最多的个数，不是_capacity，而是系统默然能储存的最大值，此时npos = -1）
当npos > len - pos 时 ， 就拷贝全部
举个例子：
destructor（析构函数）
~string()
{delete[] _str;_size = 0;_capacity = 0;
}operator=（赋值重载）
string& operator=(const string& s)
{char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);_size = s._size;_capacity = s._capacity;delete[] _str;_str = tmp;return *this;
}
//现代写法
string& operator=(string s)
{swap(s);return *this;
}
现代写法含义：传参时，s进行拷贝构造，在交换*this与s
iterator（迭代器）
迭代器的行为像指针
范围for的原理就是迭代器
#include<string>
#include<iostream>
using namespace std;
int main()
{string s("0000000000000000000");string::iterator it = s.begin();while (it != s.end()){cout << *it << " ";it++;}cout << endl;
return 0;
}#include<string>
#include<iostream>
using namespace std;
int main()
{string s("0000000000000000000");for( auto e : s )cout << e << " ";cout << endl;return 0;
}这两个代码等效，原理都是迭代器
//迭代器底层实现
char* begin()
{return _str;
}
char* end()
{return _str + _size;
}char* rbegin()
{return _str + _size;
}
char* rend()
{return _str;
}capacity（容量）
_capacity当前开辟的空间最多能储存多少字符
_size代表当前有多少个有效的字符
库里面有提供查询_capacity,_size的函数
int size()
{
return _size;
}
int capacity()
{
return _capacity;
}如何扩容：（库里面有两个函数，可以实现扩容）
第一个reserve
传入一个size_t的参数，作为要扩容到标准
当 n <= _capacity 一般不会造成缩容（这个要具体看编译器）
当 n > _capacity 会扩容
void reserve(size_t n = 0)
{if (n <= _capacity)return;else{char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}
}第二个resize函数
当 n < _size 会造成有效数据的删除（有可能会缩容）
当 n > _size 且n < _capacity 有可能会缩容，但会造成添加有效数据，一直到 n
当 n > _capacity 会造成扩容，并添加有效数据的个数，一直到 n
void resize(size_t n, char c = '\0')
{if (n <= _size){_size = (int)n;_str[n] = '\0';}else{reserve(n);for (; _size < n; _size++){_str[_size] = c;}_str[_size] = '\0';// n为最多有效字符个数,_str[n] = '\0';}
}
clear函数
清空有效数据，令_size = 0;
empty函数
判断有效数据个数是否为0
operator[]
放回下标为pos的字符
char& operator[] (size_t pos)
{assert(pos < _size);return _str[pos];
}
const char& operator[] (size_t pos) const
{assert(pos < _size);return (const char )_str[pos];
}需要assert（判断pos < _size ）,防止对未进行赋值的位置解引用
operator+=（传入的是字符串也可以，因为会进行隐式类型转换）
string& operator+=(const string& s)
{if (s._size + _size > _capacity ){reserve(s._size + _size);}strcpy(_str + _size, s._str);_size += s._size;return *this;
}在字符串末尾添加字符串
具体使用：与整形变量的使用方法一样
append（传入的是字符串也可以，因为会进行隐式类型转换）
string& append(const string& str)
{*this += str;//复用上面的+=return *this;
}举个例子：
push_back
在字符串末尾添加一个字符
void push_back(char ch)
{if (_size == _capacity){reserve(_size * 2);}_str[_size++] = ch;_str[_size] = '\0';
}assign（容量不改变）
第一个,第三个相当与拷贝构造
第二个就是将str中的字符串中的下标从subpos位置的sublen个字符，拷贝给*this
string& assign(const string& str, size_t subpos, size_t sublen)
{assert(_size - subpos >= sublen && sublen >= 0 );if (sublen > _capacity)reserve(sublen + _capacity);memcpy(_str, str._str + subpos, sublen);_size = sublen;_str[_size] = '\0';return *this;
}第四个将s中的字符串前n个字符，给*this;
string& assign(const char* s, size_t n)
{if (n > _capacity)reserve(n);memcpy(_str, s, n);_size = n;_str[_size] = '\0';return *this;
}第五个将n个字符c给*this
string& assign(size_t n, char c)
{if (n > _capacity)reserve(n);for (int i = 0; i < n; i++){_str[i] = c;}_size = n;_str[n] = '\0';return *this;
}insert
请注意可以插入一个string
在pos位置前插入字符或字符串
string& insert(size_t pos, char c)
{
if( _capacity == _size )reserve( 2 * _size );for (size_t i = _size; i > pos; i--){_str[i] = _str[i - 1];}_size++;_str[pos] = c;
}string& insert(size_t pos, const char* str)
{int len = strlen(str);if (len + _size > _capacity)reserve(len + _size);for (size_t i = _size + len ; i >= pos + len; i--){_str[i] = _str[i - len];}_size += len;memcpy(_str + pos, str, sizeof(char) * len);return *this;
}使用方法：
自定义类型的变量 . insert ( 参数列表 ）
erase
string& erase(size_t pos = 0, size_t len = npos)
{assert(pos >= 0);if (pos + len >= _size)_size = pos;else{for (size_t i = pos + len; i < _size; i++){_str[i - len] = _str[i];}_size -= len;}_str[_size] = '\0';return *this;
}从下标为pos的位置，删除len个字符，其中当len == npos时，就将从pos位置起以后（包括pos位置的数据）的数据删除
find
size_t find(char c, size_t pos = 0) const
{for (size_t i = pos; i < _size; i++){if (_str[i] == c)return i;}return -1;//npos
}
size_t find(const char* s, size_t pos = 0) const
{char* tmp = strstr(_str , s );if (tmp == nullptr)return -1;else return tmp - _str;
}找寻_str中是否存在字符c或字符串s,如果存在返回第一次出现时的下标
不存在，返回-1
