C++ 标准库 string 类详解：接口、原理与模拟实现

int arr[] = {1, 2, 3};
for (auto& e : arr) e *= 2; // 修改原数组

string str("hello world");
for (char ch : str) cout << ch << " ";

2.2）string 类的常用接口

1）构造

string s1;                  // 空串
string s2("Hello");         // C-string 构造
string s3(5, '*');          // *****
string s4(s2);              // 拷贝构造

2）容量操作

注意事项：

• size() 与 length() 底层实现一致，为了与其他容器接口统一。
• clear() 仅重置有效长度，底层分配的内存（capacity）保留，以便后续复用。
• resize(n, c) 若 n 大于当前大小，用 c 填充；若小于则截断。
• reserve(n) 仅在 n 大于当前 capacity 时扩容，不会改变有效字符数。

string s = "hello";
s.reserve(100);             // 空间可能变大，但 size() 仍为 5
s.resize(10, 'x');          // helloxxxxx

3）访问及遍历

string s = "Hello";
// 下标访问
s[0] = 'h';

// 迭代器遍历
for (auto it = s.begin(); it != s.end(); ++it) {
    cout << *it << " ";
}

// 反向迭代器
for (auto rit = s.rbegin(); rit != s.rend(); ++rit) {
    cout << *rit << " ";
}

迭代器类型补充：

• iterator：读写，正向。
• const_iterator：只读，正向。
• reverse_iterator：读写，反向。
• const_reverse_iterator：只读，反向。

4）修改操作

string s = "Hello";
s.push_back('!');           // Hello!
s.append(" World");        // Hello! World
s += " to C++";             // Hello! World to C++

const char* cStr = s.c_str(); // 兼容 C 函数

size_t pos = s.find("World"); // 查找位置
if (pos != string::npos) {
    cout << "Found at: " << pos << endl;
}

string sub = s.substr(7, 6);  // World

性能提示：

• 频繁追加字符时，建议先用 reserve() 预留空间，减少因扩容导致的内存重新分配开销。
• operator+ 会创建临时对象，大量拼接时效率低于 += 或 append。

5）非成员函数

• operator>>：输入流读取（遇到空格停止）。
• operator<<：输出流写入。
• getline(cin, str)：读取整行（含空格）。
• 关系运算符：支持字典序比较。

string name;
girl(cin, name); // 读取一行
if (name > "Alice") cout << "Name is later";

6）不同编译器下的结构差异

不同编译器的 string 实现略有不同，以 32 位平台为例：

• VS 环境：通常占用 28 字节。内部包含联合体，短字符串（<16 字符）使用内部缓冲，长字符串堆分配。还包含长度、容量字段及辅助指针。
• G++ 环境：通常采用写时拷贝（COW）机制，占用较小（如 4 字节指针），指向堆上包含长度、容量、引用计数及数据的结构。

2.3）string 类的模拟实现

面试中常要求手写 String 类，核心在于正确管理资源。重点考察构造函数、析构函数、拷贝构造函数及赋值运算符重载。

1）浅拷贝与深拷贝问题

初学者常忽略拷贝构造函数，导致默认生成浅拷贝，引发重复释放（Double Free）崩溃。

class String {
public:
    String(const char* str = nullptr) {
        if (str == nullptr) assert(false);
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    ~String() {
        delete[] _str;
    }
private:
    char* _str;
};

// 测试
String s1("hello");
String s2(s1); // 触发默认拷贝构造，浅拷贝

问题分析： s1 和 s2 的 _str 指向同一块堆内存。当 s2 析构释放内存后，s1 再析构时会再次释放同一地址，导致程序崩溃。

解决方案： 实现深拷贝，为新对象分配独立内存。

String(const String& s) {
    _str = new char[strlen(s._str) + 1];
    strcpy(_str, s._str);
}

2）传统与现代写法对比

传统写法： 显式申请、拷贝、释放。

String& operator=(const String& s) {
    if (this != &s) {
        char* Pstr = new char[strlen(s._str) + 1];
        strcpy(Pstr, s._str);
        delete[] _str;
        _str = Pstr;
    }
    return *this;
}

现代写法（异常安全）： 利用拷贝交换原则（Copy-and-Swap）。

String& operator=(String s) { // 传值，自动调用拷贝构造
    swap(_str, s._str);       // 交换资源
    return *this;             // s 析构时释放旧资源
}

此写法不仅代码简洁，还能天然处理自赋值情况，且具备异常安全性。

3）写时拷贝（COW）

概念： 结合浅拷贝的高效与深拷贝的安全。读操作共享内存，写操作时才真正复制数据。

机制：

1. 初始状态：多对象共享同一内存页，权限设为只读。
2. 触发写入：检测到写操作时，触发缺页异常，内核分配新内存并复制数据。
3. 继续执行：修改在新内存上进行，原数据保持不变。

应用场景：

• Linux fork()：父子进程共享内存，仅修改时复制，提升进程创建速度。
• Redis bgsave：子进程持久化时共享父进程内存，减少阻塞。
• Java CopyOnWriteArrayList：读多写少场景下的线程安全 List。
• Docker/ZFS：镜像分层存储，容器层修改时复制文件。

优缺点：

• 优点：节省内存，提升读性能，并发读安全。
• 缺点：写操作延迟不可控，存在写放大风险（如 Java 中修改一个元素需复制整个数组）。

2.4）面试中的正确实现要点

实现 String 类需满足以下要求：

1. 支持基本赋值与复制。
2. 可作为函数参数及返回值。
3. 可作为 STL 容器（如 vector）的元素类型。

关键在于遵循'三法则'（Rule of Three）：若定义了析构函数，通常也需定义拷贝构造函数和赋值运算符。

2.5）STL string 的现状

现代 C++ 标准库的 string 实现已高度优化，部分版本不再使用传统的 COW 策略（因多线程环境下引用计数维护复杂），转而采用更安全的独占所有权模型。但在理解底层原理时，COW 依然是重要的知识储备。

本文涵盖了 string 类的核心接口、内存管理机制及模拟实现细节。理解这些内容有助于编写更安全、高效的 C++ 代码。