1. 项目概述：为什么我们要亲手实现一个String类？

在C++的世界里，std::string几乎是每个开发者每天都要打交道的对象。从简单的日志打印到复杂的文本处理，它无处不在。很多朋友，尤其是刚入门的C++学习者，往往满足于调用它的size()、append()、find()这些接口，觉得会用就行了。但如果你只停留在“会用”的层面，那么你对内存管理、拷贝控制、异常安全这些C++核心概念的理解，就永远隔着一层毛玻璃。

亲手模拟实现一个String类，远不止是为了应付面试官那几个经典的“深拷贝浅拷贝”问题。它是一个绝佳的练手项目，能强迫你去思考：当你在写str1 = str2时，底层究竟发生了什么？str1 + str2这个看似简单的操作，背后隐藏着多少次内存分配和拷贝？为什么有些操作会抛出异常，而有些不会？通过这个项目，你会把《C++ Primer》里那些抽象的理论——构造函数、析构函数、拷贝构造、拷贝赋值、移动语义、操作符重载——全部串联起来，并在内存的“战场”上真刀真枪地演练一遍。我当年就是在实现自己的String类之后，才对“资源管理”和“RAII”有了刻骨铭心的理解。你会发现，之前很多模糊的、靠死记硬背的规则，突然变得清晰且理所当然。

接下来，我将带你从零开始，构建一个我们自己的MyString类。我们会遵循现代C++（C++11及以后）的最佳实践，不仅实现基本功能，还会深入探讨性能优化和异常安全的边界。最终，你会得到一份可以直接编译、测试的完整源码，更重要的是，获得一套解决类似资源管理问题的“肌肉记忆”。

2. 整体设计与核心思路拆解

在动手写代码之前，我们必须先想清楚这个类的骨架和灵魂。一个健壮的String类，核心是管理一块动态分配的、用于存储字符序列的堆内存。这引出了三个最根本的设计决策。

2.1 底层存储结构的选择

首先，我们用什么来存字符？最简单的想法是直接用char*指针。这没错，但它太“原始”了，我们需要自己记录字符串的长度和容量。更现代、更高效的做法是采用类似std::string的“短字符串优化”（SSO）策略，但对于我们的教学实现，先从char*开始更能看清本质。

因此，我们的类至少需要三个成员变量：

• char* m_data: 指向堆上字符数组的指针，以\0结尾。
• size_t m_size: 当前字符串的实际长度（不包括结尾的\0）。
• size_t m_capacity: 当前已分配内存能容纳的字符数（至少为m_size）。

为什么需要m_capacity？这是为了优化。如果每次添加字符都重新分配内存，性能会惨不忍睹。我们采用“倍增”策略预留一些额外空间，减少内存分配的频率。

2.2 “六大金刚”：必不可少的成员函数

这是C++类的基石，对于管理资源的类尤为重要：

1. 构造函数：包括默认构造、从C风格字符串构造、从字符个数构造。
2. 析构函数：必须释放m_data指向的动态内存，防止内存泄漏。
3. 拷贝构造函数：实现“深拷贝”。当用一个MyString对象初始化另一个时，必须分配新内存并复制内容，而不是简单拷贝指针。
4. 拷贝赋值运算符：这是坑最多的地方。必须正确处理自赋值（str = str），并且通常要提供强异常安全保证。
5. 移动构造函数（C++11）：“窃取”右值对象的资源，将其置为空状态，高效且无拷贝。
6. 移动赋值运算符（C++11）：同理，高效地接管右值对象的资源。

后四个函数就是著名的“三/五法则”：如果一个类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，那么它很可能全部都需要。

2.3 接口设计：实用性与STL风格

我们的接口应该向std::string看齐，这有助于使用者无缝切换。主要分为几类：

• 容量相关：size(),capacity(),empty(),reserve(),shrink_to_fit()。
• 元素访问：operator[]（重载const和非const版本），at()（进行边界检查）。
• 修改操作：append(),operator+=,insert(),erase(),clear()。
• 字符串操作：c_str(),find(),substr()。
• 非成员函数：流操作符<<和>>， 比较运算符==,!=,<等。

设计时，要时刻考虑异常安全。例如，在reserve()或append()中，如果内存分配失败，我们的类对象应该保持原有状态不变。

3. 核心实现细节与难点剖析

理论说再多不如看代码。我们现在深入几个最核心、最容易出错的函数实现。

3.1 构造、拷贝与析构：资源管理的生命线

class MyString { public: // 1. 默认构造函数 MyString() : m_data(new char[1]), m_size(0), m_capacity(0) { m_data[0] = '\0'; } // 2. 从C风格字符串构造 MyString(const char* str) { if (str == nullptr) { m_data = new char[1]; m_data[0] = '\0'; m_size = m_capacity = 0; } else { m_size = strlen(str); m_capacity = m_size; m_data = new char[m_capacity + 1]; // +1 for '\0' strcpy(m_data, str); } } // 3. 拷贝构造函数（深拷贝） MyString(const MyString& other) : m_size(other.m_size), m_capacity(other.m_capacity) { m_data = new char[m_capacity + 1]; strcpy(m_data, other.m_data); // 安全，因为other保证以'\0'结尾 } // 4. 析构函数 ~MyString() { delete[] m_data; // 对数组使用 delete[] m_data = nullptr; // 一个好习惯，防止悬空指针 } private: char* m_data; size_t m_size; size_t m_capacity; };

注意：在拷贝构造函数中，我们直接复制了m_capacity而不是m_size。这是因为我们假设原对象可能预留了空间，拷贝时我们选择保持相同的容量策略，避免立即触发扩容。这是一种设计选择，你也可以选择只分配m_size + 1的内存。

3.2 拷贝赋值运算符：异常安全的关键

这是“三/五法则”中最需要技巧的部分。一个朴素但错误的实现是：

// 错误示范！缺乏自赋值检查和异常安全 MyString& operator=(const MyString& other) { delete[] m_data; // 1. 先释放自己的内存 m_size = other.m_size; m_capacity = other.m_capacity; m_data = new char[m_capacity + 1]; // 2. 分配新内存 strcpy(m_data, other.m_data); // 3. 拷贝数据 return *this; }

这个实现有两个致命问题：

1. 自赋值问题：如果other就是自己（str = str），第一步delete[] m_data就把自己的内存释放了，第三步strcpy就是在拷贝已被释放的垃圾数据。
2. 异常不安全：如果第二步new分配内存失败，抛出了std::bad_alloc异常，那么此函数会退出，但*this对象的状态已经被破坏（内存已释放，指针悬空）。这违反了强异常安全保证（操作要么完全成功，要么对象状态保持不变）。

正确的实现采用“拷贝并交换”（copy-and-swap） idiom，或者先分配后释放：

// 正确实现：提供强异常安全保证 MyString& operator=(const MyString& other) { if (this != &other) { // 1. 自赋值检查 char* new_data = new char[other.m_capacity + 1]; // 2. 先分配新内存 strcpy(new_data, other.m_data); // 3. 拷贝数据（可能抛异常，但此时原对象未变） // 4. 以下操作不会抛异常 delete[] m_data; m_data = new_data; m_size = other.m_size; m_capacity = other.m_capacity; } return *this; }

这个版本中，如果new或strcpy抛出异常，函数会在此处退出，而*this的原始内存和数据都完好无损，满足了强异常安全。

3.3 移动语义：性能优化的利器（C++11）

移动构造函数和移动赋值运算符是C++11引入的，用于高效转移资源所有权，避免不必要的深拷贝。

// 5. 移动构造函数 MyString(MyString&& other) noexcept // 标记为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; } // 6. 移动赋值运算符 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; }

移动操作后，被移动的对象（other）应处于一个有效但内容未定义的状态（通常为空）。将其成员置零或置空是良好实践。标记为noexcept可以允许像std::vector::push_back这样的操作在扩容时使用移动而非拷贝，从而提升性能。

4. 关键功能实现与扩容策略

有了基础框架，我们来实现最常用的修改操作：append和push_back。它们的核心都绕不开内存管理。

4.1 内存管理：reserve 与 resize

首先，我们需要一个内部工具函数来管理容量：

void MyString::reserve(size_t new_capacity) { if (new_capacity <= m_capacity) { return; // 无需扩容 } // 通常采用倍增策略，避免频繁分配 size_t actual_new_capacity = m_capacity; if (actual_new_capacity == 0) { actual_new_capacity = 1; } while (actual_new_capacity < new_capacity) { actual_new_capacity *= 2; // 倍增因子可以是1.5或2，2更常见 } char* new_data = new char[actual_new_capacity + 1]; strcpy(new_data, m_data); // 拷贝原有数据 delete[] m_data; m_data = new_data; m_capacity = actual_new_capacity; // m_size 不变 }

reserve()只影响容量，不影响字符串内容。resize()则会改变m_size，并可能填充新字符或截断字符串。

4.2 append 与 operator+= 的实现

append是许多操作的基础。我们实现一个追加C风格字符串的版本：

MyString& MyString::append(const char* str) { if (str == nullptr) return *this; size_t append_len = strlen(str); if (append_len == 0) return *this; size_t new_size = m_size + append_len; if (new_size > m_capacity) { reserve(new_size); // 触发扩容 } strcpy(m_data + m_size, str); // 从原字符串结尾开始拷贝 m_size = new_size; // m_data[m_size] 已经是 '\0'，因为strcpy会复制结束符 return *this; } // operator+= 可以方便地基于 append 实现 MyString& MyString::operator+=(const char* str) { return append(str); } MyString& MyString::operator+=(const MyString& str) { return append(str.c_str()); }

4.3 插入与删除：iterator 的考量

insert和erase是更复杂的操作，因为它们涉及内存中元素的移动。一个健壮的insert需要处理位置校验、容量检查和数据搬移。

MyString& MyString::insert(size_t pos, const char* str) { if (pos > m_size) { throw std::out_of_range("MyString::insert position out of range"); } size_t insert_len = strlen(str); size_t new_size = m_size + insert_len; if (new_size > m_capacity) { reserve(new_size); } // 将pos之后的原有数据向后移动insert_len个位置 // 注意：memmove 可以处理内存重叠区域，memcpy不行 memmove(m_data + pos + insert_len, m_data + pos, m_size - pos + 1); // +1 为了移动结尾的'\0' // 插入新数据 memcpy(m_data + pos, str, insert_len); m_size = new_size; return *this; }

erase的实现类似，但方向相反，是将后面的数据向前移动覆盖要删除的部分。

实操心得：在实现insert和erase时，使用memmove而非memcpy是至关重要的，因为源内存和目标内存可能存在重叠。memcpy对重叠区域的行为是未定义的，会导致数据错误。

5. 完整源码与关键测试用例

由于篇幅所限，这里给出核心类的骨架和部分关键实现。完整源码会包含所有上述函数以及find,substr, 比较运算符，流操作符等。

// MyString.h #ifndef MYSTRING_H #define MYSTRING_H #include <iostream> #include <cstring> #include <stdexcept> #include <utility> class MyString { public: // 类型别名，模仿STL using size_type = size_t; // 1. 构造与析构 MyString(); explicit MyString(const char* str); MyString(const MyString& other); // 拷贝构造 MyString(MyString&& other) noexcept; // 移动构造 ~MyString(); // 2. 赋值操作 MyString& operator=(const MyString& other); // 拷贝赋值 MyString& operator=(MyString&& other) noexcept; // 移动赋值 MyString& operator=(const char* str); // 3. 容量 size_type size() const { return m_size; } size_type capacity() const { return m_capacity; } bool empty() const { return m_size == 0; } void reserve(size_type new_cap); void shrink_to_fit(); // 4. 元素访问 char& operator[](size_type pos); const char& operator[](size_type pos) const; char& at(size_type pos); const char& at(size_type pos) const; const char* c_str() const { return m_data; } const char* data() const { return m_data; } // 5. 修改操作 MyString& append(const char* str); MyString& append(const MyString& str); void push_back(char ch); MyString& insert(size_type pos, const char* str); MyString& insert(size_type pos, const MyString& str); MyString& erase(size_type pos, size_type count = npos); void clear(); void resize(size_type new_size, char ch = '\0'); // 6. 字符串操作 int compare(const MyString& str) const; MyString substr(size_type pos, size_type count = npos) const; size_type find(const char* str, size_type pos = 0) const; // 7. 操作符重载 MyString& operator+=(const char* str); MyString& operator+=(const MyString& str); friend bool operator==(const MyString& lhs, const MyString& rhs); friend bool operator!=(const MyString& lhs, const MyString& rhs); friend bool operator<(const MyString& lhs, const MyString& rhs); friend std::ostream& operator<<(std::ostream& os, const MyString& str); friend std::istream& operator>>(std::istream& is, MyString& str); private: char* m_data; size_type m_size; size_type m_capacity; static const size_type npos = -1; // 类似std::string::npos // 内部辅助函数 void _reallocate(size_type new_capacity); }; // 非成员比较运算符等实现... #endif // MYSTRING_H

对应的MyString.cpp需要实现上述所有函数体。测试是验证实现正确性的关键。你应该编写全面的测试用例：

// test_mystring.cpp #include "MyString.h" #include <cassert> #include <iostream> void test_construction() { MyString s1; // 默认构造 assert(s1.size() == 0); assert(std::strcmp(s1.c_str(), "") == 0); MyString s2("Hello"); // 从C字符串构造 assert(s2.size() == 5); assert(std::strcmp(s2.c_str(), "Hello") == 0); MyString s3(s2); // 拷贝构造 assert(s3.size() == s2.size()); assert(std::strcmp(s3.c_str(), s2.c_str()) == 0); assert(s3.c_str() != s2.c_str()); // 必须是深拷贝，指针地址不同 MyString s4(std::move(s2)); // 移动构造 assert(s4.size() == 5); assert(s2.size() == 0); // s2被移空 assert(s2.c_str() != nullptr && std::strcmp(s2.c_str(), "") == 0); } void test_assignment() { MyString s1("Hello"); MyString s2; s2 = s1; // 拷贝赋值 assert(s2 == s1); s1 = s1; // 自赋值，必须安全 assert(s1 == MyString("Hello")); MyString s3("World"); MyString s4; s4 = std::move(s3); // 移动赋值 assert(s4 == "World"); assert(s3.empty() || std::strcmp(s3.c_str(), "") == 0); // s3状态有效但未指定 } void test_modifications() { MyString s("Hello"); s.append(" World"); assert(s == "Hello World"); s.insert(6, "Beautiful "); assert(s == "Hello Beautiful World"); s.erase(6, 10); // 删除"Beautiful " assert(s == "Hello World"); s.clear(); assert(s.empty()); } void test_operations() { MyString s1("Hello"); MyString s2("World"); MyString s3 = s1 + " " + s2; assert(s3 == "Hello World"); assert(s1.find("ll") == 2); assert(s1.find("z") == MyString::npos); MyString sub = s3.substr(6, 5); assert(sub == "World"); } int main() { test_construction(); test_assignment(); test_modifications(); test_operations(); std::cout << "All tests passed!\n"; return 0; }

6. 常见问题、调试技巧与性能思考

即使实现了所有功能，在实际使用和调试中还是会遇到各种问题。这里记录几个我踩过的坑和调试技巧。

6.1 典型问题排查清单

6.2 调试工具与技巧

• GDB/LLDB：在关键函数入口设置断点，观察m_data指针地址和指向的内容，检查m_size和m_capacity的值是否符合预期。
• Valgrind：这是检测内存泄漏、非法内存访问的利器。编译时加上-g选项，用valgrind --leak-check=full ./your_program运行测试用例。
• AddressSanitizer (ASan)：在GCC/Clang中通过-fsanitize=address编译，可以在运行时快速检测出越界、释放后使用等问题。
• 打印日志：在拷贝构造、赋值、析构等函数中加入简单的日志输出，跟踪对象的生命周期和资源转移。

6.3 进阶思考：与 std::string 的差距

我们的MyString是一个教学实现，与成熟的std::string（如GCC的libstdc++或Clang的libcxx实现）相比，还有巨大差距：

1. 短字符串优化（SSO）：现代std::string对于短字符串（通常<=15或23字节）直接将其存储在对象内部的缓冲区中，避免堆内存分配，极大提升了小字符串的性能。这需要更复杂的内存布局判断。
2. 引用计数与写时复制（Copy-On-Write）：一些旧版标准库实现采用COW来优化拷贝性能，但它在多线程环境下需要原子操作，且与C++11的迭代器失效规则有冲突，因此现代实现已较少使用。
3. 更精细的异常安全：所有操作都提供最强的异常安全保证。
4. 完善的迭代器支持：提供iterator和const_iterator，能与STL算法无缝协作。
5. 分配器支持：允许用户自定义内存分配策略。

实现这个基础的MyString后，如果你有兴趣，可以尝试挑战SSO优化，这将让你对内存对齐、类型双关、条件存储有更深的理解。这就像练武，先扎好马步（掌握基础的内存管理和拷贝控制），再去修炼上乘武功（学习高级优化技巧）。整个过程下来，你再去看std::string的源码，或者面试时被问到相关八股文，心里都会非常有底。