C++ 标准库 string 类详解与模拟实现

范围 for 循环 C++11 引入了基于范围的 for 循环，简化了集合遍历。括号由冒号分为两部分：迭代变量和被迭代范围。它会自动处理迭代器，无需手动判断结束条件。

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

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    
    // C++98 写法
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
        arr[i]++;
        cout << arr[i] << " ";
    }
    cout << endl;
    
    // C++11 写法
    for (auto &e : arr) { // 引用修改原数组
        e++;
        cout << e << " ";
    }
    cout << endl;
    
    string str("hello world");
    for (auto c : str) {
        cout << c << " ";
    }
    cout << endl;
    
    return 0;
}

string 类常用接口

1. 构造方式

void Test() {
    string s1;              // 空字符串
    string s2("hello world"); // C 字符串构造
    string s3(s2);          // 拷贝构造
}

2. 容量操作

注意：

• size() 与 length() 原理相同，为了与其他容器接口一致，通常用 size()。
• clear() 只清空内容，底层空间不变。
• resize(n) 扩容时用 \0 填充，resize(n, c) 用字符 c 填充。
• reserve() 若参数小于当前容量，则不改变容量。

3. 访问及遍历

4. 修改操作

提示：

• 尾部追加字符时，s.push_back(c)、s.append(1, c) 和 s += 'c' 效果类似，+= 最常用。
• 若能预估字符数量，先用 reserve() 预留空间可减少内存重分配开销。

5. 非成员函数

底层结构差异

不同编译器下 string 的内部实现有所不同，以 32 位平台为例：

VS 下的结构

VS 的 string 占用 28 字节。采用短字符串优化（SSO）：

• 当字符串长度小于 16 时，使用内部固定字符数组存放，无需堆分配。
• 当长度大于等于 16 时，从堆上开辟空间。
• 结构体包含联合体、长度字段、容量字段及其他指针信息。

g++ 下的结构

g++ 的 string 通常采用写时拷贝（Copy-On-Write），对象本身仅占 4 字节（一个指针）。

• 指针指向堆上的控制块，包含：空间总大小、有效长度、引用计数。
• 这种设计在多线程环境下需注意线程安全问题。

string 类的模拟实现

面试中常要求手写 string 类，核心在于掌握资源管理规则（Rule of Three/Five）。

浅拷贝问题

如果未显式定义拷贝构造函数和赋值运算符，编译器会生成默认的浅拷贝。这会导致两个对象共享同一块堆内存，析构时发生重复释放，引发程序崩溃。

class String {
public:
    String(const char* str = "") {
        if (nullptr == str) {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};
// 测试代码中若进行 String s2(s1)，将导致浅拷贝错误

深拷贝解决方案

每个对象应拥有独立的资源副本。

传统写法

显式实现拷贝构造函数、赋值运算符重载和析构函数。

class String {
public:
    String(const char* str = "") {
        if (nullptr == str) {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    
    // 拷贝构造
    String(const String& s) : _str(new char[strlen(s._str) + 1]) {
        strcpy(_str, s._str);
    }
    
    // 赋值运算符重载
    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;
    }
    
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

现代写法（异常安全）

利用临时对象和 swap 提高效率，减少内存泄漏风险。

class String {
public:
    String(const char* str = "") {
        if (nullptr == str) {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    
    // 拷贝构造
    String(const String& s) : _str(new char[strlen(s._str) + 1]) {
        strcpy(_str, s._str);
    }
    
    // 赋值运算符重载 (右值引用版本)
    String& operator=(String& s) {
        swap(_str, s._str);
        return *this;
    }
    
    // 赋值运算符重载 (常量引用版本)
    String& operator=(const String& s) {
        if (this != &s) {
            String temp(s);
            swap(_str, temp._str);
        }
        return *this;
    }
    
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

扩展阅读与练习

• 写时拷贝原理
• STL string 相关问题
• LeetCode 练习题：反转字母
• LeetCode 练习题：第一个唯一字符
• 牛客网练习题：字符串最后一个单词的长度
• LeetCode 练习题：验证回文串
• LeetCode 练习题：字符串相加