C++从入门到实战（十六）String（中）String的常用接口（构造接口，析构接口，迭代器，遍历修改，容量管理与数据访问）

前言

• 在上一篇博客中，我们深入探讨了 STL 与 String 的内在联系，解析了 string 类的设计初衷以及它在 C++ 编程中的重要价值。
• 通过剖析 string 类在内存管理、字符操作和 STL 容器适配等方面的独特优势，我们理解了它作为 C++ 标准字符串处理工具的核心地位。
• 本篇博客将进入 string 的实战环节，重点解析 string 类的常用接口

我的个人主页，欢迎来阅读我的其他文章
https://blog.csdn.net/2402_83322742?spm=1011.2415.3001.5343
我的C++知识文章专栏
欢迎来阅读指出不足
https://blog.csdn.net/2402_83322742/category_12880513.html?spm=1001.2014.3001.5482

C++string的官方讲解网站

https://cplusplus.com/reference/string/string/?kw=string

一、std::string

typedef basic_string<char> string;

std::string 是 C++ 标准库中用于处理字符串的类，它让我们可以像操作普通变量一样方便地处理文本数据。

• 简单来说，string 就是 C++ 为程序员提供的「字符串神器」，不用再手动管理内存，也不用操心字符串长度，各种常用操作都已经帮你写好了。

• string的接口有很多，我们先来看一看他的接口有哪些，后面会挨个详细讲

二、string的构造接口

• string 类提供了多种构造函数，让你可以用不同的方式创建字符串对象。下面是最常用的几种构造方式。

1. 默认构造函数：创建空字符串

string();

作用：创建一个空的字符串对象，不包含任何字符。
例子：

string s;  // 创建空字符串
cout << s << endl;  // 输出空行

2. 拷贝构造函数：复制已有字符串

string (const string& str);

作用：用一个已有的 string 对象创建新的字符串，内容完全相同。
例子：

string original = "hello";
string copy(original);  // 拷贝构造
cout << copy << endl;  // 输出: hello

3. 从已有字符串截取部分

string (const string& str, size_t pos, size_t len = npos);

作用：从 str 的 pos 位置开始，截取 len 个字符作为新字符串。
关键参数：

• pos：起始位置（从0开始）。
• len = npos：npos 是一个特殊值，表示「直到字符串末尾」。

例子：

string original = "hello world";
string substr1(original, 6);  // 从位置6开始到末尾，输出: world
string substr2(original, 0, 5);  // 从位置0开始取5个字符，输出: hello

4. 用C风格字符串构造

string (const char* s);

作用：把 C 风格的字符串（以 '\0' 结尾的字符数组）转换为 string 对象。
例子：

const char* c_str = "hello";
string s(c_str);  // 用C字符串构造
cout << s << endl;  // 输出: hello

5. 用C风格字符串的前n个字符构造

string (const char* s, size_t n);

作用：取 C 风格字符串的前 n 个字符（不要求以 '\0' 结尾）。
例子：

const char* c_str = "abcdef";
string s(c_str, 3);  // 取前3个字符
cout << s << endl;  // 输出: abc

6. 用重复字符构造

string (size_t n, char c);

作用：创建包含 n 个重复字符 c 的字符串。
例子：

string s(5, 'a');  // 创建5个'a'的字符串
cout << s << endl;  // 输出: aaaaa

7. 用迭代器构造（了解即可）

template <class InputIterator>  
string (InputIterator first, InputIterator last);

作用：用迭代器范围内的字符构造字符串，常用于从其他容器（如 vector<char>）创建字符串。

三、string的赋值与析构

1. 析构函数 ~string()

每个 string 对象在生命周期结束时，会自动调用析构函数，释放占用的内存。你不需要手动操作，C++ 会帮你搞定。

例子：

{
    string s = "hello";  // 创建对象
}  // 离开作用域，s 自动销毁，内存自动释放

2. 赋值运算符 operator=

2.1 用另一个 string 对象赋值（常用）

string& operator= (const string& str);

作用：把一个 string 对象的内容复制到另一个 string 对象。
例子：

string s1 = "hello";
string s2 = "world";
s1 = s2;  // s1 现在是 "world"
cout << s1 << endl;  // 输出: world

2.2 用 C 风格字符串赋值（了解即可）

string& operator= (const char* s);

作用：把 C 风格字符串（如 "hello"）赋值给 string 对象。
例子：

string s;
s = "hello";  // 等价于 string s = "hello";
cout << s << endl;  // 输出: hello

2.3 用单个字符赋值

string& operator= (char c);

作用：让 string 对象只包含一个字符。
例子：

string s;
s = 'A';  // s 现在是 "A"
cout << s << endl;  // 输出: A

四、string::iterator迭代器（重点掌握）

1. 为什么需要迭代器？

迭代器是C++中访问容器（如string、vector）元素的通用方式，它让我们可以：

• 统一语法：用相同的方式遍历不同类型的容器。
• 支持算法：STL算法（如find、sort）依赖迭代器工作。
• 隐藏底层细节：无需关心容器内部如何存储数据。

类比：迭代器就像“容器的指针”，让你可以逐个访问元素。

2. 迭代器的基本使用（像指针一样操作）

定义迭代器：

string::iterator it;  // 正向迭代器（从前往后）
string::reverse_iterator rit;  // 反向迭代器（从后往前）

遍历字符串：

#include <iostream>
#include <string>
using namespace std;
int main()
{
	string s = "hello";

// 正向遍历（从前往后）
for (string::iterator it = s.begin(); it != s.end(); ++it) {
    cout << *it;  // *it 是当前字符，输出: hello
}
 cout << endl;
// 反向遍历（从后往前）
for (string::reverse_iterator rit = s.rbegin(); rit != s.rend(); ++rit) {
    cout << *rit;  // 输出: olleh
}
	return 0;
}

简化写法（用auto自动推导类型）：

for (auto it = s.begin(); it != s.end(); ++it) {
    cout << *it;  // 效果同上
}

3. 迭代器的4种类型

4. 迭代器的边界

• s.begin()：指向第一个字符（如 'h' in "hello"）。
• s.end()：指向最后一个字符的下一个位置（即字符串结束标记 '\0' 的位置），不包含该字符。
• s.rbegin()：指向最后一个字符（如 'o' in "hello"）。
• s.rend()：指向第一个字符的前一个位置（反向的结束标记）。

为什么不访问'\0'？
因为迭代器设计为只访问有效字符，而 '\0' 是C风格字符串的结束标记，string 类用 size() 明确记录长度，不需要 '\0'。

5. 修改字符串（通过迭代器写操作）

string s = "hello";
for (auto it = s.begin(); it != s.end(); ++it) {
    *it = toupper(*it);  // 转为大写
}
cout << s;  // 输出: HELLO

6. 迭代器与STL算法结合

例子1：查找字符

string s = "hello";
auto it = find(s.begin(), s.end(), 'l');
if (it != s.end()) {
    cout << "找到 'l' 在位置: " << it - s.begin() << endl;  // 输出: 2
}

例子2：反转字符串

string s = "hello";
reverse(s.begin(), s.end());  // 直接反转
cout << s;  // 输出: olleh

7. 安全注意事项

• 迭代器失效：修改字符串可能导致迭代器失效，例如：

  for (auto it = s.begin(); it != s.end(); ) {
      if (*it == 'l') {
          s.erase(it);  // 错误！删除元素后迭代器失效
      } else {
          ++it;
      }
  }
  

  正确做法：erase() 返回下一个有效迭代器：

  for (auto it = s.begin(); it != s.end(); ) {
      if (*it == 'l') {
          it = s.erase(it);  // 正确！更新迭代器
      } else {
          ++it;
      }
  }
  

五、string的遍历与修改

1. string的遍历（逐个访问字符）

方法1：用下标 []（最常用）
类似数组，用 s[i] 访问第 i 个字符（索引从0开始）。
例子：

string s = "hello";
for (size_t i = 0; i < s.size(); i++) {
    cout << s[i] << " ";  // 输出: h e l l o
}

方法2：用迭代器（适合STL算法）
迭代器像「指针」，指向字符串中的字符。
例子：

string s = "hello";
for (auto it = s.begin(); it != s.end(); ++it) {
    cout << *it << " ";  // 输出: h e l l o
}

方法3：范围for循环（C++11起，最简单）
直接遍历每个字符，无需索引。
例子：

string s = "hello";
for (char c : s) {
    cout << c << " ";  
}

2. string的修改（增删改查）

修改单个字符
用下标或迭代器直接修改。
例子：

string s = "hello";
s[0] = 'H';        // s 变为 "Hello"
s.back() = '!';    // 修改最后一个字符，s 变为 "Hello!"

追加内容
用 += 或 append() 方法。
例子：

string s = "hello";
s += " world";      // s 变为 "hello world"
s.append("!");      // s 变为 "hello world!"

插入字符
用 insert() 方法在指定位置插入。
例子：

string s = "hello";
s.insert(1, "X");   // 在位置1插入 'X'，s 变为 "hXello"

删除字符
用 erase() 方法删除指定位置或范围。
例子：

string s = "hello";
s.erase(1, 2);      // 从位置1开始删除2个字符，s 变为 "heo"

替换内容
用 replace() 方法替换指定范围的字符。
例子：

string s = "hello";
s.replace(1, 3, "XXX");  // 替换位置1~3的字符，s 变为 "hXXXo"

3. string的底层（了解即可）

string 的底层是一个动态字符数组，类似 char*，但会自动管理内存：

• 自动扩容：当字符串变长时，string 会自动申请更大的内存，并复制原有内容。
• 内存优化：现代C++对短字符串有特殊优化（SSO，小字符串优化），直接存储在对象内部，避免堆内存分配。

例子（帮助理解底层）：

string s = "a";  // 可能直接存对象内部（SSO）
s += "bcdef";    // 内容太长，转为堆内存存储

注意事项

1. 索引越界：访问 s[i] 时，确保 i < s.size()，否则会导致未定义行为（比如崩溃）。
2. 迭代器失效：修改字符串可能导致迭代器失效，比如：

   for (auto it = s.begin(); it != s.end(); ++it) {
       s.erase(it);  // 错误！删除元素后迭代器失效
   }
   

3. 性能提示：频繁插入/删除可能导致内存频繁重新分配，性能较低。

六、String里的Capacity（容量管理）

1. size() 和 length()（获取字符串长度）

• 作用：返回字符串中实际字符的数量（不包含结尾的 '\0'）。
• 区别：size() 是所有容器（如 vector）通用的接口，length() 是专门为字符串设计的，两者功能完全相同。
  例子：

string s = "hello";
cout << s.size() << endl;   // 输出: 5
cout << s.length() << endl; // 输出: 5（和size()一样）

2. max_size()（最大容量）

作用：返回当前系统中 string 对象能存储的最大字符数（理论上限）。
注意：实际中几乎不可能达到这个值，因为内存会先耗尽。
例子：

string s;
cout << s.max_size() << endl;  // 输出一个很大的数

3. resize(n) 和 resize(n, c)（调整大小）

作用：调整字符串长度为 n：

• 若 n 小于当前长度，截断多余字符。
• 若 n 大于当前长度，用字符 c 填充（默认用 '\0' 填充）。
  例子：

string s = "hello";
s.resize(3);        // s 变为 "hel"
s.resize(5, '!');   // s 变为 "hel!!"

4. capacity()（当前分配的容量）

作用：返回字符串当前分配的内存能容纳的最大字符数（不包含 '\0'）。
特点：容量通常大于等于实际长度，避免频繁重新分配内存。
例子：

string s = "hello";
cout << s.size() << endl;     // 输出: 5（实际长度）
cout << s.capacity() << endl; // 输出: 15（不同系统可能不同）

5. reserve(n)（预分配容量）

作用：提前分配至少能容纳 n 个字符的内存，减少后续扩容次数。
例子：

string s;
s.reserve(100);  // 预先分配100个字符的空间
cout << s.capacity() << endl;  // 输出: 100 或更大（取决于实现）

6. clear()（清空字符串）

作用：清空字符串内容，使其长度为0，但不释放内存（容量不变）。
例子：

string s = "hello";
s.clear();
cout << s.size() << endl;     // 输出: 0
cout << s.capacity() << endl; // 输出: 15（和clear前一样）

7. empty()（判断是否为空）

作用：检查字符串是否为空（长度是否为0）。
例子：

string s = "hello";
cout << s.empty() << endl;  // 输出: 0（false）

s.clear();
cout << s.empty() << endl;  // 输出: 1（true）

8. shrink_to_fit()（缩容）

作用：将容量调整为当前实际长度，释放多余内存。
注意：缩容需要重新分配内存并复制数据，代价较高，建议少用。
例子：

string s;
s.reserve(100);  // 容量变为100
s = "hello";     // 长度变为5，但容量仍为100

s.shrink_to_fit();  // 容量缩小到5（或略大于5）

总结

底层原理（了解即可）

string 的内存管理策略：

• 动态扩容：当字符串长度超过容量时，自动申请更大的内存（通常翻倍），例如：

  string s;
  s += 'a';  // 容量可能变为1
  s += 'b';  // 容量可能变为2
  s += 'c';  // 容量可能变为4（翻倍）
  

• 小字符串优化（SSO）：短字符串（如 "hello"）直接存储在对象内部，不使用堆内存，提高性能。

注意事项

1. 容量 vs 长度：
   • 长度：实际字符数（size()）。
   • 容量：已分配的内存大小（capacity()）。
2. 性能提示：
   • 提前 reserve() 可避免频繁扩容。
   • 少用 shrink_to_fit()，除非确实需要释放大量内存。
3. 清空字符串：clear() 比 s = "" 效率更高，因为不涉及内存分配。

八、string数据访问

1. operator[]（下标访问）

作用：通过索引访问字符串中的字符，类似数组。
重载版本：

• char& operator[] (size_t pos); // 用于非const字符串（可修改）
• const char& operator[] (size_t pos) const; // 用于const字符串（只读）

为什么需要两个版本？
为了区分读写操作：

• 对非const字符串（如 string s = "hello";），s[0] = 'H'; 可以修改字符。
• 对const字符串（如 const string cs = "hi";），cs[0] 只能读，不能修改。

例子：

string s = "hello";
s[0] = 'H';         // 修改第一个字符，s 变为 "Hello"
cout << s[1];       // 输出: e

const string cs = "hi";
// cs[0] = 'H';     // 错误！const版本不允许修改
cout << cs[0];      // 输出: h

2. at() 方法（安全访问）

作用：同 []，但会检查索引是否越界（若越界则抛出 out_of_range 异常）。
例子：

string s = "hello";
try {
    cout << s.at(10);  // 越界，抛出异常
} catch (const out_of_range& e) {
    cout << "错误: " << e.what();  // 输出错误信息
}

对比 [] 和 at()：

3. back()（访问最后一个字符）

作用：返回字符串的最后一个字符的引用。
例子：

string s = "hello";
cout << s.back();       // 输出: o
s.back() = '!';         // 修改最后一个字符，s 变为 "hell!"

4. front()（访问第一个字符）

作用：返回字符串的第一个字符的引用。
例子：

string s = "hello";
cout << s.front();      // 输出: h
s.front() = 'H';        // 修改第一个字符，s 变为 "Hello"

注意事项

1. 空字符串风险：对空字符串调用 back() 或 front() 会导致未定义行为（如崩溃），需先检查 s.empty()。
2. 性能取舍：at() 更安全但稍慢，[] 更快但需自行确保索引合法。
3. 引用返回：[]、at()、back()、front() 返回的都是引用，可直接修改字符。

以上就是这篇博客的全部内容，下一篇我们将继续探索STL中String里更多精彩内容。

我的个人主页，欢迎来阅读我的其他文章
https://blog.csdn.net/2402_83322742?spm=1011.2415.3001.5343
我的C++知识文章专栏
欢迎来阅读指出不足
https://blog.csdn.net/2402_83322742/category_12880513.html?spm=1001.2014.3001.5482