C++ string类深度解析与实现指南

1. 从C风格字符串到C++ string类的进化之路

第一次接触C++的string类时，我还在用strcpy和strcat这些C风格的字符串函数。记得有次深夜调试，因为忘记给目标数组分配足够空间，导致程序崩溃，花了两个小时才找到这个低级错误。这种痛苦经历让我深刻理解了C++标准库设计string类的良苦用心。

string类封装了字符串的存储和管理，自动处理内存分配，提供丰富的操作方法，让开发者从繁琐的指针操作中解放出来。它不仅是字符序列的容器，更是一套完整的字符串处理解决方案。从简单的查找替换到复杂的模式匹配，string类都能优雅应对。

2. string类核心接口深度解析

2.1 构造与初始化：七种武器

string类提供了多种构造函数，满足不同场景下的初始化需求：

cpp复制string s1;               // 默认构造，空字符串
string s2("hello");      // C风格字符串初始化
string s3(5, 'A');       // 填充构造，5个'A'
string s4(s2);           // 拷贝构造
string s5(s2, 1, 3);     // 子串构造，从位置1开始取3个字符
string s6(s2.begin(), s2.begin()+3); // 迭代器范围构造
string s7 = "world";     // 赋值运算符

经验之谈：初始化列表构造（C++11）string s8{'h','e','l','l','o'}在某些编译器上可能比直接字符串初始化更高效，特别是在已知字符串长度且较短时。

2.2 容量操作：内存管理的艺术

cpp复制s.capacity();  // 返回当前分配的存储容量
s.reserve(100); // 预分配100字节空间
s.shrink_to_fit(); // 请求减少capacity以匹配size
s.resize(10);  // 调整字符串长度为10，多删少补

内存分配策略因实现而异，VS2019的string在小于15字符时使用SSO（Small String Optimization），直接在栈上存储；超过后才会在堆上分配。这种优化对小字符串操作性能提升显著。

2.3 元素访问：安全与效率的平衡

cpp复制s[0];       // 不检查越界，性能最高
s.at(0);    // 会检查越界，抛出std::out_of_range
s.front();  // 首字符引用
s.back();   // 末字符引用
s.data();   // 返回C风格字符数组（C++17起保证以null结尾）
s.c_str();  // 保证返回null结尾的C风格字符串

避坑指南：在循环中频繁调用s.at()会带来额外性能开销，确认安全的情况下应优先使用operator[]。

2.4 修改操作：字符串的七十二变

追加操作：

cpp复制s += " append";  // 最常用
s.append(" world", 5);  // 追加前5个字符
s.push_back('!'); // 追加单个字符

插入与删除：

cpp复制s.insert(6, "inserted ");  // 在位置6插入
s.erase(6, 9);  // 从位置6开始删除9个字符
s.clear();     // 清空字符串

替换操作：

cpp复制s.replace(0, 5, "HELLO");  // 替换位置0开始的5个字符

2.5 字符串操作：查找与子串

查找系列：

cpp复制size_t pos = s.find("ll");  // 返回首次出现位置
pos = s.rfind("ll");       // 从后向前查找
pos = s.find_first_of("aeiou"); // 查找任意元音字母
pos = s.find_last_not_of(" \t"); // 查找最后一个非空白字符

子串提取：

cpp复制string sub = s.substr(6, 5);  // 从位置6开始取5个字符

3. 手把手实现简易string类

3.1 基础框架设计

cpp复制class MyString {
public:
    // 构造与析构
    MyString();
    MyString(const char* str);
    MyString(const MyString& other);
    ~MyString();
    
    // 容量操作
    size_t size() const;
    size_t capacity() const;
    bool empty() const;
    void reserve(size_t new_cap);
    
    // 元素访问
    char& operator[](size_t pos);
    const char& operator[](size_t pos) const;
    char& at(size_t pos);
    
    // 修改操作
    MyString& operator+=(const MyString& str);
    void push_back(char ch);
    void clear();
    
private:
    char* m_data;       // 字符串数据
    size_t m_size;      // 当前长度
    size_t m_capacity;  // 当前容量
};

3.2 关键实现细节

内存管理策略：

cpp复制void MyString::reserve(size_t new_cap) {
    if (new_cap <= m_capacity) return;
    
    char* new_data = new char[new_cap + 1]; // +1 for '\0'
    memcpy(new_data, m_data, m_size + 1);   // 复制原数据包括null终止符
    delete[] m_data;
    m_data = new_data;
    m_capacity = new_cap;
}

拷贝构造与赋值：

cpp复制MyString::MyString(const MyString& other) 
    : m_size(other.m_size), m_capacity(other.m_capacity) {
    m_data = new char[m_capacity + 1];
    memcpy(m_data, other.m_data, m_size + 1);
}

MyString& MyString::operator=(const MyString& other) {
    if (this != &other) {
        char* new_data = new char[other.m_capacity + 1];
        memcpy(new_data, other.m_data, other.m_size + 1);
        delete[] m_data;
        m_data = new_data;
        m_size = other.m_size;
        m_capacity = other.m_capacity;
    }
    return *this;
}

移动语义实现（C++11）：

cpp复制MyString::MyString(MyString&& other) noexcept 
    : m_data(other.m_data), m_size(other.m_size), m_capacity(other.m_capacity) {
    other.m_data = nullptr;
    other.m_size = 0;
    other.m_capacity = 0;
}

3.3 运算符重载的艺术

cpp复制bool operator==(const MyString& lhs, const MyString& rhs) {
    return lhs.size() == rhs.size() && 
           memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
}

MyString operator+(const MyString& lhs, const MyString& rhs) {
    MyString result;
    result.reserve(lhs.size() + rhs.size());
    result += lhs;
    result += rhs;
    return result;
}

std::ostream& operator<<(std::ostream& os, const MyString& str) {
    return os << str.c_str();
}

4. 性能优化与异常安全

4.1 写时复制（COW）的取舍

早期STL实现常用COW技术优化string拷贝性能，但在多线程环境下需要额外同步开销。C++11后，大多数实现转向SSO+移动语义的组合优化。

cpp复制// COW实现示例
class CowString {
    struct StringData {
        size_t refcount;
        size_t capacity;
        char data[1];  // 柔性数组
    };
    
    StringData* m_data;
    
    void detach() {
        if (m_data->refcount > 1) {
            StringData* new_data = create_data(m_data->capacity);
            memcpy(new_data->data, m_data->data, size());
            --m_data->refcount;
            m_data = new_data;
        }
    }
};

4.2 短字符串优化（SSO）实现

cpp复制class SsoString {
    static const size_t SSO_BUFFER_SIZE = 15;
    
    union {
        struct {
            char* ptr;
            size_t size;
            size_t capacity;
        } long_str;
        char sso_buffer[SSO_BUFFER_SIZE + 1];
    };
    
    bool is_sso() const {
        return size() <= SSO_BUFFER_SIZE;
    }
    
    const char* data() const {
        return is_sso() ? sso_buffer : long_str.ptr;
    }
};

4.3 异常安全保证

string操作需要满足基本异常安全保证，关键操作如reserve应实现强异常安全：

cpp复制void MyString::reserve(size_t new_cap) {
    if (new_cap <= m_capacity) return;
    
    char* new_data = nullptr;
    try {
        new_data = new char[new_cap + 1];
        memcpy(new_data, m_data, m_size + 1);
    } catch (...) {
        delete[] new_data;
        throw;
    }
    
    delete[] m_data;
    m_data = new_data;
    m_capacity = new_cap;
}

5. 实战中的坑与最佳实践

5.1 常见陷阱排查表

5.2 性能优化技巧

1. 批量操作优于单字符操作：一次性append长字符串比多次push_back快5-10倍
2. reserve预分配：已知最终大小时，预分配可避免多次重分配
3. 移动而非拷贝：C++11后优先使用移动语义传递string
4. 避免临时对象：s = s + "a" + "b"会创建多个临时对象，应改为s += "a"; s += "b"

5.3 与现代C++特性的结合

字符串视图配合：

cpp复制void process(std::string_view sv) {
    // 只读操作无需拷贝字符串
    size_t pos = sv.find("key");
    // ...
}

process("临时字符串");  // 不会产生std::string构造开销

格式化字符串（C++20）：

cpp复制std::string s = std::format("The answer is {}.", 42);

实现string类最让我深刻的理解是：标准库的设计处处体现着效率与安全的平衡。比如operator[]不检查边界是为了给高性能场景留出空间，而at()则提供了安全选项。这种设计哲学值得在自定义类时借鉴。