C++手写String类：深入理解内存管理与类设计

1. 为什么需要自己实现string类

在C++标准库中，std::string已经是一个非常完善的字符串处理类了，那我们为什么还要自己动手实现一个呢？这就像虽然市面上有各种现成的汽车，但汽车工程师仍然需要从零开始造一辆车来理解所有细节。

首先，通过手写string类，我们可以深入理解以下几个关键点：

• 内存管理的本质：如何动态分配和释放内存
• 深浅拷贝的区别及其实现方式
• 运算符重载的实际应用场景
• 类设计的封装性原则

我在实际工作中发现，很多C++开发者虽然能熟练使用std::string，但当被问到"string对象在内存中是如何布局的"或者"为什么string可以像基本类型一样用=赋值"时，往往回答不上来。这就是知其然不知其所以然的表现。

2. 基础架构设计

2.1 类的基本结构

我们先来定义类的骨架。一个最基本的string类需要包含以下成员：

cpp复制class MyString {
private:
    char* m_data;  // 存储字符串数据的指针
    size_t m_size; // 当前字符串长度
    size_t m_capacity; // 当前分配的内存容量
    
public:
    // 构造函数和析构函数
    MyString();
    MyString(const char* str);
    ~MyString();
    
    // 拷贝控制
    MyString(const MyString& other);
    MyString& operator=(const MyString& other);
    
    // 基本功能
    size_t size() const;
    size_t capacity() const;
    const char* c_str() const;
};

这里有几个设计要点需要注意：

1. 我们使用三个私有成员变量来管理字符串状态
2. 提供了从C风格字符串构造的接口
3. 显式定义了拷贝构造函数和赋值运算符

重要提示：在C++中，如果你需要管理动态内存，那么"三大件"（析构函数、拷贝构造函数、赋值运算符）必须同时定义或同时不定义，这就是著名的Rule of Three原则。

2.2 内存管理策略

内存管理是string类最核心的部分。我们采用类似std::vector的增长策略：

1. 初始分配一定容量（比如16字节）
2. 当需要扩容时，按照当前容量的1.5倍或2倍增长
3. 每次操作后维护m_size和m_capacity的正确性

这种策略在时间和空间效率上取得了很好的平衡。我在实际测试中发现，1.5倍增长比2倍增长在内存利用率上更优，但2倍增长在频繁追加操作时性能更好。

3. 核心功能实现

3.1 构造函数与析构函数

让我们先实现基础的构造和析构：

cpp复制MyString::MyString() : m_data(nullptr), m_size(0), m_capacity(0) {
    m_data = new char[1];
    m_data[0] = '\0';
}

MyString::MyString(const char* str) {
    m_size = strlen(str);
    m_capacity = m_size + 1;
    m_data = new char[m_capacity];
    strcpy(m_data, str);
}

MyString::~MyString() {
    delete[] m_data;
}

这里有几个容易出错的地方：

1. 默认构造函数必须分配至少1字节的空间并设置空字符
2. 带参构造函数要考虑字符串终止符'\0'的位置
3. 析构函数要用delete[]而不是delete

3.2 拷贝控制实现

拷贝控制是string类最容易出错的部分，我们先看错误示范：

cpp复制// 错误实现 - 浅拷贝
MyString::MyString(const MyString& other) 
    : m_data(other.m_data), 
      m_size(other.m_size),
      m_capacity(other.m_capacity) {}

这种实现会导致两个string对象共享同一块内存，析构时会出现双重释放的问题。正确的深拷贝实现如下：

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

MyString& MyString::operator=(const MyString& other) {
    if (this != &other) {  // 自赋值检查
        delete[] m_data;   // 释放原有内存
        
        m_size = other.m_size;
        m_capacity = other.m_capacity;
        m_data = new char[m_capacity];
        strcpy(m_data, other.m_data);
    }
    return *this;
}

这里有个重要技巧：赋值运算符要先检查自赋值情况（如s = s），否则直接delete会导致数据丢失。

4. 常用功能扩展

4.1 字符串连接功能

实现字符串连接操作符+和+=：

cpp复制MyString operator+(const MyString& lhs, const MyString& rhs) {
    MyString result;
    result.m_size = lhs.m_size + rhs.m_size;
    result.m_capacity = result.m_size + 1;
    result.m_data = new char[result.m_capacity];
    strcpy(result.m_data, lhs.m_data);
    strcat(result.m_data, rhs.m_data);
    return result;
}

MyString& MyString::operator+=(const MyString& other) {
    size_t new_size = m_size + other.m_size;
    if (new_size + 1 > m_capacity) {
        reserve(new_size * 2);  // 扩容
    }
    strcat(m_data, other.m_data);
    m_size = new_size;
    return *this;
}

实现时要注意：

1. +运算符通常实现为非成员函数
2. +=运算符要处理可能的扩容情况
3. 连接后要正确更新size

4.2 下标访问与迭代器

为了支持类似数组的访问方式，我们需要实现operator[]：

cpp复制char& MyString::operator[](size_t index) {
    if (index >= m_size) {
        throw std::out_of_range("Index out of range");
    }
    return m_data[index];
}

const char& MyString::operator[](size_t index) const {
    if (index >= m_size) {
        throw std::out_of_range("Index out of range");
    }
    return m_data[index];
}

同时，为了支持范围for循环，我们可以提供简单的迭代器支持：

cpp复制char* MyString::begin() { return m_data; }
char* MyString::end() { return m_data + m_size; }
const char* MyString::begin() const { return m_data; }
const char* MyString::end() const { return m_data + m_size; }

5. 性能优化技巧

5.1 移动语义支持

现代C++中，移动语义可以显著提升性能。我们需要实现移动构造函数和移动赋值运算符：

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

MyString& MyString::operator=(MyString&& other) noexcept {
    if (this != &other) {
        delete[] m_data;
        
        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;
    }
    return *this;
}

移动操作的关键点：

1. 直接"窃取"源对象的资源
2. 将源对象置于有效但空的状态
3. 标记为noexcept以便标准库优化

5.2 小字符串优化

在实际项目中，很多字符串都很短（小于16字节）。我们可以实现小字符串优化(SSO)：

cpp复制class MyString {
private:
    union {
        char* m_data;
        char m_sso_buffer[16];
    };
    size_t m_size;
    bool m_is_sso;
    
    // 其他成员...
};

当字符串较短时，直接使用栈上的buffer；较长时才动态分配内存。这种优化可以显著减少小字符串的内存分配开销。

6. 测试与验证

6.1 基础功能测试

编写测试用例验证基本功能：

cpp复制void test_basic() {
    MyString s1;  // 默认构造
    assert(s1.size() == 0);
    
    MyString s2("hello");  // C字符串构造
    assert(s2.size() == 5);
    
    MyString s3 = s2;  // 拷贝构造
    assert(strcmp(s3.c_str(), "hello") == 0);
    
    s1 = s3;  // 赋值
    assert(s1.size() == 5);
}

6.2 边界情况测试

特别注意测试边界情况：

cpp复制void test_edge_cases() {
    // 空字符串
    MyString empty;
    assert(empty.size() == 0);
    
    // 自赋值
    MyString s("test");
    s = s;
    assert(strcmp(s.c_str(), "test") == 0);
    
    // 超长字符串
    const char* longStr = "this is a very long string...";
    MyString ls(longStr);
    assert(ls.size() == strlen(longStr));
}

6.3 性能测试

比较自定义string和std::string的性能：

cpp复制void test_performance() {
    auto start = std::chrono::high_resolution_clock::now();
    
    MyString s;
    for (int i = 0; i < 100000; ++i) {
        s += "test";
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "MyString: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
              << "ms\n";
}

7. 常见问题与解决方案

7.1 内存泄漏问题

内存泄漏是最常见的问题之一。确保：

1. 每个new都有对应的delete
2. 在赋值运算符中先释放旧内存
3. 使用工具如Valgrind检测内存泄漏

7.2 缓冲区溢出

字符串操作容易发生缓冲区溢出。预防措施：

1. 所有涉及内存写入的操作都要检查边界
2. 使用strncpy代替strcpy
3. 维护好size和capacity的关系

7.3 异常安全问题

保证在异常发生时对象仍处于有效状态：

1. new可能抛出bad_alloc异常
2. 赋值运算符应该先分配新内存再释放旧内存
3. 使用RAII技术管理资源

8. 进阶扩展思路

8.1 支持Unicode

当前实现仅支持ASCII字符。要支持Unicode需要：

1. 改用wchar_t或char16_t/char32_t
2. 实现UTF-8/UTF-16编码转换
3. 考虑多字节字符的length计算

8.2 实现字符串视图

C++17引入了string_view，我们可以实现类似的轻量级视图类：

cpp复制class MyStringView {
private:
    const char* m_data;
    size_t m_size;
    
public:
    // 接口实现...
};

8.3 添加格式化功能

实现类似sprintf的格式化功能：

cpp复制MyString MyString::format(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    
    // 计算所需空间
    int len = vsnprintf(nullptr, 0, fmt, args);
    
    MyString result;
    result.reserve(len + 1);
    
    vsnprintf(result.m_data, len + 1, fmt, args);
    result.m_size = len;
    
    va_end(args);
    return result;
}

手写string类是一个非常好的学习项目，它几乎涵盖了C++面向对象编程和资源管理的所有核心概念。在实际项目中，除非有特殊需求，否则还是建议使用标准库的std::string，因为它经过了充分的优化和测试。但通过这个练习，你会对C++的内存管理、类设计和运算符重载有更深入的理解。