一.string类介绍

  C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
  C++中将string封装为单独的类，string 类是 C++ 标准库中的一个非常重要的类，用于表示和操作字符串。string类位于命名空间std（标准库）下，使用string类记得加上头文件#include，并且使用命名空间using namespace std或者using std::string。

//使用时记得加上
#include<string>
using std::string;//或者using namespace std;//源代码大致框架
namespace std
{class string{private:char* _str;size_t _size;size_t _capacity;};
}

二.string类的静态成员变量

静态成员变量：static const size_t npos = -1;

int main()
{//static const size_t npos = -1;//typedef unsigned long long size_t//-1的原码：10000000 00000000 00000000 00000001//-1的反码：11111111 11111111 11111111 11111110//-1的补码：11111111 11111111 11111111 11111111//npos：-1的补码按照无符号整形打印出的值，由于静态成员变量，类外使用时加上类域cout << string::npos << endl;//32位环境：4294967295return 0;
}

三.string类的常用接口

1.构造函数（constructor）

1. 无参构造：string(); 构造空的string类对象，即空字符串。常用。
2. 有参构造：string (const char* s); 用常量字符串来构造string类对象常用。
3. 拷贝构造：string (const string& str); 用str拷贝构造string类对象常用。
4. string (const string& str, size_t pos, size_t len = npos); 构造从下标pos开始，长度为len的子串，含缺省参数npos。
5. string (const char* s, size_t n); 构造前n个字符组成的子串。
6. string (size_t n, char c); 构造n个字符c组成的字符串。

int main()
{string s1;string s2("hello xzy");string s3(s2);string s4(s2, 6, 8);string s5("hello xzy", 5);string s6(10, 'x');cout << s1 << endl;//输出：cout << s2 << endl;//输出：hello xzycout << s3 << endl;//输出：hello xzycout << s4 << endl;//输出：xzycout << s5 << endl;//输出：hellocout << s6 << endl;//输出：xxxxxxxxxxreturn 0;
}

2.析构函数（destructor）

~string(); 程序结束前自动调用，释放堆区动态开辟的资源

3.运算符重载（operator）

1.operator=

1. string& operator= (const string& str); 常用。

2. string& operator= (const char* s);

3. string& operator= (char c);

int main()
{string s1;string s2;string s3;//赋值重载s1 = "hello xzy";s2 = s1;s3 = 'v';//拷贝构造string s4 = s1;cout << s1 << endl;//输出：hello xzycout << s2 << endl;//输出：hello xzycout << s3 << endl;//输出：vcout << s4 << endl;//输出：hello xzyreturn 0;
}

2.operator[]

4. char& operator[] (size_t pos); 返回字符引用，用于下标访问，且可以修改。常用。

int main()
{string s1("hello xzy");s1[6] = 'w';s1[7] = 'j';s1[8] = '\0';cout << s1 << endl;//输出：hello wjs1[10] = 'A';//下标越界，内部断言assert报错return 0;
}

3.operator+=

5. string& operator+= (const string& str); 常用。
6. string& operator+= (const char* s);
7. string& operator+= (char c);

int main()
{string s1("hello xzy");string s2(" how are you");s1 += s2;cout << s1 << endl;s1 += "???";cout << s1 << endl;s1 += '!';cout << s1 << endl;return 0;
}

4.operator+

8. string operator+ (const string& lhs, const string& rhs);
9. string operator+ (const string& lhs, const char* rhs);
10. string operator+ (const char* lhs, const string& rhs);

int main()
{string s1("hello");string s2 = s1 + " world";string s3 = "xzy " + s1;string s4 = s2 + s3;cout << s2 << endl; //hello worldcout << s3 << endl; //xzy hellocout << s4 << endl; //hello worldxzy helloreturn 0;
}

4.string的四种迭代器（iterator）

  迭代器是一种用于遍历容器元素的对象（并非类，而是设计模式中的一种行为模式），它提供了一种通用的访问容器元素的方式，无论容器的类型和数据结构如何。迭代器在C++标准库中被广泛使用，特别是在处理如vector、list、map等容器时。

1.正向迭代器 iterator

返回正向迭代器：可以修改字符串。

1. iterator begin(); 返回字符串的第一个字符。
2. iterator end(); 返回字符串最后一个有效字符（不含\0）的下一个字符。

2.反向迭代器 reverse_iterator

返回反向迭代器：可以修改字符串。

3. reverse_iterator rbegin(); 返回字符串最后一个有效字符（不含\0）。
4. reverse_iterator rend(); 返回字符串第一个字符的前一个字符。

3.const修饰的正向迭代器 const_iterator

返回const修饰的正向迭代器：不可以修改字符串。

5. const_iterator begin() const;
6. const_iterator end() const;

4.const修饰的反向迭代器 const_reverse_iterator

返回const修饰的反向迭代器：不可以修改字符串。

7. const_reverse_iterator rbegin() const;
8. const_reverse_iterator rend() const;

5.四种迭代器源代码

int main()
{string s1("hello xzy");string::iterator it = s1.begin();while (it != s1.end()){cout << *it << " ";++it;}cout << endl;string s2("hello xzy");string::reverse_iterator rit = s2.rbegin();while (rit != s2.rend()){cout << *rit << " ";++rit;}cout << endl;const string s3("hello xzy");string::const_iterator cit = s3.begin();while (cit != s3.end()){//*cit += 2; s3不能修改cout << *cit << " ";++cit;}cout << endl;const string s4("hello xzy");string::const_reverse_iterator crit = s4.rbegin();while (crit != s4.rend()){//*crit += 2; s4不能修改cout << *crit << " ";++crit;}cout << endl;return 0;
}

5.string类对象的容量操作

1. size_t size() const; 返回字符串有效字符长度（不包括\0）。常用。
2. size_t length() const; 返回字符串有效字符长度（不包括\0）。
3. size_t capacity() const; 返回空间总大小（不包括\0）。常用。
4. void resize (size_t n); 为字符串预留大于等于n的空间（不包括\0），避免扩容，提高效率。常用。
5. void clear(); 清空数据，但是一般不清容量。常用。
6. bool empty() const; 判断是否为空。常用。
7. void resize (size_t n); 只保留前n个数据。
8. void resize (size_t n, char c); 保留前n个数据，若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不会改变容量大小。

5. 在VS2022中的容量变化：有效数据小于16时，数据存放在_buff中，无需扩容；当有效数据大于等于16时，数据存放在_str中，先2倍扩容一次，之后1.5倍扩容。

6. 再linux中的g++编译器中的容量变化：数据只存放在_str中，容量不足就2倍扩容，感觉相当完美！

//在VS2022下的string类
class string
{
private:char* _buff[16]; //有效数据小于16，存放在这里char* _str;      //有效数据大于等于16，存放在这里size_t _size;size_t capacity;
};
int main()
{string s;size_t sz = s.capacity();cout << "capacity changed: " << sz << '\n';cout << "making s grow:\n";for (int i = 0; i < 100; ++i){s.push_back('c');if (sz != s.capacity()){sz = s.capacity();cout << "capacity changed: " << sz << '\n';}}cout << "VS2022下的string类的大小：" << sizeof(s) << endl;return 0;
}

int main()
{string s1("hello xzy how are you");cout << s1.length() << endl;   //21cout << s1.size() << endl;     //21cout << s1.max_size() << endl; //2147483647cout << s1.capacity() << endl; //31string s2("hello xzy how are you");s2.reserve(100);//扩容：不一定扩100，但一定大于等于n，取决于编译器，Linux中的g++编译器扩的是100cout << s2.empty() << endl;    //0cout << s2.capacity() << endl; //111s2.shrink_to_fit();            //缩容cout << s2.capacity() << endl; //31string s3("hello xzy how are you");s3.resize(9);cout << s3 << endl; //hello xzys3.resize(15, 'w');cout << s3 << endl; //hello xzywwwwwwreturn 0;
}

6.string类对象的修改操作

1. void push_back (char c); 在字符串后尾插字符c。
2. void pop_back(); 在字符串尾删一个字符。
3. string& append (const string& str); 在字符串后追加一个字符串。
4. string& assign (const string& str, size_t subpos, size_t sublen); 拷贝字符串：从下标为subpos开始，拷贝长度为sublen的字符串到string类对象里面。
5. string& insert (size_t pos, const string& str); 在pos位置处插入字符串到string类对象里面。（由于效率问题（移动数据），谨慎使用）。
6. string& erase (size_t pos = 0, size_t len = npos); 从pos位置开始删除长度为npos个字符。（由于效率问题（移动数据），谨慎使用）。
7. string& replace (size_t pos, size_t len, const string& str); 从pos位置开始的长度为len的子串，替换为str。（伴随着插入与删除，效率低，谨慎使用）。
8. void swap (string& str); 交换字符串。

int main()
{string s1("hello xzy");s1.push_back('!');cout << s1 << endl; //hello xzy!s1.pop_back();cout << s1 << endl; //hello xzys1.append(" how are you");cout << s1 << endl; //hello xzy! how are you//可以用+=取代尾插s1 += "???";cout << s1 << endl; //hello xzy! how are you???string s2("hello xzy!!!");string s3;s3.assign(s2, 6, 3);cout << s3 << endl; //xzystring s4("hello xzy");s4.insert(0, "hello wj ");cout << s4 << endl; //hello wj hello xzystring s5("hello xzy!!!");s5.erase(9, 2);cout << s5 << endl; //hello xzy!string s6("hello xzy!!!");s6.replace(6, 5, "wj");cout << s6 << endl; //hello wj!string s7("hello x hello x");string tmp;tmp.reserve(s7.size());for (auto ch : s7){if (ch == 'x')tmp += "wj";elsetmp += ch;}cout << tmp << endl; //hello wj hello wjs7.swap(tmp);cout << s7 << endl;  //hello wj hello wjreturn 0;
}

9. const char* c_str() const; 返回C格式字符串。方便调用C中的接口。

int main()
{string file;cin >> file;//c_str()函数用于调用C语言的函数，若直接传string，类型不符合（类和指针）FILE* fout = fopen(file.c_str(), "r");if (fout == NULL){perror("open file fail!");exit(1);}char ch = fgetc(fout);while (ch != EOF){cout << ch;ch = fgetc(fout);}fclose(fout);fout = NULL;return 0;
}

7.string类对象的查找操作

1. string substr (size_t pos = 0, size_t len = npos) const; 找子串：返回从pos位置开始，长度为npos的string类。
2. size_t find (char c, size_t pos = 0) const; 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置。
3. size_t rfind (char c, size_t pos = npos) const; 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置。
4. size_t find_first_of (const char* s, size_t pos = 0) const; 从字符串pos位置开始从前往后找字符串s中出现的字符，返回该字符在字符串中的位置。
5. size_t find_last_of (const char* s, size_t pos = npos) const; 从字符串pos位置开始从后往前找字符串s中出现的字符，返回该字符在字符串中的位置。
6. size_t find_first_not_of (const char* s, size_t pos = 0) const; 从字符串pos位置开始从前往后找字符串s中没有出现的字符，返回该字符在字符串中的位置。
7. size_t find_last_not_of (const char* s, size_t pos = npos) const; 从字符串pos位置开始从后往前找字符串s中没有出现的字符，返回该字符在字符串中的位置。

int main()
{//suffix：后缀string s1("test.cpp");size_t pos1 = s1.find(".");string suffix1 = s1.substr(pos1);cout << suffix1 << endl; //.cppstring s2("test.cpp.zip");size_t pos2 = s2.rfind(".");string suffix2 = s2.substr(pos2);cout << suffix2 << endl; //.zipstring s3("hello xzy");size_t found = s3.find_first_of("xzy");while (found != string::npos){s3[found] = '*';found = s3.find_first_of("xzy", found + 1);}cout << s3 << endl; //hello ***string str1("/user/bin/man");cout << endl << str1 << "的路径名与文件名如下：" << endl;size_t found1 = str1.find_last_of("/\\");cout << "path：" << str1.substr(0, found1) << endl;cout << "file：" << str1.substr(found1 + 1) << endl;string str2("c:\\windows\\winhelp.exe");cout << endl << str2 << "的路径名与文件名如下：" << endl;size_t found2 = str2.find_last_of("/\\");cout << "path：" << str2.substr(0, found2) << endl;cout << "file：" << str2.substr(found2 + 1) << endl;return 0;
}

8.string类对象的遍历操作

1.下标 + []

int main()
{string s1("hello xzy");//1.下标+[]for (int i = 0; i < s1.size(); i++){s1[i] += 2;//可以修改cout << s1[i] << " ";}cout << endl << s1 << endl;return 0;
}

2.迭代器

int main()
{string s1("hello xzy");//2.迭代器string::iterator it = s1.begin();while (it != s1.end()){*it += 2;//可以修改cout << *it << " ";++it;}cout << endl << s1 << endl;return 0;
}

3.auto和范围for

int main()
{string s1("hello xzy");//3.范围for：字符赋值，自动迭代，自动判断结束//  底层就是迭代器for (auto ch : s1){ch += 2;//修改ch对于s1无影响，ch是它的拷贝cout << ch << ' ';}cout << endl << s1 << endl;return 0;
}

int main()
{string s1("hello xzy");for (auto& ch : s1)//引用：取别名，就可以修改s1{ch += 2;cout << ch << ' ';}cout << endl << s1 << endl;return 0;
}

1.auto关键字

1. 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期 推导而得。

2. 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。

3. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

4. auto不能作为函数的参数，可以做返回值，但是建议谨慎使用。

5. auto不能直接用来声明数组。

#include<map>
//auto不能做参数
//void func1(auto a) error
//{}//auto可以做返回值，但是建议谨慎使用
auto func2()
{return 2;
}int main()
{int a = 10;auto b = a;//编译期间自动推导类型auto c = 'a';auto d = func2();//auto e; auto必须初始化，否则不知道开多少空间int x = 10;auto y = &x;auto* z = &x;//可以不写*auto& m = x;//必须加上&auto aa = 1, bb = 2;//right//auto cc = 3, dd = 4.0; error必须始终推导为同一类型//auto array[] = { 4, 5, 6 }; error数组不能具有其中包含“auto”的元素类型// auto 的价值map<string, string> dict; //初始化二叉树//map<string, string>::iterator mit = dict.begin();auto mit = dict.begin();cout << typeid(mit).name() << endl;return 0;
}

2.范围for

1. 对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。

2. 范围for可以作用到数组和容器对象上进行遍历。

3. 范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

int main()
{int array[] = { 1, 2, 3, 4, 5 };//范围for适用于《容器》和《数组》// C++98的遍历for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++){cout << array[i] << ' ';}cout << endl;// C++11的遍历for (auto& i : array){cout << i << ' ';}cout << endl;return 0;
}

四.非成员函数：getline()

1. istream& getline (istream& is, string& str, char delim); delim：分隔符
2. istream& getline (istream& is, string& str);

类似C语言中的scanf(“%s”, str)，但是其遇到空格会停止；
C++中引入了getline优化了scanf遇到的问题，默认遇到\n才停止，也可以自定义停止字符delim。

例题：字符串最后一个单词的长度

#include <iostream>
#include<string>
using namespace std;int main() 
{string str;getline(cin, str);size_t pos = str.rfind(' ');string sub = str.substr(pos + 1);cout << sub.size() << endl;
}