C++——string 类
1. 标准库中的string类
头文件 #include
目录
1. 标准库中的string类头文件 #include
1. string类对象的常见构造
2. string类对象的容量操作
2.1 auto和范围for
auto关键字
在迭代器里面：
范围for
范围for使用aotu
3. string类对象的访问及遍历操作
4. string类对象的修改操作
5. string类非成员函数
6. string类的模拟实现
6.1 经典的string类问题
6.2 浅拷贝
6.3 深拷贝
6.3.1 传统版写法的String类
6.3 写时拷贝(了解)写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
1.1 string类的常用接口说明（注意下面我只讲解最常用的接口）
1. string类对象的常见构造
| string() （重点） | 构造空的string类对象，即空字符串 |
| string(const char* s) （重点） | 用C-string来构造string类对象 |
| string(size_t n, char c) | string类对象中包含n个字符c |
| string(const string&s) （重点） | 拷贝构造函 |
void Teststring()
{
string s1; // 构造空的string类对象s1
string s2("hello bit"); // 用C格式字符串构造string类对象s2
string s3(s2); // 拷贝构造s3
}2. string类对象的容量操作
| 函数名称 | 功能说明 |
| 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, charc)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
string s;
//reserve 开空间 为字符串预留空间
//提前开空间，避免扩容，提高效率
//reserve不会改变s.size()的大小，特别是reserve企图把s的大小变小时，最小只能变成s所存的内存大小
//但是capacity会跟着reserve改变
s.reserve(100)；//开内存空间的大小，但会涉及内存对齐
//返回空间总大小
int sz=s.capacity();
//扩容插入
s.resize(n)
//如果n比size小，就会删除数据，如果比size大就会扩容，插入数据
s[i] //可以特别访问i位置的字符头插 和 中间插入：s.insert("插入位置"，“插入内容”);
#include
using namepace std;
int main()
{
string s;
s = "xxxyyy";
cout << s << endl;
//头插
s.insert(0, "hello");
cout << s << endl;
//中间插入
s.insert(3, "bit");
cout << s << endl;
//插入一个字符
char ch='t'；
s.insert(0,1,ch);
s.insert(s.begin(),ch);
return 0;
} 删除：s.erase(); s.erase("要开始删除的下标位置"，“要删除几个字符”);
//下标为1的位置删除一个字符
s.erase(1, 1);
//下标为0的位置删除3个字符
s.erase(0, 3);
//若只写一个参数，那么就从下标开始全部删除后面的字符
string = "hello world";
s.erase(6);//"hello"替换：string& replace(size_t pos, size_t len, string& str);
//与s[i]不同，这可能会覆盖数据，但replace就会移动数据
string s="hello world";
s.replace(5,1,"%%"); //"hello%%world"查找：size_t find(const string& str,size_t pos = 0) const;
查找+替换
string s("hello bit hello world");
cout << s << endl;
int pos = s.find(' ');
//整形的最大下标就是npos，如果没有找到就返回npos ，，string::npos
while (pos != string::npos)
{
s.replace(pos, 1, "%%");
pos = s.find(' ');
}
cout << s; //hello%%bit%%hello%%world
//但上面效率实在太低，每次遇到依次空格，字符串就要整体后移，
//如果构造一个新的字符串，就只要O(n)
string tmp;
for(auto e : s)
{
if(e==' ') tmp+="%%";
else tmp+=e;
}string s.substr():查找到对应下标字母
size_t s.find() + size_t rfind():
string s = "abcdefg";
string str=s.substr(3, 2);
cout << str << endl; //de
int pos = s.find("d");
string _str = s.substr(pos);
cout << _str<输出流：cin 和 getline()
cin:（遇到换行和空格都分割）
string str1, str2;
cin >> str1 >> str2; //asd jkl
cout << str1 << endl << str2 << endl; //自动遇到空格分隔 str1="asd" str2="jkl"
getline:(默认只遇到换行才分割)
string s;
getline(cin,s); //asd jkl
cout<2.1 auto和范围for
auto关键字
1)在这里补充2个C++11的小语法，方便我们后面的学习。
2)在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
3)用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
4)auto不能作为函数的参数，可以做返回值，但是建议谨慎使用
5)auto不能直接用来声明数组
在迭代器里面：
#include
#include
#include 范围for
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此
C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。范围for可以作用到数组和容器对象上进行遍历
范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。
范围for使用aotu
string s1="asdfg";
for(auto ch : s1) cout<3. string类对象的访问及遍历操作
| 函数名称 | 功能说明 |
| operator[] （重点） | 返回pos位置的字符，const string类对象调用 |
| begin+ end | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
| rbegin + rend | begin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
4. string类对象的修改操作
| 函数名称 | 功能说明 |
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+= (重点) | 在字符串后追加字符串str |
| c_str(重点) | 返回C格式字符串 |
| find + npos(重点) | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
注意：
1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
5. string类非成员函数
| 函数 | 功能说明 |
| operator+ | 尽量少用，因为传值返回，导致深拷贝效率低 |
| operator>> （重点） | 输入运算符重载 |
| operator<< （重点） | 输出运算符重载 |
| getline （重点） | 获取一行字符串 |
| relational operators （重点） | 大小比较 |
上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。
6. string类的模拟实现
6.1 经典的string类问题
上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下string类的实现是否有问题？
6.2 浅拷贝
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。父母给每个孩子都买一份玩具，各自玩各自的就不会有问题了。
6.3 深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
6.3.1 传统版写法的String类
class String
{ p
ublic:
String(const char* str = "")
{
// 构造String类对象时，如果传递nullptr指针，可以认为程序非
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
String& operator=(const String& s)
{
if (this != &s)
{
char* pStr = new char[strlen(s._str) + 1];
strcpy(pStr, s._str);
delete[] _str;
_str = pStr;
}
return *this;
}
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};6.3.2 现代版写法的String类
class String
{
public:
String(const char* str = "")
{
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(nullptr)
{
String strTmp(s._str);
swap(_str, strTmp._str);
}
// 对比下和上面的赋值那个实现比较好？
String& operator=(String s)
{
swap(_str, s._str);
return *this;
}
/*
String& operator=(const String& s)
{
if(this != &s)
{
String strTmp(s);
swap(_str, strTmp._str);
}
return *this;
} */
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};6.3 写时拷贝(了解)
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源.