C++ string 类详解：接口、模拟实现与写时拷贝

示例：

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

int main() {
    int array[] = {1, 2, 3, 4, 5};
    // C++11 的遍历
    for(auto& e : array) e *= 2;
    
    string str("hello world");
    for(auto ch : str) {
        cout << ch << " ";
    }
    cout << endl;
    return 0;
}

2.2）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 类对象的容量操作

注意事项：

• size() 与 length() 底层原理相同。
• clear() 是清空有效字符，但不改变底层空间大小（capacity）。
• resize(n, c) 改变有效字符个数，多出的空间用字符 c 填充。
• reserve(res_arg) 为 string 预留空间，不改变有效元素个数；只有当参数大于当前底层空间时才会扩容。

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

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

int main() {
    string s = "Hello";
    // 下标访问
    cout << s[1] << endl;
    // 迭代器遍历
    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;
}

4）string 类对象的修改操作

#include <iostream>
using namespace std;

int main() {
    string s = "Hello";
    s.push_back('!');
    s.append(" Welcome");
    s += " to C++";
    const char* cStr = s.c_str();
    size_t pos = s.find("Welcome");
    string sub = s.substr(7, 7);
    return 0;
}

5）string 类非成员函数

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

6）vs 和 g++ 下 string 结构的说明

注意：下述结构是在 32 位平台下进行验证，32 位平台下指针占 4 个字节。

VS 下 string 的结构 string 总共占 28 个字节。内部有一个联合体定义存储空间：

• 当字符串长度小于 16 时，使用内部固定的字符数组。
• 当字符串长度大于等于 16 时，从堆上开辟空间。 此外还有 size_t 字段保存长度和容量，以及一个指针。

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

2.3）string 类的模拟实现

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

1）经典的 string 类问题

浅拷贝导致的崩溃 如果未自定义拷贝构造函数，编译器生成的默认拷贝构造函数执行浅拷贝，导致两个对象共享同一块堆内存。析构时重复释放会导致程序崩溃。

解决方案：手动实现深拷贝。

class String {
public:
    String(const char* str = "") {
        if (str != nullptr) {
            _str = new char[strlen(str) + 1];
            strcpy(_str, str);
        } else {
            _str = nullptr;
        }
    }
    // 拷贝构造函数
    String(const String& s) {
        if (s._str) {
            _str = new char[strlen(s._str) + 1];
            strcpy(_str, s._str);
        } else {
            _str = nullptr;
        }
    }
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

2）浅拷贝 VS 深拷贝

• 传统写法：显式分配内存并拷贝数据。
• 现代写法：利用移动语义或交换法（Copy-and-Swap）优化赋值运算符。

class String {
public:
    /*拷贝构造函数*/
    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;
};

3）写时拷贝（COW）

什么是写时拷贝？ 结合了浅拷贝和深拷贝的优点。读操作时共享内存，写操作时才真正分配新内存复制数据。

工作机制

1. 初始状态：进程 A 拥有内存页 Page 1。
2. 发生拷贝（如 fork）：A 和 B 共享 Page 1，权限设为只读。
3. 安全读取：无额外开销。
4. 触发写入：CPU 发现只读，触发缺页异常。
5. 内核介入：分配新物理内存 Page 2，复制数据，恢复读写权限。

应用场景

1. Linux 中的 fork() 系统调用。
2. Redis 的 bgsave 持久化。
3. Java 中的 CopyOnWriteArrayList。
4. 容器技术与存储（Docker / ZFS）。

优缺点总结

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

2.4）面试中 string 的一种正确写法

C++ 面试题中实现 String 类的基本要求：

1. 能像 int 类型那样定义变量，支持赋值、复制。
2. 能用作函数的参数类型及返回类型。
3. 能用作标准库容器的元素类型（如 vector/list/deque 的 value_type）。

2.5）STL 中的 string 类怎么了？

不同编译器实现差异较大，了解底层结构有助于优化代码性能。