目录
二、string常用接口功能简介（具体使用和底层转到模拟实现）
1.2 string(const char* str) //用C - string来构造string类对象
1.3string(const string&s) //拷贝构造函数
2.3empty //检测字符串释放为空串，是返回true，否则返回false
2.6resize //将有效字符的个数该成n个，多出的空间用字符c填充
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，底层空间需要用户自己管理，稍不留神可能还会越界访问
而C++中的string类相比C语言的字符串使用更加简单、方便、快捷，基本很少有人去使用C库中的字符串操作函数
1、字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作
单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信
息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits
和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
| (constructor)函数名称 | 功能说明 |
| string() （重点） | 构造空的string类对象，即空字符串 |
| string(const char* s) （重点） | 用C-string来构造string类对象 |
| string(size_t n, char c) | string类对象中包含n个字符c |
| string(const string&s) （重点） | 拷贝构造函数 |
| 函数名称 | 功能说明 |
| size（重点） | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty （重点） | 检测字符串释放为空串，是返回true，否则返回false |
| clear （重点） | 清空有效字符 |
| reserve （重点） | 为字符串预留空间** |
| resize （重点） | 将有效字符的个数该成n个，多出的空间用字符c填充 |
❗️ 注意：
1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
| 函数名称 | 功能说明 |
| operator[] （重 点） |
返回pos位置的字符，const string类对象调用 |
| begin+ end | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器 |
| rbegin + rend | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
| 函数名称 | 功能说明 |
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+= (重点) | 在字符串后追加字符串str |
| c_str(重点) | 返回C格式字符串 |
| find + npos(重点) | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
❗️ 注意：
- 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
| 函数 | 功能说明 |
| operator+ | 尽量少用，因为传值返回，导致深拷贝效率低 |
| operator>> （重点） | 输入运算符重载 |
| operator<< （重点） | 输出运算符重载 |
| getline （重点） | 获取一行字符串 |
| relational operators （重点） | 大小比较 |
模拟实现仅是简单地实现功能，主要是加深使用；所有接口均在如下类中实现；
#pragma once
//防止冲突，设置命名空间
namespace my{
class string{
public:
private:
char* _str;
size_t _size;//数据大小
size_t _capacity//空间大小;
};
} //生成空字符串
string()
{
_str = new char[1];
_str[0] = '\0';
_size = _capacity = 0;
}空的时候最少要开一个，本次模拟实现的底层是用C的字符串，必须存放一个"\0"标记字符串结尾；
//用C - string来构造string类对象
string(const char* str)
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
} //拷贝构造
string(const string&s){
_str = new char[s._capacity + 1];
_capacity = s._capacity;
_size = s._size;
strcpy(_str, s._str);
} size_t size()const{
return _size;
} size_t capacity()const{
return _capacity;
} bool empty()const{
return this->_size == 0;
} void clear()
{
_size = 0;
_str[0] = '\0';
}clear只是将string中有效字符清空，不改变底层空间大小
void reserve(size_t n){
if (n > _capacity){
char* newCapacity = new char[n + 1];
strcpy(newCapacity, _str);
delete[] _str;
_str = newCapacity;
_capacity = n;
}
}reserve()：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
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;
}
}resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
小，如果是将元素个数减少，底层空间总大小不变。
模拟实现
char& operator[](size_t pos){
return _str[pos];
}
char& operator[](size_t pos)const{
return _str[pos];
}使用示例：
void func(const string& s){
for (size_t i = 0; i < s.size(); i++){
s[i]++;
}
}
int main(){
string s1("hellow world");
for (int i = 0; i < s1.size(); i++)
{
s1[i]++;
}
func(s1);
}为什么实现这个const版本呢，就是为了应对func函数所对应的使用情况；我们知道，const的权限不能放大只能缩小；
模拟实现
在string中，我们可以把迭代器当作一个原生指针；
//迭代器
typedef char* iterator; iterator begin(){
return _str;
}
iterator end(){
return _str+size();
}使用示例：
string s1("hellow world");
//迭代器打印
string::iterator it = s1.begin();
while (it != s1.end()){
std::cout << *it;
++it;
}
std::cout << std::endl;
//范围for打印
for (auto& e : s1){
std::cout << e;
}
std::cout << std::endl;其实范围for的迭代器的的底层就是替换成迭代器 ；
当把类中的begin()屏蔽后，范围for的报错是：
在反汇编中也清晰看到就是调用的迭代器
模拟实现
void push_back(char ch){
if (_size == _capacity){
size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newCapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}模拟实现
void append(const char* str){
size_t len = strlen(str);
if (_size+len > _capacity){
reserve(_capacity+len);
}
strcat(_str+_size, str);
_size += len;
}模拟实现
追加一个字符
string& operator+=(char ch){
push_back(ch);
return *this;
}
追加一个字符串
string& operator+=(const char* str){
append(str);
return *this;
}模拟实现
const char* c_str() const
{
return _str;
}模拟实现
查找单个字符
size_t find(char ch, size_t pos = 0) const
{
assert(pos < _size);
while (pos < _size)
{
if (_str[pos] == ch)
{
return pos;
}
++pos;
}
return npos;
}查找字符串
size_t find(const char* str, size_t pos = 0) const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}