1. C++ STL string类深度解析
C++标准模板库(STL)中的string类是处理字符串的核心组件，相比传统的C风格字符串(char*)，它提供了更安全、更便捷的字符串操作方式。作为C++程序员，深入理解string类的实现原理和正确使用方法是基本功。
1.1 string类的基本特性
string类本质上是一个封装了字符序列的容器，具有以下核心特点：
- 自动内存管理：无需手动分配和释放内存
- 丰富的成员函数：提供各种字符串操作接口
- 动态大小：可根据需要自动调整存储空间
- 安全性：内置边界检查，减少缓冲区溢出风险
注意：虽然string比C风格字符串安全，但不当使用仍可能导致性能问题或未定义行为
1.2 string的常用构造方式
string类提供了多种构造函数，满足不同场景下的初始化需求：
cpp复制// 空字符串构造
string s1;
// 从C风格字符串构造
const char* cstr = "Hello";
string s2(cstr);
// 填充构造：5个'A'字符
string s3(5, 'A');
// 拷贝构造
string s4(s2);
// 移动构造(C++11)
string s5(std::move(s2));
在实际工程中，最常用的是从C字符串构造和拷贝构造。移动构造在C++11后引入，对于临时string对象可以避免不必要的拷贝开销。
2. string类的容量管理
string作为动态字符串容器，其内存管理策略直接影响性能和内存使用效率。
2.1 容量相关接口
cpp复制string s = "Hello";
cout << s.size(); // 5，当前字符数
cout << s.length(); // 5，与size()相同
cout << s.capacity(); // 可能为15，实际分配空间
cout << s.empty(); // 0，非空
size()和length()都返回当前字符串长度，但size()是STL容器统一接口，推荐使用。capacity()返回实际分配的内存大小，通常大于等于size()。
2.2 内存调整策略
string采用动态内存分配策略，当当前空间不足时，会自动扩容。常见的扩容策略包括：
- 固定增量：每次增加固定大小(如16字节)
- 倍数增长：每次容量翻倍(常见实现方式)
- 按需精确分配：但频繁分配影响性能
cpp复制string s;
for(int i=0; i<100; ++i) {
s += 'a';
cout << s.capacity() << endl; // 观察扩容模式
}
通过reserve()可以预先分配足够空间，避免频繁扩容：
cpp复制string s;
s.reserve(100); // 预先分配100字节
// 后续添加操作不会触发扩容，直到超过100字符
2.3 resize()与reserve()的区别
这两个函数经常被混淆，但它们有本质区别：
| 函数 | 作用 | 是否影响内容 | 是否影响capacity |
|---|---|---|---|
| reserve | 预留内存空间 | 不影响现有内容 | 可能增大 |
| resize | 改变字符串长度 | 会修改内容 | 可能增大 |
cpp复制string s = "Hello";
s.reserve(50); // capacity>=50，但size仍为5
s.resize(10); // size=10，多出的5个位置填充'\0'
s.resize(15, 'x'); // size=15，新增5个'x'
3. string的元素访问与遍历
string提供了多种访问和遍历字符的方式，各有适用场景。
3.1 下标访问
最直接的访问方式是通过operator[]：
cpp复制string s = "Hello";
char c1 = s[1]; // 'e'
char c2 = s.at(1); // 'e'
// 区别在于边界检查
s[100]; // 未定义行为
s.at(100); // 抛出std::out_of_range异常
在已知索引安全的情况下，operator[]更高效；不确定索引范围时，使用at()更安全。
3.2 迭代器遍历
STL风格的迭代器访问：
cpp复制string s = "Hello";
for(auto it = s.begin(); it != s.end(); ++it) {
cout << *it;
}
// 反向迭代
for(auto rit = s.rbegin(); rit != s.rend(); ++rit) {
cout << *rit; // 输出olleH
}
迭代器方式在算法中很常见，也便于与其他STL算法配合使用。
3.3 范围for循环(C++11)
更简洁的遍历方式：
cpp复制string s = "Hello";
for(char c : s) {
cout << c;
}
// 若要修改字符，使用引用
for(char& c : s) {
c = toupper(c);
}
范围for是语法糖，底层仍转换为迭代器实现，但代码更简洁。
4. string的修改操作
string提供了丰富的字符串修改接口，理解它们的区别对写出高效代码很重要。
4.1 尾部添加字符
三种常见方式：
cpp复制string s = "Hello";
s.push_back('!'); // 添加单个字符
s.append(" world"); // 添加字符串
s += " C++"; // 最常用的追加方式
性能对比：
- +=操作符最常用，可追加字符或字符串
- push_back()只适合单个字符
- append()有多种重载，功能最灵活
4.2 字符串连接
连接多个字符串时，避免频繁创建临时对象：
cpp复制// 低效方式：创建多个临时string
string s = "a" + "b" + "c";
// 高效方式
string s;
s.reserve(3); // 预分配空间
s += "a";
s += "b";
s += "c";
对于大量字符串连接，使用ostringstream可能更高效：
cpp复制#include <sstream>
ostringstream oss;
oss << "a" << "b" << "c";
string s = oss.str();
4.3 查找与子串
string提供了强大的查找功能：
cpp复制string s = "Hello world";
size_t pos = s.find("world"); // 6
if(pos != string::npos) {
// 找到子串
}
// 反向查找
pos = s.rfind('o'); // 7
// 提取子串
string sub = s.substr(6, 5); // "world"
查找算法的时间复杂度通常是O(n)，频繁查找应考虑更高效的数据结构如哈希表。
5. string的高级用法与性能优化
5.1 string_view(C++17)
string_view是轻量级的字符串视图，避免不必要的拷贝：
cpp复制void process(string_view sv) {
// 只读访问，不拷贝数据
}
string s = "Hello";
process(s); // 不拷贝
process("World"); // 不创建临时string
5.2 短字符串优化(SSO)
许多实现采用SSO技术，小字符串直接存储在对象内部，避免堆分配：
cpp复制string s1 = "Short"; // 可能存储在栈上
string s2 = "A very long string that will require heap allocation";
了解SSO有助于写出更高效的代码，特别是在处理大量小字符串时。
5.3 自定义分配器
对于特殊场景，可以自定义内存分配策略：
cpp复制template<typename T>
class MyAllocator {
// 自定义分配逻辑
};
basic_string<char, char_traits<char>, MyAllocator<char>> custom_str;
这在嵌入式系统或需要特殊内存管理的场景中很有用。
6. 常见问题与解决方案
6.1 字符串与数字转换
cpp复制// string转数字
string s = "123";
int i = stoi(s);
double d = stod("3.14");
// 数字转string
string s1 = to_string(42);
string s2 = to_string(3.14159);
注意转换失败会抛出异常，生产代码应该捕获：
cpp复制try {
int i = stoi("abc");
} catch(const std::invalid_argument& e) {
cerr << "Invalid argument: " << e.what();
}
6.2 字符串分割
标准库没有直接提供分割函数，可以结合stringstream实现：
cpp复制vector<string> split(const string& s, char delim) {
vector<string> tokens;
string token;
istringstream iss(s);
while(getline(iss, token, delim)) {
tokens.push_back(token);
}
return tokens;
}
对于高性能需求，可以考虑使用strtok(但要注意线程安全问题)或自己实现分割算法。
6.3 性能陷阱
- 不必要的拷贝：
cpp复制void process(string s); // 按值传递导致拷贝
// 改进：若不修改且C++17可用string_view
// 否则const string&
- 频繁扩容：
cpp复制string s;
for(int i=0; i<100000; ++i) {
s += "data"; // 可能多次扩容
}
// 改进：预先reserve足够空间
- 误用c_str()：
cpp复制string s = "Hello";
const char* p = s.c_str();
s += " world"; // p可能失效
// 使用p导致未定义行为
c_str()返回的指针在string修改后可能失效，需要特别注意。
在实际项目中，合理使用string能极大提高开发效率和代码安全性。根据具体场景选择合适的方法，并注意性能优化点，可以写出既高效又健壮的字符串处理代码。