hello，又见面了！
C++_云边有个稻草人的博客-CSDN博客------C++专栏（质量分高达97！）
菜鸟进化中。。。
目录
[1.1 C语言中的字符串](#1.1 C语言中的字符串)
[1.2 面试题(暂不做讲解)](#1.2 面试题(暂不做讲解))
[二、 标准库中的string类](#二、 标准库中的string类)
[2.1 string类(了解)](#2.1 string类(了解))
[2.2 auto和范围for](#2.2 auto和范围for)
[2.3 string类的常用接口说明（注意下面我只讲解最常用的接口）](#2.3 string类的常用接口说明（注意下面我只讲解最常用的接口）)
[2.3.1 string类对象的常见构造](#2.3.1 string类对象的常见构造)
[2.3.2 string类对象的容量操作](#2.3.2 string类对象的容量操作)
[2.3.3 string类对象的访问及遍历操作](#2.3.3 string类对象的访问及遍历操作)
[【operator[ ]】](#【operator[ ]】)
[2.4 string类对象的Element access（元素存取）](#2.4 string类对象的Element access（元素存取）)
[2.5 string类对象的修改操作](#2.5 string类对象的修改操作)
[2.6 String类内部扩容细节](#2.6 String类内部扩容细节)
[2.7 小试牛刀](#2.7 小试牛刀)
------------------------------------------《Rain》------------------------------------------
正文开始------
一、为什么要学习string类？
1.1 C****语言中的字符串
C 语言中，字符串是以 '\0' 结尾的一些字符的集合，为了操作方便， C 标准库中提供了一些 str 系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP 的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
1.2面试题(暂不做讲解)
415. 字符串相加 - 力扣（LeetCode）
在 OJ 中，有关字符串的题目基本以 string 类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string 类，很少有人去使用 C 库中的字符串操作函数。
二、标准库中的string****类
2.1 string类(了解)
https://cplusplus.com/reference/string/string/?kw=string，最好观看第一手的资料，自己阅读英文版
C++标准库都封装在std这个命名空间里面的，在使用string类时，必须包含****#include头文件以及using namespace std;
cpp
#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
//class string
//{
//public:
// s2[]的底层
// //为什么string类的对象能直接利用[]来访问和修改元素呢？下面是[]运算符的重载，引用返回能直接修改元素
// char& operator[](size_t pos)
// {
// assert(pos < _size);
// return _str[pos];
// }
//private:
// char* _str;
// size_t _size;
// size_t _capacity;
//};
int main()
{
string s1;//空字符串
string s2("1111122222");//将字符串拷贝s2进行赋值
string s3("1111111111", 3);//拷贝字符串里面的前3个字符
string s4(100, 'x');
string s5(s2, 4, 3);//这里的4（pos）指的是下标
string s6(s2,9);
string s7(s2,4,90);
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
cout << s4 << endl;
cout << s5 << endl;
cout << s6 << endl;
cout << s7 << endl;
//s2.operator[](0) = 'x';相当于调用的函数
s2[1] = 'x';//直接像数组一样利用下标来修改内容
cout << s2 << endl;
//利用循环来遍历s2
for (int i = 0; i < s2.size(); i++)
{
s2[i]++;
}
cout << s2 << endl;
return 0;
}
2.2 auto和范围for
auto****关键字
- 在早期C/C++中auto的含义是：使用**auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。**C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期****推导而得。
- 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加**&。**
- 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际****只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
- auto****不能作为函数的参数（C++20开始支持），可以做返回值但是建议谨慎使用，见下：
- auto****不能直接用来声明数组
auto有啥用呢，价值在哪里呢？
cpp
int main()
{
int i = 0;
int j = 0;
//自动推导类型,根据等号右边的数据来自动推导左边数据的类型
auto z = i; // int
auto m = 1.1; //double
auto p = &i; //int*
int& r1 = i; //r1的类型是int&,不是int
auto r2 = r1; //int，不是int&
auto& r3 = r1; //int&
//auto r4; //报错
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
//利用迭代器来遍历链表
list<int>::iterator it = lt.begin();
auto it = lt.begin();//在这里使用迭代器就非常的爽！不用再写那么长的代码了
while (it != lt.end())
{
cout << *it << " ";
it++;
}
cout << endl;
// 后面学了map用auto会更爽，我们先引入map的迭代器看看这里使用auto的感觉
// auto语法糖 ---> 简化代码，替代写起来长的类型
std::map<std::string, std::string> dict;
//std::map<std::string, std::string>::iterator dit = dict.begin();
auto dit = dict.begin(); //很甜，超级甜~
return 0;
}范围****for
- 对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号"："分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。
- 范围for可以作用到数组和容器对象上进行遍历。
- 范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。
cpp
int main()
{
string s1("hello world");
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
// 范围for
// 适用于容器遍历和数组遍历
// 自动取容器的数据赋值给左边的对象，左边的对象的名称随便取
// 自动++，自动判断结束
// 原理：范围for底层是迭代器
//for (char ch : s1)
for (auto ch : s1)//这里更喜欢用auto
{
cout << ch << " ";
}
cout << endl;
//for (int n : lt)
for (auto n : lt)
{
cout << n << " ";
}
cout << endl;
return 0;
}
有一个问题，如果按下面的代码数组里面的内容会不会被修改呢？
cpp
for (auto ch : s1)//这里更喜欢用auto
{
cout << ch << " ";
}
cout << endl;
for (auto ch : s1)//这里更喜欢用auto
{
ch++;
}
for (auto ch : s1)//这里更喜欢用auto
{
cout << ch << " ";
}
cout << endl;
为什么呢？
前面讲的只是单纯的赋值，并不能改变里面的数据，加上&即可，真是嘎嘎嘎香
对于范围for哪两种情况下要用引用呢？
- 修改容器里面的数据
- 如果容器里面存的是比较大的对象，那我们最好用引用以减少拷贝（如果我们用引用同时又不想修改里面的内容，就可以用const引用）
总结一下，对于string有三种遍历方式，这三种遍历方式都可读可写
-
下标 \]，对于sring和vector会比较方便，不适用于物理存储空间不连续的容器
- 范围for
什么类都可以用范围for吗？
不是，像日期类，没有这种用法。原理：范围 for 的底层是迭代器
2.3 string****类的常用接口说明（注意下面我只讲解最常用的接口）
2.3.1 string****类对象的常见构造
2.3.2 string****类对象的容量操作
注意：
- size()与length()（都不包含最后结尾的\0）方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
- clear()只是将string中有效字符清空，不改变底层空间大小。
- resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
- reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
- max_size指最大能开到多少空间，不切实际没有什么意义，不同平台下返回的值不同。
【reserve 和 reverse】见下：
cpp
//reserve 保留 预留
//reverse 反转 翻转
int main()
{
string s1;
// 提前开空间，避免扩容（这是在知道大概需要多少空间的情况下比较好）
s1.reserve(200);//编译器会开的比200大，同样满足需求，但是不会是小
cout << s1.capacity() << endl;
return 0;
}2.3.3 string****类对象的访问及遍历操作
【operator[ ]】
上次我们学的日期类里面的取地址运算符的重载也是支持const对象和普通对象都可以调用。
【遍历begin+end+迭代器第一弹】
cpp
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s1("hello world");
//[下标]的方式去遍历
for (int i = 0; i < s1.size(); i++)
{
s1[i]++;//利用下标去修改数组的内容
}
for (int i = 0; i < s1.size(); i++)
{
cout<<s1[i]<<" ";
}
cout << endl;
// 迭代器---像指针一样的对象（有可能是指针，有可能不是指针，要看底层的实现）
// iterator是一个类型，是属于string类里面的一个内部类
string::iterator it1 = s1.begin();
while (it1 != s1.end())//s1.end()指向的是最后一个数据的下一个位置
{
(*it1)--;
++it1;//*it1就是这个位置，++来走到下一个位置
}
it1 = s1.begin();
while (it1 != s1.end())//s1.end()指向的是最后一个数据的下一个位置
{
cout << (*it1) << " ";
++it1;//*it1就是这个位置，++来走到下一个位置
}
cout << endl;
return 0;
}
用下标的访问方式来修改和读取数据很香，为啥还要用迭代器呢？
用下标访问的方式只适用于string和vector这样的结构，string和vector底层是连续的物理空间，用[ ]来访问就很方便，，但是我们后面学习链表和树形结构再用[ ]来访问就很不方便。[ ]不是通用的方式，而迭代器是通用的方式
看看下面举例迭代器具体在哪里使用------list（记得加上头文件#include<list>）
所有的容器都要定义迭代器，迭代器是所有容器通用的一种东西，都可以使用迭代器去遍历，所使用的方式也都是很相似的
cpp
int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
//利用迭代器来遍历链表
list<int>::iterator it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
it++;
}
cout << endl;
return 0;
}
【迭代器第二弹】
cpp
int main()
{
string s1("hello world");
string::reverse_iterator rit = s1.rbegin();
while (rit != s1.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
return 0;
}
【const对象的迭代器和反向迭代器】
cpp
int main()
{
const string s1("hello world");
string::const_reverse_iterator rit = s1.rbegin();//不能修改容器里面的内容
while (rit != s1.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
const string s2(s1);
string::const_iterator it = s2.begin();//不能修改容器里面的内容，这里可以用auto
while (it != s2.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
上面介绍的就是我们常用的四种迭代器，iterator，reverse_iterator，const_iterator，const_reverse_iterator，其他的cbegin啥的我们不常用。
2.4 string类对象的Element access（元素存取）
对于operator[ ]，见下：
对于at，不同于operator[]直接assertion报错at会有抛出异常机制，见下：
back，front 返回的是最后一个字符和第一个字符，我们用[ ]和at也可以实现，注意返回的是引用，可以用来修改数据。（具体自己来查看文档）
cpp
int main()
{
try
{
string s1("hello world1111");
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;//空间大小，其实比本身容量还要再大一个
cout << s1.max_size() << endl;
cout << endl << endl;
s1.clear();
cout << s1.size() << endl;
cout << s1.capacity() << endl;
//s1[20];
s1.at(20);
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}2.5 string类对象的修改操作
注意：
-
- 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
cpp
int main()
{
//其实string底层跟我们前面学的顺序表很相似
class String
{
public:
//...
private:
char buff[16];
char* _str;
size_t size;
size_t _capacity;
}
//利用push_back只能插入单个字符
string s1("hello");
s1.push_back(',');
s1.push_back('w');
cout << s1 << endl;
//利用append来插入字符串，具体更多用法查看文档
s1.append("orld");
cout << s1 << endl;
s1.append(10, '~');
cout << s1 << endl;
string s2("hello pig");
//利用迭代器
s1.append(s2.begin(), s2.end());//将一整串都直接插入到s1的后面
cout << s1 << endl;
s1.append(s2.begin()+6, s2.end());//可以定位s2的字符将其插入
cout << s1 << endl;
//但是我们更多是使用+=这个运算符重载,这个确实更香，不经常使用push_back和append
string s3("hello");
s3 += ',';
s3 += "world";
cout << s3 << endl;
return 0;
}
2.6 String类内部扩容细节
cpp
int main()
{
string s1;
size_t old = s1.capacity();
for (int i = 0; i < 200; i++)
{
s1 += 'x';
if (s1.capacity() != old)
{
cout << "capacity:"<< s1.capacity() << endl;
old = s1.capacity();
}
}
cout << endl;
string s2("11111111");
string s3("111111111111111111111222222222222222222");
cout << sizeof(s2) << endl;
return 0;
}2.7 小试牛刀
感慨一下，学了一些算法思想思路确实就是不一样了哈，继续学起来。对于本题，不难看出要使用双指针算法，经典的双指针算法。
值得一提的是，我们要单独写一个判断是否是字母的函数，这样在while循环里面的条件就比较好写。这也是我第一次用C++来写算法题，那就一个方便呀，以前过得是什么苦日子~
现在基本啥都有了，以前是啥也没有纯纯自己造啊/woqu,还有，甘蕉力扣比洛谷刷题感觉好。
cpp
class Solution {
public:
// 单独写一个函数------判断是否是字母
bool isLetter(char ch) {
if (ch >= 'a' && ch <= 'z')
return true;
if (ch >= 'A' && ch <= 'Z')
return true;
return false;
}
string reverseOnlyLetters(string s) {
int begin = 0;
int end = s.size() - 1;
while (begin < end) {
while (begin < end && !isLetter(s[begin])) {
begin++;
}
while (begin < end && !isLetter(s[end])) {
end--;
}
// 交换
swap(s[begin], s[end]);
begin++;
end--;
}
return s;
}
};387. 字符串中的第一个唯一字符 - 力扣（LeetCode）
387. 字符串中的第一个唯一字符 - 力扣（LeetCode）
string，vestor，list 都想实现逆置，逆置的底层逻辑是一样的，有点想实现逆置的函数模版，但是string，vector，list的底层结构不一样就无法直接写一个逆置的函数模版，但是！它们共同的一点都有迭代器，哈哈此时我们可以写一个关于迭代器的逆置函数模版，只要给我你的迭代器我就可以实现这些容器的逆置。
cpp
class Solution {
public:
string addStrings(string num1, string num2) {
string str;
str.reserve( max(num1.size(), num2.size()) + 1);
int end1 = num1.size()-1,end2 = num2.size()-1;
int next = 0;
while(end1 >= 0 || end2 >= 0)
{
int x1 = end1 >= 0 ? num1[end1--]-'0' : 0 ;
int x2 = end2 >= 0 ? num2[end2--]-'0' : 0 ;
int ret = x1 + x2 + next;
next = ret / 10;
ret = ret % 10;
str += ret+'0';
}
if(next == 1)
{
str += '1';
}
reverse(str.begin(),str.end());
return str;
}
};
557. 反转字符串中的单词 III - 力扣（LeetCode）
今天就先学到这里吧，剩下的明天继续更！
完------
------------------------------------------《Rain》------------------------------------------
Rain_秦基博_高音质在线试听_Rain歌词|歌曲下载_酷狗音乐
至此结束------
我是云边有个稻草人
期待与你的下一次相遇！
(有机会再看一遍怪奇物语全季)