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

范围 for 不仅能作用于数组，也能作用于容器对象如 std::string。循环会自动调用 begin() 和 end()，无需手动管理迭代器或下标。

string 类的常用接口

1）string 类的常用构造

#include <iostream>
#include <string>
using namespace std;

int main() {
    string s1;                  // 空字符串
    string s2("Hello World");   // 由字符串常量构造
    string s3(10, '*');         // 10 个星号
    string s4(s2);              // 拷贝构造
    return 0;
}

2）string 类对象的容量操作

注意事项：

1. size() 与 length() 底层原理相同，主要是为了与其他容器接口保持一致。
2. clear() 是清空有效字符，但不改变底层空间大小（capacity）。
3. resize(n, c) 改变有效字符个数。如果 n 大于当前大小，用字符 c 填充；如果小于，则截断。
4. reserve(n) 为 string 预留空间，不改变有效元素个数。只有当参数大于当前底层空间时才会扩容。

3）string 类对象的访问及遍历操作

#include <iostream>
#include <string>
using namespace std;

int main() {
    string s = "Hello";
    
    // 下标访问
    cout << s[1] << endl;  // 'e'
    s[0] = 'h';            // 可以修改
    
    // 迭代器遍历
    for(string::iterator it = s.begin(); it != s.end(); ++it) {
        cout << *it << " ";
    }
    
    // 反向迭代器遍历
    for(string::reverse_iterator rit = s.rbegin(); rit != s.rend(); ++rit) {
        cout << *rit << " ";
    }
    
    // 范围 for
    for(char c : s) {
        cout << c << "-";
    }
    return 0;
}

对于 string 来说，常用的四种组合包括：iterator（能读能改，正着走）、const_iterator（只能读，正着走）、reverse_iterator（能读能改，倒着走）、const_reverse_iterator（只能读，倒着走）。

4）string 类对象的修改操作

#include <iostream>
using namespace std;

int main() {
    string s = "Hello";
    
    s.push_back('!');          // "Hello!"
    s.append(" Welcome");      // "Hello! Welcome"
    s += " to C++";            // "Hello! Welcome to C++"
    
    const char* cStr = s.c_str();
    cout << cStr << endl;
    
    size_t pos = s.find("Welcome");
    if(pos != string::npos) {
        cout << "Found at: " << pos << endl;
    }
    
    string sub = s.substr(7, 7);
    cout << "Sub-string: " << sub << endl;
    return 0;
}

追加字符的三种方式：

1. push_back(c)：只能插入单个字符。
2. append(n, c)：表示追加 n 个字符 c。
3. +=：最常用，既可以连接单个字符，也可以连接字符串。

使用 reserve 预留空间： 如果预估要存较多字符，先预留空间可以减少频繁扩容带来的性能消耗。

string s;
s.reserve(50);  // 预留 50 字节

5）string 类非成员函数

string full_name;
getline(cin, full_name);
cout << "你好，" << full_name << endl;

string str1 = "apple";
string str2 = "banana";
if(str1 < str2) {
    cout << "apple 在字典中排在 banana 前面" << endl;
}

6）VS 和 G++ 下 string 结构的说明

VS 下 string 的结构 string 总共占 28 个字节。内部有一个联合体，当字符串长度小于 16 时，使用内部固定的字符数组存放；大于等于 16 时，从堆上开辟空间。此外还有保存长度的字段和保存容量的字段。

G++ 下 string 的结构 G++ 下，string 是通过写时拷贝实现的，对象总共占 4 个字节，内部只包含了一个指针，指向堆空间。堆空间中包含了空间总大小、字符串有效长度、引用计数等信息。

string 类的模拟实现

在面试中，面试官常要求模拟实现 string 类，重点在于构造、拷贝构造、赋值运算符重载以及析构函数。

浅拷贝问题 初学者容易忽略拷贝构造函数，导致浅拷贝。默认拷贝构造函数只是简单复制指针地址，析构时会重复释放同一块内存，导致程序崩溃。

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

void TestString() {
    String s1("hello bit!!!");
    String s2(s1);  // 触发隐式拷贝构造，若未自定义则为浅拷贝
}

解决方案 手动实现拷贝构造函数，为新对象申请独立内存空间。

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

传统 vs 现代的 string 类

传统写法 直接分配内存并拷贝，赋值运算符需检查自赋值并释放旧资源。

现代写法 利用移动语义或交换法优化。例如赋值运算符采用传值语义，形参是局部副本，函数结束时自动释放旧资源，只需交换指针即可。

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

    String(const String& s) : _str(nullptr) {
        String strTmp(s._str);
        swap(_str, strTmp._str);
    }

    String& operator=(String s) {
        std::swap(_str, s._str);
        return *this;
    }

    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

写时拷贝（COW）

什么是写时拷贝？ 写时拷贝是一种结合了浅拷贝和深拷贝优点的策略。读操作时共享内存，写操作时才真正分配新内存进行拷贝。核心思想是延迟执行。

工作机制 以操作系统内存页为例：进程 A 拥有 Page 1。发生拷贝（如 fork）时，系统不复制数据，而是让 A 和 B 都指向 Page 1，并将权限设为只读。当 B 试图写入时触发缺页异常，内核分配新页面 Page 2 并复制数据，B 映射到 Page 2，A 保持 Page 1。

应用场景

1. Linux fork()：父子进程初始共享内存，仅修改时拷贝，提升创建速度。
2. Redis bgsave：子进程负责持久化，父进程继续处理请求，避免阻塞。
3. Java CopyOnWriteArrayList：读多写少场景，写时复制数组。
4. Docker/ZFS：镜像分层存储，容器层可写，底层镜像只读。

优缺点总结

• 优点：节省资源，提升性能，并发读安全。
• 缺点：不可预知的延迟，写放大开销。

面试中 string 的正确写法

C++ 面试题通常要求实现一个 String 类，至少满足：

1. 支持定义变量、赋值、复制。
2. 能用作函数参数及返回类型。
3. 能作为标准库容器的元素类型。

实现时需确保资源管理正确，遵循三法则（Rule of Three）或五法则（Rule of Five），处理好深拷贝与移动语义。