对于C++中string的详细介绍
开篇介绍：
hello 大家，在前面几篇博客中，我们算是把C++中的入门基础+类和对象+模版初阶成功拿下。
那么，接下来我们就要进入C++中真正的重点中了，STL的使用，那么呢，其实也就是直接使用 C++中所提供的现成的数据结构，比如我们今天要讲的string类。
那么string类呀，是一个非常重要也非常好使的一个数据结构，那么接下来，就让我们来详细了解一下C++中的string类。
string的介绍：
在 C++ 中，std::string 是标准库（STL）提供的字符串类，用于高效管理和操作字符序列。它封装了动态字符数组的逻辑，自动处理内存分配与释放，是 C 语言风格字符数组（char[]）的现代化替代方案。以下从定义、特性、操作到高级用法，全面详解 std::string。
一、基本定义与头文件
std::string 位于 std 命名空间，其本质是 std::basic_string 的特化版本（针对单字节字符，如 ASCII、UTF-8）。类似的还有宽字符版本：
std::wstring（basic_string）：用于宽字符（如 Unicode 16/32 位）；std::u16string（C++11，basic_string）：UTF-16 编码；std::u32string（C++11，basic_string）：UTF-32 编码。
日常开发中最常用的是 std::string（单字节字符），使用前需包含头文件并声明命名空间：
#include
using namespace std; // 或显式使用 std::string
二、核心特性
- 可变性：字符串内容可直接修改（区别于 Python
str、JavaString的不可变性）。 - 动态内存管理：自动扩容 / 缩容，无需手动分配 / 释放内存（避免 C 语言
char[]的内存泄漏风险）。 - 与 STL 兼容：支持迭代器、算法（如
std::reverse、std::find），可作为容器使用。 - 编码无关性：仅管理字节序列，不直接处理编码（需结合外部逻辑处理 UTF-8 等多字节编码）。
三、初始化与构造
std::string 提供多种构造方式，覆盖不同场景：
| 构造方式 | 示例代码 | 说明 |
|---|---|---|
| 默认构造 | string s; | 空字符串（长度 0，容量可能为 0 或默认值）。 |
| C 字符串初始化 | string s("hello"); 或 string s = "hello"; | 用 C 风格字符串（const char*）初始化。 |
| 复制构造 | string s1("abc"); string s2(s1); 或 string s3 = s1; | 复制已有字符串。 |
| 截取 C 字符串前 n 个字符 | string s("hello", 3); // 结果："hel" | 取前 3 个字符（超出原长度则取全部）。 |
| n 个重复字符 | string s(5, 'a'); // 结果："aaaaa" | 用 5 个 'a' 初始化。 |
| 范围初始化（迭代器） | string s1("hello"); string s2(s1.begin(), s1.begin() + 3); // "hel" | 用另一个字符串的迭代器范围初始化。 |
| 移动构造（C++11） | string s1("hello"); string s2(std::move(s1)); //s1 变为空，s2 为 "hello" | 转移资源，避免复制（高效）。 |
四、基本操作（元素访问与长度）
1. 元素访问
std::string 支持通过索引或迭代器访问字符，常用方式：
operator[]：直接访问索引位置的字符（不检查越界，越界行为未定义）。at(size_t pos)：访问索引位置的字符（检查越界，越界抛出std::out_of_range异常）。front()/back()：访问第一个 / 最后一个字符（C++11，空字符串调用会导致未定义行为）。- 迭代器：
begin()/end()（正向迭代）、rbegin()/rend()（反向迭代）。
示例：
string s = "hello";
cout << s[1] << endl; // 'e'（无越界检查）
cout << s.at(2) << endl; // 'l'（有越界检查）
cout << s.front() << endl; // 'h'
cout << s.back() << endl; // 'o'
// 迭代器遍历
for (auto it = s.begin(); it != s.end(); ++it) {
cout << *it; // 输出 "hello"
}
2. 长度与容量
std::string 区分 长度（实际字符数） 和 容量（已分配的内存可容纳的最大字符数，不含终止符 ）：
size()/length()：返回当前字符串长度（两者等价，length()是历史遗留，建议用size()）。capacity()：返回当前容量（预分配的内存大小，避免频繁扩容）。empty()：判断是否为空字符串（size() == 0时返回true）。reserve(size_t n)：预分配至少能容纳n个字符的内存（仅增大容量，不改变长度）。shrink_to_fit()（C++11）：将容量缩减至与长度一致（释放多余内存，可能触发重分配）。
示例：
string s = "hello";
cout << s.size() << endl; // 5（实际字符数）
cout << s.capacity() << endl; // 可能为 5 或更大（取决于编译器实现）
s.reserve(10); // 预分配至少 10 个字符的空间
cout << s.capacity() << endl; // ≥10（容量增大，长度仍为 5）
s.shrink_to_fit();
cout << s.capacity() << endl; // 5（容量缩减至与长度一致）
五、修改操作（增删改）
std::string 支持灵活的修改，核心方法如下：
1. 尾部添加
push_back(char c)：在尾部添加单个字符。append(...)：在尾部添加字符串（支持多种参数，如const char*、std::string、子串、重复字符等）。operator+=：简化拼接（支持char、const char*、std::string）。
示例：
string s = "abc";
s.push_back('d'); // s = "abcd"
s.append("ef"); // s = "abcdef"
s.append(2, 'g'); // s = "abcdefgg"
s += "h"; // s = "abcdefggh"
2. 插入字符 / 字符串
insert(pos, ...)：在指定位置 pos 插入内容（pos 为索引，从 0 开始），支持插入：
- 单个字符；
- C 字符串或
std::string； - 子串（指定起始位置和长度）；
- 迭代器范围。
示例：
string s = "abc";
s.insert(1, "xx"); // 在索引 1 插入 "xx" → "axxcb"
s.insert(3, 2, 'y'); // 在索引 3 插入 2 个 'y' → "axxyycb"
3. 删除字符 / 字符串
erase(pos, len)：从位置pos开始删除len个字符（len省略时删除至结尾）。pop_back()（C++11）：删除最后一个字符（等价于erase(size()-1, 1)）。clear()：清空字符串（长度变为 0，容量可能保留）。
示例：
string s = "abcdef";
s.erase(2, 2); // 从索引 2 删 2 个字符 → "abef"
s.pop_back(); // 删除最后一个字符 → "abe"
s.clear(); // 清空 → ""（size=0，capacity 可能不变）
4. 替换子串
replace(pos, len, new_str)：从位置 pos 开始，删除 len 个字符，替换为 new_str（new_str 可以是 const char*、std::string、重复字符等）。
示例：
string s = "hello world";
s.replace(6, 5, "there"); // 从索引 6 删 5 个字符（"world"），替换为 "there" → "hello there"
s.replace(0, 5, 3, 'x'); // 从索引 0 删 5 个字符（"hello"），替换为 3 个 'x' → "xxxt here"
六、字符串拼接与比较
1. 拼接
除了 append() 和 operator+=，还可直接用 operator+ 拼接两个字符串（返回新字符串，原字符串不变）：
string s1 = "hello", s2 = "world";
string s3 = s1 + " " + s2; // s3 = "hello world"
2. 比较
std::string 支持两种比较方式：
- 关系运算符：
==、!=、<、>、<=、>=（按字典序比较，同 C 语言strcmp）。 compare(...)方法：返回整数（0 表示相等，正数表示当前字符串更大，负数表示更小），支持比较子串。
示例：
string s1 = "apple", s2 = "banana";
cout << (s1 < s2) << endl; // true（'a' < 'b'）
cout << s1.compare(s2) << endl; // 负数（s1 < s2）
cout << s1.compare(0, 3, s2, 0, 3) << endl; // 比较 s1[0..2]("app") 和 s2[0..2]("ban") → 负数
七、查找与子串
1. 查找子串
std::string 提供一系列查找方法，返回子串首次出现的索引（未找到返回 std::string::npos，一个静态常量，表示无效索引）：
| 方法 | 功能 | 示例（s = "ababa"） |
|---|---|---|
find(str, pos) | 从 pos 开始查找 str 首次出现位置 | s.find("aba") → 0（从 0 开始找） |
rfind(str, pos) | 从 pos 开始反向查找 str 末次出现位置 | s.rfind("aba") → 2（从末尾反向找） |
find_first_of(str) | 查找 str 中任一字符首次出现位置 | s.find_first_of("xyzab") → 0（找 'a'） |
find_last_of(str) | 查找 str 中任一字符末次出现位置 | s.find_last_of("ab") → 4（最后一个 'a'） |
find_first_not_of(str) | 查找首个不在 str 中的字符位置 | s.find_first_not_of("ab") → npos（全是 'a'/'b'） |
示例：
string s = "hello world";
size_t pos = s.find("world");
if (pos != string::npos) {
cout << "找到，位置：" << pos << endl; // 输出 6
}
2. 截取子串
substr(pos, len)：从位置 pos 开始截取 len 个字符（len 省略时截取至结尾，pos 越界会抛出异常）。
示例：
string s = "hello world";
string sub1 = s.substr(6); // 从 6 开始截取至结尾 → "world"
string sub2 = s.substr(0, 5); // 从 0 开始截取 5 个字符 → "hello"
八、与 C 风格字符串的交互
C++ 中部分场景（如 C 库函数）需要 C 风格字符串（const char*），std::string 提供两种转换方法：
c_str()：返回指向字符串的const char*指针（以data()：C++11 前返回const char*（可能不含c_str()等价（保证以
注意：指针仅在字符串未被修改且未析构时有效（修改字符串会导致指针失效）。
示例：
string s = "hello";
const char* cstr = s.c_str(); // 转换为 C 风格字符串
printf("%s
", cstr); // 输出 "hello"（C 库函数使用）
九、高级用法
1. 迭代器与 STL 算法
std::string 支持迭代器，可直接使用 STL 算法（如 std::reverse、std::sort）：
#include // 包含算法库
string s = "hello";
reverse(s.begin(), s.end()); // 反转字符串 → "olleh"
sort(s.begin(), s.end()); // 排序 → "ehllo"
2. 字符串与数值转换
C++11 起提供了字符串与数值的转换函数（位于
- 字符串转数值：
stoi（int）、stol（long）、stoll（long long）、stof（float）、stod（double）等。 - 数值转字符串：
to_string（支持所有基本数值类型）。
示例
// 字符串转数值
string s1 = "123";
int num1 = stoi(s1); // 123
string s2 = "3.14";
double num2 = stod(s2); // 3.14
// 数值转字符串
int num3 = 456;
string s3 = to_string(num3); // "456"
3. 原始字符串字面量（C++11）
用 R"(...)" 定义原始字符串（忽略转义字符 ），适合路径、正则表达式等场景：
string path = R"(C:Users
ame ile.txt)"; // 无需转义，直接表示 "C:Users
ame ile.txt"
十、注意事项
-
迭代器失效：修改字符串（如
insert、erase、reserve触发扩容）可能导致迭代器、指针、引用失效，需重新获取。string s = "abc"; auto it = s.begin(); s.push_back('d'); // 若触发扩容，it 失效 // *it 行为未定义！需重新获取：it = s.begin(); -
容量与性能：频繁拼接字符串时，提前用
reserve(n)预分配容量可避免多次扩容（每次扩容可能复制整个字符串，耗时）。 -
空字符串处理：对空字符串调用
front()、back()、pop_back()会导致未定义行为，需先用empty()判断。 -
多线程安全：
std::string不是线程安全的，多线程读写需加锁。 -
编码问题：
std::string仅存储字节序列，若处理 UTF-8 等多字节编码（如中文、emoji），需注意：- 单个字符可能占多个字节（如 ' 中 ' 占 3 字节 UTF-8），
size()返回的是字节数而非字符数。 - 直接用
[]访问可能获取到半个字符（导致乱码），需结合编码库（如 ICU）处理。
- 单个字符可能占多个字节（如 ' 中 ' 占 3 字节 UTF-8），
总结
std::string 是 C++ 中处理字符串的首选工具，它结合了 C 风格字符数组的灵活性与 STL 的封装性，提供了丰富的操作接口，同时自动管理内存，大幅降低了出错风险。掌握其初始化、修改、查找等核心操作，以及与 C 风格字符串的交互，能高效处理文本数据。
示例代码：
那么我给大家一些关于string里面的一些比较常用重要的使用样例代码：
#include
#include
using namespace std;
//string
//需要注意，string是个类
//里面存放着动态数组，但是数组里面存储的是字符类型
//class String
//{
//public:
// //成员函数
//private:
// char* _str;//动态数组
// int _size;
// int _capacity;
//};
//string是在std里面的
//std::string;
void teststringconstruct()
{
//default (1) string();无参构造函数
std::string str1;//调用string类中的无参构造函数
cout << str1 << endl;
//from c - string(4) string(const char* s);
string str2("hello world！");//调用string类中的有参构造函数
//括号里面要加双引号，然后再放我们要存储进去的数据
//copy(2) string(const string & str);拷贝构造函数
string str3 = str2;
cout << str3 << endl;
//fill(6) string(size_t n, char c);使用n个c字符去将string数组填充
string str4(5, 'h');//单字符用单引号
cout << str4 << endl;
//substring(3) string(const string & str, size_t pos, size_t len = npos);
//将str的第pos个位置往后一个位置开始，将len个字符填充到创建的新str中
//string::npos指42亿巴拉巴拉，并不是指-1
//即使我们输入的len超出了str的数据长度，编译器也会自动到字符串终止符停下
string str5(str2, 6, 5);
string str6(str2, 6, string::npos);
string str7("hello world", 6, 5);
cout << str5 << endl;
cout << str6 << endl;
cout << str7 << endl;
//from sequence(5) string(const char* s, size_t n);
//从s的第一个数据开始到第n个数据结束，这之间的数据都丢到新创建的str中
string str8("hello world", 5);//但是要注意，此时前面的就不是string类型的了，而是char*类型
//也就代表着我们不能传string类变量进去
cout << str8 << endl;
//需要注意的是，string中也有对<<和>>这个操作符进行重载
//所以我们是可以直接通过<<去对一个string类变量输入数据
//同时我们上面能直接就将一个string类变量的数据都输出
//也是依靠着string类中对<<的重载
//可以参考日期类中对<<和>>的运算符重载函数
string str9;//先创建类变量，然后再去对这个变量进行数据输入
cin >> str9;
cout << str9 << endl;
//string类中还有一个很牛波一的
//就是对[]的运算符重载
//我们可以直接通过string类变量[n]，去访问类变量中下标为n的数据
//数组都是从0开始存储数据的哦
string str10 = "hello world";//拷贝构造函数
cout << str10[0] << str10[5] << str10[10] << endl;
// h ' ' d
//然后就是要知道它[]运算符重载函数返回的是引用，所以可以直接修改
str10[0] = 'q';
cout << str10 << endl;
//string类的析构函数就不需要我们自己调用了
//编译器会自动调用
//~string();
}
void teststringiterator()
{
std::string str1("hello world");
//第一种遍历字符串方式：for循环
//需要注意的是，在string类中，提供了size()这个函数用于返回字符串数组中数据的个数
//所以我们可以直接借助size()这个函数去获取字符串数组中数据的个数
for (int i = 0; i < str1.size(); i++)
{
cout << str1[i] << " ";
}
cout << endl;
//在C++中，还提供了迭代器的一个功能
//应用这个迭代器，我们可以实现高效的遍历数组、字符串等等数据结构
//迭代器可以看作是一种 "指针"，指向容器中的某个元素
//通过迭代器可以读写它所指向的元素
//迭代器可以移动，从而指向容器中的其他元素
//不同容器有不同类型的迭代器，具有不同的功能特性
//使用格式就是类::iterator 创建的变量名字 = 类变量名.某个成员函数
//那么对于最后的成员函数是有不同的函数对应不同的功能
//比如begin()就会返回指向字符串的第一个元素，类似str[0]
//而end()则是指向字符串中最后一个有效数据的后面一个，类似我们实现顺序表时的size
//begin()和end()的返回值都是指针哦，所以我们可以直接用it这个指针变量接收
string::iterator it = str1.begin();
//其实it就是一个指针变量，就这么简单
while (it != str1.end())
{
cout << *it << " ";//解引用迭代器 it，输出它所指向的字符，然后输出一个空格。
it++;
}
cout << endl;
//那么也有反向迭代器，即从反方向开始的
//叫做reverse_iterator
//rbegin() 返回的反向迭代器指向容器的最后一个元素（即正向迭代器 end() 的前一个位置）。
//rend() 返回的反向迭代器指向容器第一个元素的前一个位置（即正向迭代器 begin() 的前一个位置）。 //依旧是使用++
//rbegin()和rend()的返回值都是指针哦，所以我们可以直接用it这个指针变量接收
//也是使用++
string::reverse_iterator rit = str1.rbegin();
while (rit != str1.rend())
{
cout << *rit << " ";//解引用
rit++;
//反向迭代器的 ++ 操作是向字符串起始方向移动（与正向迭代器的 -- 效果相同），
//符合反向遍历的逻辑。
}
cout << endl;
//要注意，上面说的两种迭代器，都是可以对数据进行修改的
//eg：
string str2("good moring");
string::iterator it1 = str2.begin();
cout << "小写转为大写：";
while (it1 != str2.end())
{
*it1 -= 32;//修改元素，从小写转换为大写
cout << *it1 << " ";
++it1;
}
//修改了之后可就是修改了
cout << endl;
string::reverse_iterator rit1 = str2.rbegin();
cout << "大写转为小写：";
while (rit1 != str2.rend())
{
*rit1 += 32;//修改元素，从大写转为小写
cout << *rit1 << " ";
++rit1;
}
cout << endl;
//那么其实还有不可以修改的迭代器，也就是只能读不能修改
//是const_iterator和const_reverse_iterator
//用法和上面一样
//const_iterator
string str3("good noon");
string::const_iterator cit = str3.cbegin();
while (cit != str3.cend())
{
cout << *cit << " ";//解引用迭代器 it，输出它所指向的字符，然后输出一个空格。
cit++;
}
cout << endl;
//const_reverse_iterator
string::const_reverse_iterator crit = str3.crbegin();
while (crit != str3.crend())
{
cout << *crit << " ";//解引用迭代器 it，输出它所指向的字符，然后输出一个空格。
crit++;
}
cout << endl;
}
void teststringauto()
{
//C++11 里的auto就是让编译器 "自动推断变量类型"，不用我们手动写类型了，特别方便。
auto a = 10;//auto==int
//其实就是我们可以把auto当作是一个数据类型，
//然后就像平时创建数据类型变量一样去创建auto类型变量
//那么编译器会根据我们给变量的值自动识别个变量是什么类型的
//然后把auto自动替换为其所识别到的类型
//那么这也就是说明使用auto的时候，必须要初始化
//说白了就是像模版中typename type1
auto ch = 'a';//ayto==char
auto f = 10.10;//auto==float
//当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，
//因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto a1 = 10, b1 = 20, c1 = 30;
//auto不能直接用来声明数组
//auto arr[100] = { 0 };//这种写法是错的
//范围for
//对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。
//因此C++11中引入了基于范围的for循环。
//for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，
//第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。
//范围for可以作用到数组和容器对象上进行遍历
//范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。
//其实就是使用for，然后：前面放类型加变量
//：后面放要进行循环的数据
int arr[5] = { 1,2,3,4,5 };
for (auto i : arr)
{
cout << i << " ";
}
//如上面的例子
//其实i就相当于既是之前for循环的int i
//又相当于是arr[i]，编译器会自动判断arr到哪里结束
//也就是要进行几次循环，不需要我们再去手动指定
//那么将i的类型设置为auto的好处就是可以让编译器去自己分辨auto要是什么类型的
cout << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << " ";
}
cout << endl;
string str1("good afternoon");
for (auto ch : str1)
{
cout << ch << " ";
}
cout << endl;
for (int i = 0; i < str1.size(); i++)
{
cout << str1[i] << " ";
}
//真的是嘎嘎好使，嘎嘎好使
}
void teststringpush()
{
std::string str1("hello world");
str1.push_back(' ');//尾插数据进已经创建的字符串数组
str1.push_back('a');//尾插数据进已经创建的字符串数组
cout << str1 << endl;
//同样的，append也可以指定插入的字符串中字符个数
str1.append(" hello world", 3);
cout << str1 << endl;
//不过一般来说，我们都是用string中提供的+=运算符重载函数来尾插数据
string str2("xxxxxxx");
str2 += 'a';
cout << str2 << endl;
str2 += "bbbbbb";
cout << str2 << endl;
//还有就是+运算符重载函数：
string str3;//创建空字符串
str3 = str2 + " nihao";//用一个新的字符串接收两个字符串相加的结果
//上面的str2和“nihao”的位置也可以互换
cout << str3 << endl;
//assign就是将原字符串的内容用新的内容进行替换
//不重要，略
//insert，头插
string str4 = "kkkkk";
str4.insert(str4.begin(), 'm');//头插到第一个数据
cout << str4 << endl;
str4.insert(2, "aaa");//从下标为2的位置开始插入“aaa”
cout << str4 << endl;
//erase，除去字符串中从一个位置到另一个位置的数据
//其实就是将下标为前一个参数到下标为后面一个参数的数据都除去
string str5("abcdef");
str5.erase(1, 3);
cout << str5 << endl;
//replace，将字符串中某个位置的数据替换为我们指定的数据
//如果那个位置的空间小于我们要输入的字符串的大小
//它会自动扩容
string str6("hello win !");
str6.replace(5, 1, "%%");//将下标为5的位置，数据替换为“%%”，
//要注意，其实这中间的1就是指只针对5这个下标的位置
//而要是2就是指从下标5到5后面一个位置这两个位置
cout << str6 << endl;
str6.replace(9, 2, "%%");
cout << str6 << endl;
}
void teststringreserve()
{
std::string str1("hello world");
cout << str1.size() << endl;//11个字符
//string类中提供了capacity()函数去获取编译器为了
//这个字符串数组开辟来了多少空间
cout << str1.capacity() << endl;//开了15个空间
cout << str1 << endl;
//不过由于我们每次可能会对已经创建的字符串数组插入数据
//那就会让编译器不断扩容
//使得效率低下
//上面的push_back是只能尾插进一个字符
//下面的append是能够尾插进一个字符串
str1.append(" hello world");
cout << str1 << endl;
cout << str1.size() << endl;//25
cout << str1.capacity() << endl;//31
//所以C++就在string类中提供了reserve函数
//这个函数可以保留字符串数组中要有多少个空间
str1.reserve(28);
cout << "reserve(28):" << str1.capacity() << endl;//31
str1.reserve(40);
cout <<"reserve(40):" << str1.capacity() << endl;//47
str1.reserve(20);
cout << "reserve(20):" << str1.capacity() << endl;//47
//但是不同编译器对reserve使用后对空间的处理不同
//vs2026就是对于reserve的空间如果小于原本的字符串数组所占的空间的话，那么它是不会去改的
//而要是大于，那么它会屁颠屁颠的跑去改
//但是不会说就直接改成你所指定的空间了
//因为存在着内存对齐，所以它会大于等于我们所指定的空间
}
void teststringoperations()
{
string str1("hello win");
//c_str() 是 std::string 类的成员函数，
//主要用于将 C++ 风格的字符串（std::string）
//转换为 C 风格的字符串（以 结尾的字符数组）
const char* copystr1 = str1.c_str();
printf("%s",copystr1);
printf("
");
printf("%s", str1.c_str());
//find函数，用于查找字符串中某个指定值
//是从前往后去寻找
//find函数会返回那个指定值的下标
//但是只会返回遇到的第一个指定值的下标
string str2("hehllo whorldh");
size_t pos1 = str2.find('h');
cout <<"hehllo whorld的从前往后的第一个h的下标为：" << pos1 << endl;
//ring函数，是从后往前去寻找，其他的和find函数类似
size_t rpos = str2.rfind('h');
cout << "hehllo whorld的从后往前的第一个h的下标为：" << rpos << endl;
//find_first_of，一个被名字误导的函数
//实际上它是指从某个位置开始寻找去和我们输入的字符串，注意，是字符串
//有出现一个和我们输入的字符串中的任意一个元素相同的元素的话
//就返回那个元素的下标
size_t fpos = str2.find_first_of("low", 1);
cout << fpos << endl;
//那么find_last_of就是指从后往前找的，其他的和find_first_os英语
size_t lpos = str2.find_last_of("low", 1);
cout << lpos << endl;
//find_first_not_of的作用就是与find_first_of相反就完了
//find_last_not_of则是从后往前的
//substr一个还算还行的函数
//功能就是选取已有的字符串的某些连续数据，给一个新的string类变量
string str3;
str3 = str2.substr(0, 2);
cout << str3 << endl;
//那么我们不妨实现一下使用find函数去找空格，然后将空格替换为%
string str4("h e l l o");
size_t pos = str4.find(' ');
while (pos < str4.size())
{
//当pos的值大于等于字符串长度的时候，也就代表字符串中找不到空格了
//因为当find函数找不到要找的字符时，就会返回一个贼大的值
str4[pos] = '%';
pos = str4.find(' ', pos + 1);//从上次找到的空格的后面一个开始寻找
}
cout << str4 << endl;
//那么上面的方法有点低级了，下面来个更高级的
string str5("h e l l o w o r l d");
string str6;//用空间换时间
for (auto ch : str5)
{
if (ch == ' ')
{
ch = '%';
}
str6.push_back(ch);
}
cout << str6 << endl;
}
void testgetline()
{
//getline，一个嘎嘎好使的函数
//需要注意，它并不是string类的成员函数，是在std里面的
//那么它的作用就是负责获取用户输入的字符串
//在C语言中，scanf碰到“ ”就会停下
//而在C++中，cin不会“ ”吸收进去
//所以，就有了getline这个函数
//这个函数一共三个参数
//第一个参数我们直接传cin就行
//第二个参数传被输入数据的string变量
//第三个参数就有讲究了，它是指编译器获取的数据要到什么字符停下
//一般默认是换行符，不过我们也可以指定
string str1;
//要先创建变量，再去用getline
std::getline(cin, str1, ' ');//碰到空格就停下
cout << str1 << endl;
//string str2;
////要先创建变量，再去用getline
//std::getline(cin, str2);//碰到换行就停下
//cout << str2 << endl;
}
int main()
{
teststringconstruct();
teststringiterator();
teststringauto();
teststringpush();
teststringreserve;
teststringoperations();
testgetline();
return 0;
} 希望大家能有所收获。
结语：以 string 为钥，解锁 STL 的高效世界
当你看完这篇博客，敲完最后一行 string 的示例代码，看着屏幕上正确输出的字符串时，其实你已经迈出了 STL 学习中最坚实的一步。回想一下，从 C 语言里手动管理 char 数组的小心翼翼，到 C++ 中用 string 轻松实现拼接、查找、修改，这种从 “繁琐” 到 “便捷” 的跨越，正是 STL 带给我们的核心价值 —— 把底层复杂的逻辑封装成易用的接口，让我们能更专注于业务逻辑，而非重复造轮子。
在前面的内容里，我们从 string 的基本定义出发，一点点拆解它的核心特性：自动动态内存管理让我们告别了内存泄漏和缓冲区溢出的烦恼；丰富的构造函数满足了不同场景下的初始化需求，无论是空字符串、C 风格字符串拷贝，还是重复字符填充、迭代器范围构造，都能一键实现；元素访问的多种方式（[]、at ()、front ()、back ()）兼顾了效率与安全性，迭代器和范围 for 循环则让遍历变得灵活又直观。而修改操作中的 push_back、append、insert、erase、replace，更是把字符串的增删改查做到了极致灵活，再加上查找、比较、子串截取这些实用功能，string 几乎能应对所有文本处理场景。
我们还特意深入了容易被忽略的内存优化点 ——reserve 预分配容量，它能帮我们避免频繁扩容带来的性能损耗；shrink_to_fit 释放多余内存，让资源利用更高效。这些细节看似微小，却能在大规模字符串操作中带来质的提升，也让我们明白，STL 的强大不仅在于 “能用”，更在于 “能用得好”。而与 C 风格字符串的交互（c_str ()、data ()）、字符串与数值的转换（stoi、to_string）、STL 算法的兼容（reverse、sort），则让 string 的适配性变得极强，无论是对接 C 库函数，还是处理数据转换，都游刃有余。
我知道，大家在刚接触迭代器、移动构造、内存容量这些概念时，可能会觉得有些抽象。比如迭代器的 begin () 和 end () 边界、移动构造后原字符串的失效、reserve 预分配时的内存对齐规则，这些知识点初看容易混淆。但就像我们在示例代码中展示的那样，只要多动手实践，把每个函数都亲自测试一遍，把每个坑都踩一遍（比如迭代器失效后继续访问、getline 被 cin 残留换行符影响），就能慢慢理解其中的逻辑。编程从来不是 “看会” 的，而是 “练会” 的 —— 你在 teststringiterator 函数中手动实现正向、反向迭代器遍历，在 teststringoperations 中用 find 和 replace 替换空格，在 teststringreserve 中观察容量变化的过程，其实都是在把书本上的知识点内化成自己的能力。
string 作为 STL 容器家族的 “入门款”，不仅是一个字符串处理工具，更是我们理解 STL 设计思想的钥匙。它的封装性告诉我们，好的代码应该隐藏复杂实现，暴露简洁接口；它的兼容性体现了 STL “通用” 的设计理念，让不同组件可以无缝协作；它的性能优化则提醒我们，优秀的工具不仅要能用，还要高效。这些思想，在后续我们学习 vector、list、map 等其他容器时，都会反复出现。可以说，把 string 学透了，后续的 STL 学习就会事半功倍。
回想我们的学习路径：从 C++ 入门基础搭建语法框架，到类和对象理解面向对象思想，再到模板初阶接触泛型编程，最后落脚到 STL 的第一个容器 string。这条路径是循序渐进、层层递进的 —— 类和对象的知识帮我们理解了 string 为什么是一个 “类”，为什么能有成员函数和运算符重载；模板的知识让我们明白 string 其实是 basic_string
接下来，STL 的学习之路还很长。我们会遇到更复杂的容器（比如 vector 的动态数组、list 的双向链表、map 的键值对存储），更强大的算法（比如排序、查找、排序、变换），更灵活的适配器（比如 stack、queue）。但请相信，有了 string 的学习基础，你已经具备了探索这些内容的能力。后续学习中，你可以带着 “对比” 的思维 —— 比如对比 vector 和 string 的内存管理方式，对比 list 和 string 的插入删除效率，对比不同容器对迭代器的支持程度，这样就能更快地找到它们的共性与差异，形成自己的知识网络。
最后，我想对大家说：编程学习是一个 “循序渐进、厚积薄发” 的过程。可能你现在觉得 string 的某些接口还记不牢，某些底层原理还理解不透，但这都没关系。重要的是保持好奇心和动手能力，遇到不懂的问题就去查文档、写测试代码，遇到实用的技巧就记下来、多复用。就像我们用 string 处理字符串一样，学习本身也是一个 “积累 - 修改 - 优化” 的过程 —— 积累知识点，修改认知误区，优化学习方法。
STL 是 C++ 的精华所在，而 string 只是这趟精彩旅程的起点。它让我们看到了 C++ 的强大与优雅，也让我们感受到了高效编程的乐趣。未来，当你用 vector 管理动态数组，用 map 实现快速查找，用 STL 算法简化复杂逻辑时，你会感谢现在认真学习 string 的自己。
请保持这份对编程的热爱与执着，继续深耕下去。相信不久的将来，你不仅能熟练运用 STL 的各种工具，还能理解其底层实现的精髓，甚至能根据需求自定义容器和算法。编程的世界没有捷径，但每一步脚踏实地的努力，都终将化为你成长路上的坚实阶梯。
愿你以 string 为钥，解锁 STL 的广阔天地，在 C++ 的学习之路上越走越远，写出更优雅、更高效、更健壮的代码！加油，每一个为梦想全力以赴的学习者！
