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

#include <iostream>
#include <string>
#include <vector>
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
    for(auto &e : arr) { // 引用修改原数组
        e++;
        cout << e << " ";
    }
    cout << endl;
    
    string str("hello world");
    for(auto c : str) {
        cout << c << " ";
    }
    cout << endl;
    
    return 0;
}

2.3 string 常用接口概览

构造与容量操作

注意：size() 与 length() 底层实现一致，建议统一使用 size() 以保持与其他容器的接口一致性。reserve() 仅预留空间，不会改变有效元素数量。

访问与遍历

修改操作

提示：若预估字符串增长量，可先调用 reserve() 预留空间，避免频繁扩容带来的性能损耗。operator+= 比 operator+ 更高效，因为后者涉及传值和深拷贝。

输入输出与非成员函数

3. string 类的模拟实现

面试中常要求手写 string 类，核心在于处理资源管理：构造、拷贝构造、赋值运算符重载、析构函数。这涉及到浅拷贝与深拷贝的问题。

3.1 浅拷贝陷阱

如果未显式定义拷贝构造函数，编译器会生成默认的浅拷贝版本。对于管理动态内存的类，这意味着两个对象共享同一块堆内存。当其中一个对象销毁时，内存被释放，另一个对象再访问就会发生野指针错误。

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;
};

void Test() {
    String s1("hello");
    String s2(s1); // 默认拷贝构造，浅拷贝
}

3.2 深拷贝解决方案

每个对象应拥有独立的资源。我们需要显式实现拷贝构造函数和赋值运算符。

传统写法

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;
};

现代写法：拷贝 - 交换（Copy-and-Swap）

利用临时对象和 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;
};

3.3 写时拷贝（Copy-On-Write）

这是一种优化策略，通过引用计数来共享资源。只有当需要修改数据时，才真正复制一份副本。这在只读场景下能显著减少内存开销，但在多线程环境下需要额外的锁机制保护。

4. 实战练习

理解理论后，建议通过以下经典题目巩固：

1. 反转字符串中的字母：双指针法。
2. 字符串中的第一个唯一字符：哈希表统计频率。
3. 最后一个单词的长度：从后向前遍历。
4. 验证回文串：忽略非字母数字字符，双指针比较。
5. 字符串相加：模拟大数加法逻辑。

这些题目涵盖了 string 类最常用的操作模式，熟练掌握后对面试大有裨益。