引言
在c++中，string类的引用极大地简化了字符串的操作和管理，相比 C 风格字符串（char*或cahr[]），`std::string` 提供了更高效和更安全的字符串操作。接下来让我们一起来深入学习string类吧！
1.string 的构造与初始化
- 介绍 string类 的几种常见的构造方式：
- 默认构造：创建空字符串。
- 通过 C 风格字符串初始化：`std::string s("Hello");`
- 复制构造：从另一个字符串构造。
- 指定字符和长度构造：`std::string s(5, 'A');
using namespace std;
string s1; // 空字符串
string s2("Hello"); // 通过 C 风格字符串初始化
string s3(s2); // 复制构造
string s4(5, 'A'); // 重复字符构造
// "AAAAA"`2.string的迭代器支持
在 C++ 中，迭代器（Iterator）是一种抽象概念，用来遍历容器中的元素。std::string 作为标准库中的容器类，支持迭代器，使得我们可以像操作其他 STL 容器（如 vector、list 等）一样，使用迭代器来遍历和操作字符串。
（1）什么是迭代器？
迭代器可以理解为一个指针，它指向容器中的某个元素，通过迭代器我们可以逐个访问容器中的元素。不同于普通指针，迭代器具备更强的泛化性，能适用于不同的容器。对 std::string 来说，迭代器可以用于遍历字符串中的每个字符。
（2）std::string 的迭代器类型
string 提供了几种常见的迭代器类型：
string::iterator：正向迭代器，用于从字符串的起始位置向末尾遍历。
string::const_iterator：常量正向迭代器，和 iterator 类似，但它不允许修改迭代器指向的元素。
string::reverse_iterator：反向迭代器，用于从字符串末尾向前遍历。string::const_reverse_iterator：常量反向迭代器，反向遍历并且不允许修改元素。
（3）常用的迭代器操作
begin()：返回指向字符串第一个字符的正向迭代器。
end()：返回指向字符串末尾之后位置的正向迭代器（即超尾迭代器，不指向实际元素）。rbegin()：返回指向字符串最后一个字符的反向迭代器。
rend()：返回指向字符串第一个字符之前位置的反向迭代器。
cbegin() 和 cend()：常量正向迭代器，保证字符串内容不可修改。
crbegin() 和 crend()：常量反向迭代器。
#include <iostream>
#include <string>
using namespace std;
int main() {
string str1 = "Hello World";
// 使用正向迭代器遍历字符串
string::iterator it1 = str1.begin();
while ( it1 != str1.end() )
{
cout << *it1 << " "; // 输出每个字符
++it1;
}
cout << endl;
// 通过正向迭代器修改字符串
string::iterator it2 = str1.begin();
while ( it2 != str1.end())
{
(*it2)++;//所有字符替换为下一个
cout << *it2 << " ";// 输出修改后的字符串
++it2;
}
cout << endl;
// 使用常量正向迭代器遍历字符串
const string str2(str1);
string::const_iterator it3 = str2.cbegin();
while ( it3 != str2.cend())
{
//*(it3)++;
cout << *it3 << " "; // 输出每个字符，但不能修改
++it3;
}
cout << endl;
// 使用反向迭代器遍历字符串
string::reverse_iterator rit = str1.rbegin();
while ( rit != str1.rend())
{
cout << *rit << " "; // 反向输出字符串
++rit;
}
cout << endl;
return 0;
}
3.常用成员函数
3.1.获取字符串长度：
size()和 length()作用相同，都用于返回字符串的长度，返回类型都是size_t。
#include <iostream>
using namespace std;
int main()
{
string s = "Hello";
cout << s.size() << endl;//5
cout << s.length() << endl;//5
return 0;
} 5两者没有功能上的区别，提供两个概念主要是为了与开发者的习惯保持一致，size_t()更符合容器类的术语，length()更符合处理字符串的自然语言概念
3.2. 访问和修改字符串：
std::string::at() 是 C++ 标准库中std::string类的成员函数，用于安全地访问字符串中的指定字符。它会根据提供的索引返回该索引位置的字符，同时会进行越界检查，如果索引超出了字符串的范围，则会抛出 `std::out_of_range` 异常。
相比直接使用下标运算符 `[]`，`at()` 的优势在于它提供了边界检查，从而避免访问无效位置导致未定义行为。
3.3.1函数原型
char& at(size_t pos);
const char& at(size_t pos) const;- pos：要访问的字符的索引，size_t类型。
- 返回值：pos位置处的字符。如果at()被用于常量字符串，它返回const char&，否则返回 char&。
3.2.2与 `[]` 运算符的区别
- at()：会检查索引是否超出范围，如果超出，抛出 std::out_of_range异常，程序可以捕获该异常。用于安全地访问和修改字符串中的字符，推荐在需要安全性和健壮性时使用。
- []：不进行越界检查，如果访问超出范围的索引，行为是未定义的，可能导致程序崩溃或错误。在确定索引合法的情况下使用。
3.2.3示例代码
#include <iostream>
using namespace std;
int main() {
string str = "Hello, World!";
// 使用 at() 访问字符串中的字符
cout << "字符串的第一个字符：" << str.at(1) << endl; // 输出 'e'
// 修改字符串中的字符
str.at(7) = 'C'; // 将 'W' 修改为 'C'
cout << "修改后的字符串：" << str << endl;
try
{
// 尝试访问超出范围的字符，抛出异常
char ch = str.at(20);
cout << ch << endl;
}
catch (const out_of_range& e) {
// 捕获 out_of_range 异常
cout << "Out of range error：" << e.what() << endl;
}
return 0;
}
3.3. 拼接字符串：
在 C++ 中，拼接字符串的方式有很多，其中比较常用的方式包括使用 `+` 运算符（通过 `operator+` 重载实现）以及 `append()` 函数。虽然它们的作用都是拼接字符串，但它们有不同的使用场景和性能特点。
3.3.1使用 + 运算符（operator+）
+ 运算符是 C++ 中常用的拼接字符串的方法。它通过重载 `operator+` 来实现两个字符串的拼接操作。
int main()
{
string str1 = "Hello";
string str2 = "World";
// 使用 + 运算符拼接字符串
string result = str1 + ", " + str2 + "!";
cout << "Result: " << result << endl; // 输出 "Hello, World!"
return 0;
}
3.3.2使用append()方法
append()是 std::string 类的成员函数，用于将另一个字符串或字符拼接到当前字符串的末尾。相比于 + 运算符，append() 更加灵活，允许指定拼接的范围，甚至拼接部分字符串。
#include <iostream>
using namespace std;
int main()
{
string str1 = "Hello";
string str2 = "World";
// 使用 append() 拼接字符串
str1.append(", ").append(str2).append("!");//从str1的“,”开始拼接到str2的“！”
cout << "Result: " << str1 << endl; // 输出 "Hello, World!"
return 0;
} 
3.3.3+ 和 append() 的对比
1.可读性：
- + 运算符更加直观，拼接字符串时看起来像数学加法，代码简洁、易读，尤其是在拼接多个字符串时。
- append() 在一些场景下也很方便，尤其是需要逐步对同一个字符串进行修改时。
2 .性能：
- + 运算符会创建临时字符串对象。在连续使用 + 运算符时，C++ 可能会创建多个临时对象，特别是当涉及多个拼接操作时，临时对象会占用额外的内存，影响性能。
string result = str1 + str2 + str3; // 可能生成多个临时对象- append()则直接修改原字符串对象，不会生成临时对象，因此在多次拼接操作时性能更优。例如，如果你需要不断往同一个字符串中追加内容，`append()` 会比 `+` 更高效。
3. 灵活性
- + 运算符简单直观，但只支持完整字符串或字符的拼接，不能直接拼接部分字符串。
- append() 则可以指定拼接字符串的子串或部分字符，这在需要精细控制拼接内容时非常有用。
示例：拼接部分字符串
string str1 = "Hello";
string str2 = "World!!!";
// 拼接 str2 的前 5 个字符
str1.append(str2, 0, 5); // 拼接 "World"
cout << str1 << endl; // 输出 "HelloWorld"3.3.4append() 的其他用法
1. 拼接字符串：
str1.append(str2); // 将 str2 拼接到 str1 后面
2. 拼接子串：
str1.append(str2, pos, len); // 将 str2 中从位置 pos 开始的 len 个字符拼接到 str1
3. 拼接字符数组：
str1.append("World", 5); // 将 "World" 的前 5 个字符拼接到 str1
4. 拼接单个字符：
str1.append(1, '!'); // 将字符 '!' 拼接到 str1 后面
3.3.5总结
- + 运算符：简单易用，适合少量字符串的拼接，代码更简洁，但在大量拼接操作中性能可能不如 append()。
- append()：性能更优，灵活性更强，尤其适用于频繁拼接的场景，可指定拼接部分字符串或字符。
在选择使用 + 还是 append() 时，可以根据代码的可读性需求和性能要求做出权衡。如果拼接操作复杂或频繁，append()是更好的选择。
3.4.查找、替换与截取：
可以通过结合find()、substr()以及replace()函数，实现字符串的查找、截取和替换。
3.4.1查找子串
如前面所述，使用`find()`函数可以查找子串的位置。
#include <iostream>
using namespace std;
int main() {
string str = "Hello, World!";
string toFind1 = "Worlda";
string toFind2 = "World";
size_t found1 = str.find(toFind1);
size_t found2 = str.find(toFind2);
if (found1 != string::npos) {
cout << "Found at position: " << found1 << endl;
}
else {
cout << "Not found" << endl;
}
if (found2 != string::npos) {
cout << "Found at position: " << found2 << endl;
}
else {
cout << "Not found" << endl;
}
return 0;
}
3.4.2截取字符串
使用`substr()`可以从查找到的位置开始截取指定长度的子串。
string substr (size_t pos = 0, size_t len = npos) const;#include <iostream>
using namespace std;
int main() {
string str = "Hello, World!";
size_t start = 7; // 从第7个字符开始
size_t length = 5; // 截取5个字符
string sub = str.substr(start, length);
cout << "截取的字符串： " << sub << endl;
return 0;
}
3.4 3.替换字符串
使用replace()函数可以替换子串。replace()的使用方法是：
string.replace(position, length, new_string);其中position是替换的起始位置，length是要替换的字符长度，new_string是用于替换的字符串。
#include <iostream>
using namespace std;
int main() {
string str = "Hello, World!";
string toReplace = "World";
string replacement = "C++";
size_t found = str.find(toReplace);
if (found != string::npos)
{
// 在位置 found 替换长度为 toReplace.length() 的子串
str.replace(found, toReplace.length(), replacement);
}
cout << "替换后的字符串：" << str << endl;
return 0;
}
3.5其他成员函数
string的成员函数太多，我们在此就不详细说明了，其他还有很多重要的成员函数，我们简单介绍一下功能，其它还需要小伙伴们自己深入学习。
3.5.1string 类对象的容量操作
3.5.2string类对象的访问及遍历操作
3.5.3string类对象的修改操作
3.5.4string类非成员函数
更多string的成员函数：string - C++ Reference (cplusplus.com)
4.auto和范围for
1.auto
#include <iostream>
using namespace std;
int func1()
{
return 10;
}
// 不能做参数
//void func2(auto a)
//{}
// 可以做返回值，但是建议谨慎使用
auto func3()
{
return 3;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = func1();
// 编译报错，必须初始化
//auto e;
cout << typeid(b).name() << endl;int
cout << typeid(c).name() << endl;char
cout << typeid(d).name() << endl;int
int x = 10;
auto y = &x;
auto* z = &x;
auto& m = x;
cout << typeid(x).name() << endl;int
cout << typeid(y).name() << endl;int*
cout << typeid(z).name() << endl;int*
cout << typeid(m).name() << endl;int
auto aa = 1, bb = 2;
// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
//auto cc = 3, dd = 4.0;
// 编译报错：error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型
//auto array[] = { 4, 5, 6 };
string s1("hellow world");
//string::reverse_iterator rit = s1.begin();
auto rit = s1.begin();
while (rit != s1.end())
{
cout << *rit << " ";
++rit;
}
cout << endl;
return 0;
}
2.范围for
范围for是C++11引入的一种简化的遍历容器元素的方式，它极大地简化了传统的基于索引或迭代器的循环结构，是代码更加简洁明了。
基本语法：
for ( declaration : range_expression )
{
// 循环体
}int main()
{
//数组三种遍历方式
//下标[]，迭代，返回for
//自动取容器的数据赋值给左边的值
//自动++，自动判断结束
//原理：范围函数底层是迭代器
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
//修改
for (auto& ch : s1)
{
ch++;
}
cout << endl;
//修改后的字符串
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
int a[] = { 1,2,3,4,5,6,7 };
for (auto i : a)
{
cout << i << " ";
}
return 0;
}
5. string内存管理与性能
C++ 提供了标准库中的 `std::string` 类来简化字符串操作，但其内存管理背后有许多细节值得注意。以下是内存管理与性能优化相关的几个关键点：
1. std::string内存管理机制
（1）动态内存分配：std::string是基于动态内存分配的。它会在需要时自动扩展容量。这意味着当字符串增长时，可能会重新分配内存并复制已有的内容到新位置。这种操作代价较高，特别是在频繁追加内容时。
（2）内存释放：当 string 对象超出作用域或被销毁时，其占用的内存会自动被释放。这是通过 C++的自动内存管理机制（RAII，Resource Acquisition Is Initialization）实现的。
void someFunction() {
std::string localString = "Local string";
// 做一些其他操作
} // localString 在这里被销毁，其内存被释放。（3）小字符串优化（SSO, Small String Optimization）：为了避免频繁的动态分配开销，许多现代的 C++ 实现采用了小字符串优化机制。当字符串很短（通常少于 15-23 个字符，取决于实现）时，std::string 会直接在栈上存储数据，而不需要堆内存分配。
（4）容量管理：`std::string` 通常会分配比实际需要的更多内存，以避免频繁的重新分配。开发者可以通过 `reserve()` 函数预分配足够的内存空间，避免多次分配。
2. 性能优化技巧
（1）预分配内存：如果你知道字符串的大致大小，可以使用 `reserve()` 函数预分配内存，减少多次动态内存分配。例如，在大量 `push_back` 操作前调用 `reserve()`。
（2）避免不必要的复制：尽量避免在不必要的情况下拷贝 `std::string` 对象。可以通过使用引用（如 `const std::string&`）或 C++11 之后的右值引用来减少复制的开销。
void process(const std::string& str); // 避免拷贝
void process(std::string&& str); // 接收右值引用，支持移动语义（3）使用 `std::move` 优化：C++11 引入了移动语义，可以通过 `std::move()` 转移字符串的所有权，而不再拷贝数据。对于需要返回大字符串的函数，移动语义可以显著提高性能。
std::string create_large_string() {
std::string str = "large_string_data";
return std::move(str); // 避免拷贝
}（4）拼接字符串时注意效率：在拼接大量字符串时，直接使用 `+` 可能导致多次内存分配和拷贝。为了提高效率，可以考虑使用 `std::ostringstream` 或 `std::string::append()` 来减少不必要的开销。
std::ostringstream oss;
oss << "Hello" << " " << "World!";
std::string result = oss.str();3. 常见的性能陷阱
（1）频繁的小字符串拼接：频繁的小字符串拼接会导致大量的内存分配和释放操作。可以通过 `reserve()` 或使用合适的数据结构（如 `std::ostringstream`）来减少开销。
（2）返回大字符串：如果一个函数返回一个大字符串对象，而没有使用移动语义（C++11 之前），会导致不必要的拷贝。C++11 之后，编译器会优化返回值，但显式使用 `std::move` 更好地表达意图。
（3）过度使用std::string的临时对象**：在某些场景下，频繁生成临时的 `std::string` 对象会导致性能下降。可以通过优化临时对象的使用或通过 `std::string_view` 来避免不必要的临时对象生成。
总结
C++ 的 `std::string` 提供了许多便捷的功能，但在需要处理大量数据或高性能场景下，注意其内存管理机制至关重要。通过合理使用预分配、避免不必要的拷贝、利用移动语义等技术，开发者可以大幅度提高字符串操作的效率。
