C++自定义String类实现与内存管理详解

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

在C++标准库中，string类已经提供了完善的字符串操作功能，但作为C++开发者，手动实现一个简化版的string类仍然是极有价值的学习过程。这不仅能帮助我们深入理解字符串在内存中的存储方式，还能掌握以下几个关键知识点：

• 动态内存管理的核心机制（new/delete的使用）
• 深浅拷贝问题的本质与解决方案
• 运算符重载的实际应用场景
• 类设计中的异常安全考虑
• 迭代器模式的底层实现原理

我在实际开发中发现，很多看似简单的字符串操作背后都隐藏着复杂的内存管理逻辑。比如一个简单的字符串拼接操作，就需要考虑内存重新分配、数据拷贝和原有内存释放等一系列问题。通过自己实现string类，可以真正理解标准库中那些"魔法"般的接口是如何工作的。

2. 基础结构设计与构造函数实现

2.1 类的基本框架

我们先定义类的骨架结构，包含必要的成员变量和基础接口声明：

cpp复制class MyString {
public:
    // 构造函数系列
    MyString();
    MyString(const char* str);
    MyString(const MyString& other);  // 拷贝构造函数
    ~MyString();
    
    // 基础功能接口
    size_t size() const;
    const char* c_str() const;
    
private:
    char* m_data;       // 存储字符串数据
    size_t m_length;    // 字符串长度(不含'\0')
    size_t m_capacity;  // 当前分配的内存容量
};

2.2 默认构造函数实现

默认构造函数创建一个空字符串，但仍需分配最小内存空间：

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

这里我特意分配了1字节内存而不是直接置nullptr，是为了保持与c_str()接口的兼容性。在实际项目中，这种设计可以避免大量空指针检查。

2.3 带参构造函数实现

从C风格字符串构造时，需要考虑字符串长度和内存分配：

cpp复制MyString::MyString(const char* str) {
    if (str == nullptr) {
        m_data = new char[1];
        m_data[0] = '\0';
        m_length = 0;
        m_capacity = 1;
    } else {
        m_length = strlen(str);
        m_capacity = m_length + 1;  // 多分配1字节存放'\0'
        m_data = new char[m_capacity];
        strcpy(m_data, str);
    }
}

注意：这里使用了strlen和strcpy，虽然效率不是最高，但代码可读性更好。生产环境中可以考虑使用memcpy配合长度直接拷贝。

3. 关键功能实现：拷贝控制与内存管理

3.1 拷贝构造函数与深拷贝问题

直接使用编译器生成的拷贝构造函数会导致浅拷贝问题——多个对象共享同一块内存。我们需要实现深拷贝：

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

3.2 赋值运算符重载

赋值运算符需要考虑自赋值情况和异常安全：

cpp复制MyString& MyString::operator=(const MyString& other) {
    if (this != &other) {  // 防止自赋值
        char* temp = new char[other.m_capacity];  // 先分配新内存
        strcpy(temp, other.m_data);
        
        delete[] m_data;  // 再释放旧内存
        m_data = temp;
        m_length = other.m_length;
        m_capacity = other.m_capacity;
    }
    return *this;
}

这种实现方式遵循了异常安全原则——如果new操作抛出异常，原有数据不会被破坏。

3.3 移动语义实现（C++11及以上）

现代C++中，我们可以添加移动构造函数和移动赋值运算符来优化性能：

cpp复制// 移动构造函数
MyString::MyString(MyString&& other) noexcept
    : m_data(other.m_data),
      m_length(other.m_length),
      m_capacity(other.m_capacity) {
    other.m_data = nullptr;
    other.m_length = 0;
    other.m_capacity = 0;
}

// 移动赋值运算符
MyString& MyString::operator=(MyString&& other) noexcept {
    if (this != &other) {
        delete[] m_data;
        m_data = other.m_data;
        m_length = other.m_length;
        m_capacity = other.m_capacity;
        
        other.m_data = nullptr;
        other.m_length = 0;
        other.m_capacity = 0;
    }
    return *this;
}

4. 字符串遍历与修改操作

4.1 迭代器实现

为了让我们的MyString支持范围for循环，需要实现基本的迭代器功能：

cpp复制class MyString {
public:
    // 迭代器类型定义
    using iterator = char*;
    using const_iterator = const char*;
    
    iterator begin() { return m_data; }
    iterator end() { return m_data + m_length; }
    const_iterator begin() const { return m_data; }
    const_iterator end() const { return m_data + m_length; }
    const_iterator cbegin() const { return m_data; }
    const_iterator cend() const { return m_data + m_length; }
};

现在可以像标准库string一样使用迭代器了：

cpp复制MyString str("Hello");
for (auto it = str.begin(); it != str.end(); ++it) {
    *it = toupper(*it);  // 修改字符
}

4.2 下标访问运算符

提供两种版本的下标访问运算符：

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

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

4.3 字符串连接操作

实现operator+=和operator+来进行字符串连接：

cpp复制MyString& MyString::operator+=(const MyString& other) {
    size_t new_length = m_length + other.m_length;
    if (new_length + 1 > m_capacity) {  // 需要扩容
        reserve(new_length + 1);  // 预留空间
    }
    strcpy(m_data + m_length, other.m_data);
    m_length = new_length;
    return *this;
}

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

5. 常用接口实现与优化

5.1 内存管理接口

实现reserve和resize等内存管理函数：

cpp复制void MyString::reserve(size_t new_capacity) {
    if (new_capacity <= m_capacity) return;
    
    char* new_data = new char[new_capacity];
    strcpy(new_data, m_data);
    delete[] m_data;
    m_data = new_data;
    m_capacity = new_capacity;
}

void MyString::resize(size_t new_size, char fill_char) {
    if (new_size < m_length) {
        m_data[new_size] = '\0';
        m_length = new_size;
    } else if (new_size > m_length) {
        reserve(new_size + 1);
        for (size_t i = m_length; i < new_size; ++i) {
            m_data[i] = fill_char;
        }
        m_data[new_size] = '\0';
        m_length = new_size;
    }
}

5.2 查找与子串操作

实现find和substr等常用操作：

cpp复制size_t MyString::find(const MyString& substr, size_t pos) const {
    if (substr.m_length == 0) return pos <= m_length ? pos : npos;
    if (pos + substr.m_length > m_length) return npos;
    
    for (size_t i = pos; i <= m_length - substr.m_length; ++i) {
        bool match = true;
        for (size_t j = 0; j < substr.m_length; ++j) {
            if (m_data[i + j] != substr.m_data[j]) {
                match = false;
                break;
            }
        }
        if (match) return i;
    }
    return npos;
}

MyString MyString::substr(size_t pos, size_t len) const {
    if (pos > m_length) throw std::out_of_range("Position out of range");
    
    size_t actual_len = std::min(len, m_length - pos);
    MyString result;
    result.reserve(actual_len + 1);
    strncpy(result.m_data, m_data + pos, actual_len);
    result.m_data[actual_len] = '\0';
    result.m_length = actual_len;
    return result;
}

5.3 流操作符重载

为了支持cout等流操作，需要重载<<运算符：

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

std::istream& operator>>(std::istream& is, MyString& str) {
    char buffer[1024];
    is >> buffer;
    str = MyString(buffer);
    return is;
}

6. 性能优化与边界情况处理

6.1 短字符串优化(SSO)

标准库string通常会实现短字符串优化，我们也来模拟这个特性：

cpp复制class MyString {
private:
    static const size_t SSO_MAX = 15;  // 假设短字符串最大15字符
    union {
        struct {
            char* m_data;
            size_t m_length;
            size_t m_capacity;
        } m_long;  // 长字符串表示
        char m_short[SSO_MAX + 1];  // 短字符串表示(+1给'\0')
    };
    bool m_is_short;  // 标记当前是否为短字符串
    
public:
    // 构造函数需要相应修改
    MyString() : m_is_short(true) {
        m_short[0] = '\0';
    }
    
    // 其他接口也需要适配这种双模式存储
};

6.2 异常安全保证

确保所有操作都提供基本的异常安全保证：

cpp复制void MyString::append(const char* str, size_t len) {
    if (str == nullptr) return;
    
    size_t new_length = m_length + len;
    if (new_length + 1 > capacity()) {
        size_t new_capacity = calculate_new_capacity(new_length + 1);
        char* new_data = new (std::nothrow) char[new_capacity];
        if (!new_data) throw std::bad_alloc();
        
        // 先拷贝原有数据
        if (m_data) {
            memcpy(new_data, m_data, m_length);
            delete[] m_data;
        }
        m_data = new_data;
        m_capacity = new_capacity;
    }
    
    // 再追加新数据
    memcpy(m_data + m_length, str, len);
    m_length = new_length;
    m_data[m_length] = '\0';
}

6.3 性能测试与优化建议

在实际项目中，我们可以通过以下方式优化string类性能：

1. 预分配策略：当需要扩容时，不是刚好分配所需大小，而是按一定比例(如1.5倍或2倍)扩容，减少频繁重新分配
2. 移动语义：确保实现了移动构造函数和移动赋值运算符
3. 内联小函数：对于size()、empty()等简单函数声明为inline
4. 避免不必要的拷贝：使用const引用传递参数
5. 内存池：对于频繁创建销毁的字符串对象，可以考虑使用内存池技术

7. 与现代C++特性的结合

7.1 支持初始化列表

让我们的MyString支持花括号初始化：

cpp复制MyString::MyString(std::initializer_list<char> il) {
    m_length = il.size();
    m_capacity = m_length + 1;
    m_data = new char[m_capacity];
    std::copy(il.begin(), il.end(), m_data);
    m_data[m_length] = '\0';
}

7.2 添加noexcept说明

为不会抛出异常的函数添加noexcept说明：

cpp复制size_t MyString::size() const noexcept { return m_length; }
bool MyString::empty() const noexcept { return m_length == 0; }

7.3 实现用户定义字面量

添加对字符串字面量的支持：

cpp复制MyString operator"" _mys(const char* str, size_t len) {
    return MyString(str, len);
}

使用方式：

cpp复制auto str = "Hello"_mys;  // 创建MyString对象

8. 测试策略与常见问题排查

8.1 单元测试要点

为我们的MyString类设计全面的测试用例：

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

void test_assignment() {
    MyString s1("hello");
    MyString s2;
    s2 = s1;  // 赋值操作
    assert(s2.size() == 5);
    assert(s1.c_str() != s2.c_str());  // 确保深拷贝
}

// 其他测试函数...

8.2 内存泄漏检测

使用工具如Valgrind或AddressSanitizer检测内存问题：

bash复制valgrind --leak-check=full ./test_my_string

8.3 常见问题排查

1. 野指针问题：确保在析构函数中释放内存，在移动操作后将源对象置空
2. 缓冲区溢出：所有涉及内存操作的地方都要检查边界
3. 自赋值问题：赋值运算符必须处理对象给自己赋值的情况
4. 异常安全：确保在异常发生时不会泄漏资源或破坏数据一致性

9. 与标准库string的对比与扩展思考

9.1 功能对比

我们的MyString实现了标准库string的核心功能，但缺少一些高级特性：

9.2 可能的扩展方向

1. 支持自定义分配器
2. 添加对Unicode和多字节编码的支持
3. 实现字符串视图(String View)功能
4. 添加正则表达式匹配功能
5. 支持格式化操作(类似sprintf)
6. 实现线程安全版本

在实现这些扩展时，需要注意保持接口的一致性和性能的平衡。比如添加Unicode支持可能会显著增加复杂度，而线程安全版本则可能影响单线程使用时的性能。