从零实现C++ String类：掌握深拷贝、移动语义与内存管理核心

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

如果你正在学习C++，或者准备面试，那么“实现一个String类”几乎是绕不开的经典题目。这不仅仅是因为std::string是C++标准库中使用频率最高的组件之一，更是因为通过亲手实现它，你能把C++中面向对象、资源管理、运算符重载、拷贝控制等核心概念串联起来，形成一个深刻而牢固的理解。市面上的教程和面试八股文很多，但大多只给出一个骨架代码，对于“为什么这么写”、“不这么写会怎样”的细节语焉不详。结果就是，你背下了代码，却依然在复杂的项目内存管理中踩坑。

这个项目的目的，就是带你从零开始，完整地实现一个工业级别的MyString类。我们不满足于一个能跑通的Demo，而是要深入到每一个设计决策的背后，探讨标准库可能采用的策略，并直面那些在面试和实际开发中高频出现的问题。比如，为什么拷贝构造要区分深拷贝和浅拷贝？移动语义是如何提升性能的？reserve()和resize()到底有什么区别？写时拷贝（Copy-On-Write）现在还流行吗？通过回答这些问题，你将真正“吃透”String类，进而掌握C++资源管理的精髓。

2. 核心设计思路与类框架定义

在动手写第一行代码之前，我们必须明确设计目标。一个基本的字符串类需要管理一段动态分配的字符数组（char*），并记录其长度和容量。这引出了我们的核心数据成员。

2.1 数据成员的选择与内存布局

最直观的成员是：char* m_data（指向堆内存的指针）、size_t m_size（当前字符串长度，不含结尾的\0）、size_t m_capacity（当前分配的内存容量，通常>=m_size+1）。这是最常见的设计，清晰易懂。

但标准库的实现可能更高效。一种常见的优化是“短字符串优化”（SSO）。对于很短的字符串（例如15个字符以内），直接将其存储在对象内部的缓冲区中，避免一次堆内存分配的开销。这对于大量短字符串存在的场景（如解析文本、属性键值对）性能提升显著。为了教学清晰，我们第一个版本先实现标准的三成员设计，在后续优化章节再引入SSO。

基于此，我们的类框架雏形如下：

class MyString { public: // 构造函数族 MyString(); // 默认构造 MyString(const char* str); // C风格字符串构造 MyString(const MyString& other); // 拷贝构造 MyString(MyString&& other) noexcept; // 移动构造 (C++11) // 析构函数 ~MyString(); // 赋值运算符 MyString& operator=(const MyString& other); // 拷贝赋值 MyString& operator=(MyString&& other) noexcept; // 移动赋值 (C++11) // 其他成员函数... private: char* m_data; // 指向动态分配的字符数组 size_t m_size; // 当前字符串长度（不包含结尾的'\0'） size_t m_capacity; // 当前分配的内存容量（包含结尾的'\0'的位置） };

为什么选择size_t？size_t是一个无符号整数类型，它被设计用来表示对象的大小或数组的索引。对于表示长度和容量，使用无符号数可以避免负数的无意义情况，并且它的宽度足以表示系统中可能存在的最大对象，是C++标准库容器（如std::vector,std::string）的一致选择。

2.2 关键设计决策：深拷贝与浅拷贝

这是String类实现中最核心的概念，也是面试必考点。浅拷贝只复制指针的值，使得两个对象指向同一块内存。这会导致双重释放（double-free）和悬垂指针（dangling pointer）等致命错误。深拷贝则是为新的对象分配独立的内存，并将原内存的内容复制过去。我们的拷贝构造函数和拷贝赋值运算符必须实现深拷贝。

// 错误的浅拷贝行为（编译器生成的默认拷贝构造即如此） MyString a("hello"); MyString b = a; // 浅拷贝：b.m_data 和 a.m_data 指向同一地址 // 当a和b析构时，同一块内存会被释放两次，程序崩溃！

因此，我们必须手动实现拷贝控制成员（拷贝构造、拷贝赋值、析构），这就是著名的“三/五法则”。在C++11后，加上移动构造和移动赋值，成为“五法则”。

3. 基础成员函数的实现与深坑规避

让我们从构造函数和析构函数开始，这是资源管理的起点和终点。

3.1 构造函数与析构函数实现

默认构造函数需要创建一个合法的空字符串。空字符串不等于nullptr，它应该是一个包含结束符\0的有效C风格字符串。

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

注意：这里为m_data分配了1个字节，用于存放\0。m_capacity初始为1，表示当前内存刚好能容纳一个空字符串。这是正确的做法。一个常见的错误是让m_data为nullptr，但这会导致后续strlen或cout等操作失败。

从C字符串构造是最常用的构造函数。我们需要计算传入字符串的长度，分配足够的内存（长度+1用于\0），然后进行拷贝。

MyString::MyString(const char* str) { if (str == nullptr) { // 处理空指针输入，防御性编程 m_data = new char[1]; m_data[0] = '\0'; m_size = 0; m_capacity = 1; } else { m_size = strlen(str); m_capacity = m_size + 1; m_data = new char[m_capacity]; strcpy(m_data, str); // 或者用更安全的 memcpy(m_data, str, m_size + 1); } }

实操心得：使用strcpy是简洁的，但它要求目标缓冲区足够大，这在我们分配后是满足的。在生产代码中，可能会使用memcpy或std::copy来避免对源字符串进行二次遍历（strcpy需要找结束符），但差别微乎其微。关键在于，一定要分配m_size + 1的空间。

析构函数的责任是释放构造函数中分配的资源。

MyString::~MyString() { delete[] m_data; // 一定要用 delete[] 来匹配 new char[] m_data = nullptr; // 一个好习惯，防止悬垂指针，虽然对象即将销毁 m_size = m_capacity = 0; }

踩过的坑：new[]必须用delete[]释放，如果用delete，行为是未定义的，通常会导致内存泄漏或崩溃。将指针置为nullptr在析构中不是必须的，但这是一个清晰的代码习惯。

3.2 拷贝构造与拷贝赋值：实现深拷贝

拷贝构造函数：创建一个新对象，它是现有对象的完整独立副本。

MyString::MyString(const MyString& other) : m_size(other.m_size), m_capacity(other.m_capacity) { m_data = new char[m_capacity]; memcpy(m_data, other.m_data, m_size + 1); // 连同'\0'一起拷贝 }

这里使用了memcpy，因为它比循环赋值或strcpy更高效，且我们已知需要拷贝的字节数（m_size + 1）。

拷贝赋值运算符：这是实现中最容易出错的部分。它需要处理自赋值（a = a），并保证异常安全。

MyString& MyString::operator=(const MyString& other) { // 1. 防止自赋值 if (this == &other) { return *this; } // 2. 分配新内存（可能失败会抛异常） char* new_data = new char[other.m_capacity]; // 3. 拷贝数据 memcpy(new_data, other.m_data, other.m_size + 1); // 4. 释放旧内存 delete[] m_data; // 5. 接管新资源 m_data = new_data; m_size = other.m_size; m_capacity = other.m_capacity; return *this; }

为什么这个顺序是异常安全的？核心思想是“先分配新资源，再释放旧资源”。如果在new的时候失败了（内存不足），它会抛出std::bad_alloc异常。此时旧对象的m_data还没有被释放，对象仍然保持有效状态，满足了“异常安全”的强保证。如果先delete[] m_data再new，一旦new失败，对象将持有一个无效的指针，状态被破坏。

一个更简洁的拷贝赋值写法（copy-and-swap惯用法）：

MyString& MyString::operator=(const MyString& other) { MyString temp(other); // 调用拷贝构造，创建副本 swap(*this, temp); // 交换当前对象和副本的内容 return *this; // 副本（现在持有旧资源）离开作用域被销毁 } // 需要实现一个swap成员函数或友元函数 void swap(MyString& a, MyString& b) noexcept { using std::swap; swap(a.m_data, b.m_data); swap(a.m_size, b.m_size); swap(a.m_capacity, b.m_capacity); }

这种方法异常安全性高，代码简洁，且自动处理了自赋值（因为创建了临时对象）。是现代C++中推荐的方式。

4. 移动语义与现代C++优化

C++11引入的移动语义是为了避免不必要的深拷贝，提升性能。对于MyString这样的资源管理类，实现移动操作至关重要。

4.1 移动构造函数与移动赋值运算符

移动操作“窃取”右值（临时对象）的资源，而不是复制它们。被移动后的源对象应处于一个有效但不确定的状态（通常为空）。

// 移动构造函数 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) { return *this; } // 释放当前资源 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. 参数：MyString&&表示右值引用。
2. noexcept：标记为不抛出异常。这非常重要，因为标准库容器（如std::vector）在重新分配内存时，如果元素的移动构造函数是noexcept的，它会使用移动而不是拷贝来提升效率。
3. 置空源对象：必须将源对象的指针置为nullptr，这样它的析构函数delete[] nullptr（是安全的）就不会释放我们已经窃取的内存。

4.2 移动语义带来的性能提升场景

MyString createString() { MyString s("这是一个很长的临时字符串..."); return s; // 此处可能触发NRVO（返回值优化），否则会调用移动构造 } int main() { MyString str1 = createString(); // 移动构造发生，零拷贝！ MyString str2 = std::move(str1); // 显式移动，str1现在为空 std::vector<MyString> vec; vec.push_back(MyString("临时对象")); // push_back会调用移动构造（如果可用） }

有了移动语义后，返回局部对象、插入临时对象到容器等操作的开销大大降低。

5. 核心功能实现：模拟std::string的常用接口

现在来实现一些让这个类真正有用的成员函数。

5.1 容量相关操作：size,capacity,reserve,resize

size_t MyString::size() const { return m_size; } size_t MyString::capacity() const { return m_capacity; } bool MyString::empty() const { return m_size == 0; } void MyString::reserve(size_t new_capacity) { if (new_capacity <= m_capacity) { return; // 缩容请求通常被忽略（标准库行为） } // 分配新内存 char* new_data = new char[new_capacity]; // 拷贝现有数据（包括'\0'） memcpy(new_data, m_data, m_size + 1); // 释放旧内存 delete[] m_data; // 更新指针和容量 m_data = new_data; m_capacity = new_capacity; } void MyString::resize(size_t new_size, char ch = '\0') { if (new_size <= m_size) { // 缩小：直接截断，设置新的结束符 m_size = new_size; m_data[m_size] = '\0'; } else { // 扩大：可能需要扩容 reserve(new_size + 1); // +1 for '\0' // 用字符ch填充新增的空间 for (size_t i = m_size; i < new_size; ++i) { m_data[i] = ch; } m_size = new_size; m_data[m_size] = '\0'; // 确保结束符 } }

reservevsresize核心区别：

• reserve(n)：只影响容量（capacity）。它保证内存至少可以容纳n个字符（实际是n个char，为\0预留空间由实现管理）。它不改变字符串内容或大小（size）。用于提前分配内存，避免多次push_back导致的重复分配。
• resize(n, ch)：直接改变字符串的大小（size）。如果n > size()，则用字符ch填充新增部分；如果n < size()，则截断。它可能改变容量（如果需要扩容）。

5.2 元素访问：operator[],at,front,back,c_str,data

// 不检查下标的访问（类似std::string::operator[]） char& MyString::operator[](size_t pos) { // 通常不进行边界检查，追求性能 return m_data[pos]; } const char& MyString::operator[](size_t pos) const { return m_data[pos]; } // 进行边界检查的访问（类似std::string::at） char& MyString::at(size_t pos) { if (pos >= m_size) { throw std::out_of_range("MyString::at index out of range"); } return m_data[pos]; } const char& MyString::at(size_t pos) const { if (pos >= m_size) { throw std::out_of_range("MyString::at index out of range"); } return m_data[pos]; } // 首尾字符 char& MyString::front() { return m_data[0]; } const char& MyString::front() const { return m_data[0]; } char& MyString::back() { return m_data[m_size - 1]; } const char& MyString::back() const { return m_data[m_size - 1]; } // 返回C风格字符串指针 const char* MyString::c_str() const { return m_data; } const char* MyString::data() const { return m_data; } // C++17前，data()返回的数组不一定以'\0'结尾，但我们这里简单实现为与c_str相同。

注意：operator[]的const重载版本是必须的，它允许在const MyString对象上使用下标操作。

5.3 修改操作：append,operator+=,clear

// 追加C风格字符串 MyString& MyString::append(const char* str) { if (str == nullptr) return *this; size_t len = strlen(str); if (len == 0) return *this; // 检查容量是否足够 if (m_size + len + 1 > m_capacity) { // 常见的增长策略：翻倍或增加固定值，这里使用翻倍策略 size_t new_cap = (m_capacity == 0) ? (len + 1) : (m_capacity * 2); while (m_size + len + 1 > new_cap) { new_cap *= 2; } reserve(new_cap); } // 追加数据 memcpy(m_data + m_size, str, len + 1); // 拷贝字符串内容及结尾的\0 m_size += len; return *this; } // 追加另一个MyString MyString& MyString::append(const MyString& str) { return append(str.c_str()); } // 重载 += 运算符 MyString& MyString::operator+=(const char* str) { return append(str); } MyString& MyString::operator+=(const MyString& str) { return append(str); } // 清空字符串 void MyString::clear() { m_size = 0; m_data[0] = '\0'; // 注意：clear()通常不释放内存（不改变capacity），这是标准库行为。 }

内存增长策略：在append中，当容量不足时，我们采用了常见的“翻倍”策略。这摊还了多次追加操作的内存分配成本，使得单次append操作的平均时间复杂度接近O(1)。这是std::vector和std::string等容器常用的策略。

5.4 非成员函数：流操作符和加法运算符

为了让MyString用起来更自然，我们需要重载<<和>>流操作符，以及+运算符。

// 输出流 std::ostream& operator<<(std::ostream& os, const MyString& str) { os << str.c_str(); return os; } // 输入流（简化版，读取一个单词） std::istream& operator>>(std::istream& is, MyString& str) { str.clear(); // 先清空目标字符串 char ch; // 跳过开头的空白字符 while (is.get(ch) && std::isspace(ch)) {} if (!is) return is; // 读取失败 // 将第一个非空白字符放回 is.unget(); // 读取直到遇到空白字符 while (is.get(ch) && !std::isspace(ch)) { str += ch; // 使用我们实现的+= } return is; } // 加法运算符，通常实现为非成员函数以支持左右操作数类型对称 MyString operator+(const MyString& lhs, const MyString& rhs) { MyString result(lhs); // 拷贝构造左操作数 result.append(rhs); // 追加右操作数 return result; // 依赖返回值优化或移动语义 } MyString operator+(const MyString& lhs, const char* rhs) { MyString result(lhs); result.append(rhs); return result; } MyString operator+(const char* lhs, const MyString& rhs) { MyString result(lhs); result.append(rhs); return result; }

提示：operator+通常返回一个新对象，因此会涉及拷贝。在C++11以后，返回值优化（RVO）和移动语义会极大地优化这个过程，使得str3 = str1 + str2这样的写法效率很高。

6. 高级话题与性能优化探索

实现基础功能后，我们可以探讨一些更深入的话题，这些是区分普通实现和高质量实现的关键。

6.1 短字符串优化（SSO）的实现思路

SSO是一种空间换时间的优化。其核心思想是：在MyString对象内部预留一个固定大小的缓冲区（例如16字节）。当字符串长度小于等于这个缓冲区大小时，直接将字符串存储在这个缓冲区里，而不去堆上分配内存。

这需要改变我们的数据成员布局：

class MyString { private: static const size_t SSO_BUFFER_SIZE = 16; // 假设短字符串容量为15（+1个\0） union { struct { char* m_data; size_t m_size; size_t m_capacity; } m_long; // 长字符串表示 char m_short[SSO_BUFFER_SIZE]; // 短字符串缓冲区 }; bool m_is_short; // 一个标志位，表示当前是短模式还是长模式 // 或者更巧妙的方法：利用capacity的最高位作为标志位 };

实现要点：

1. 判别标志：需要一种方法快速判断当前是短模式还是长模式。可以用一个单独的bool成员，也可以利用capacity的最高位（因为容量值很大，最高位通常为0）。
2. 内存布局：使用union来让长字符串的指针和短字符串的缓冲区共享同一块内存。注意，union中的对象有非平凡构造函数/析构函数时，需要手动管理。
3. 操作重写：几乎所有成员函数（构造、拷贝、赋值、修改、访问）都需要根据m_is_short进行分支处理。
4. 性能收益：对于大量短字符串操作（如解析JSON、HTTP头），避免了堆内存分配/释放的开销，性能提升显著。

由于实现较为复杂，它完美地考察了对C++内存布局、联合体（union）和位操作的理解。

6.2 写时拷贝（Copy-On-Write）的利弊

写时拷贝是另一种优化技术：当多个对象共享同一份字符串数据时，只有在某个对象需要修改数据时，才真正执行拷贝操作。这可以减少不必要的深拷贝。

基本实现：需要一个引用计数（reference count），与字符串数据一起分配。

class MyString { private: struct StringData { char* m_data; size_t m_size; size_t m_capacity; std::atomic<int> m_refcount; // 引用计数，需线程安全 }; StringData* m_ptr; };

操作逻辑：

• 拷贝构造/赋值：不分配新内存，只复制m_ptr，并将引用计数加1。
• 修改操作（如operator[]返回非const引用、append）：检查引用计数。如果计数大于1，说明有共享，则执行真正的深拷贝（分配新内存，复制数据，将引用计数置为1），然后进行修改。

为什么现代C++标准库（如libc++, libstdc++）默认不再使用COW？

1. 线程安全问题：在多线程环境下，对引用计数的读写需要原子操作，带来开销。而std::string要求从C++11开始，并发读取是安全的，但并发读写可能导致数据竞争。COW在并发修改时行为复杂。
2. 移动语义的兴起：C++11的移动语义以极低成本解决了临时对象拷贝的问题，很多原本COW的优化场景被移动语义更优雅地替代。
3. “失效”规则的复杂性：COW使得迭代器、指针的失效规则变得非常复杂，不利于程序员理解和编译器优化。

因此，虽然COW是一个有趣的思想实验，但在现代C++中，SSO结合移动语义是更主流和推荐的优化方向。

6.3 迭代器支持

为了让MyString能与标准库算法（如std::sort,std::find）协同工作，我们需要定义迭代器类型。最简单的方法是直接使用指针作为迭代器。

class MyString { public: using iterator = char*; using const_iterator = const char*; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; iterator begin() { return m_data; } iterator end() { return m_data + m_size; } const_iterator begin() const { return m_data; } const_iterator end() const { return m_data + m_size; } const_iterator cbegin() const { return m_data; } const_iterator cend() const { return m_data + m_size; } // 反向迭代器略... };

有了迭代器，你就可以这样使用：

MyString str("Hello World"); for (auto it = str.begin(); it != str.end(); ++it) { *it = std::toupper(*it); } std::sort(str.begin(), str.end()); // 排序字符串中的字符

7. 测试、常见问题与调试技巧

实现完成后，必须进行全面的测试。

7.1 单元测试要点

你需要编写测试用例覆盖以下场景：

1. 构造与析构：默认构造、C字符串构造、拷贝构造、移动构造。
2. 赋值：拷贝赋值（包括自赋值）、移动赋值。
3. 基本功能：size(),empty(),c_str()。
4. 访问：operator[](const和非const版本)，at()（测试越界抛异常）。
5. 修改：append,operator+=,clear。
6. 容量操作：reserve,resize。
7. 流操作：operator<<,operator>>。
8. 运算符：operator+。
9. 边界情况：传入nullptr、空字符串、非常大的字符串。

7.2 常见问题与排查

1. 双重释放或内存泄漏：

   • 症状：程序崩溃（free(): double free detected in tcache 2）或内存使用量持续增长。
   • 排查：检查拷贝构造和拷贝赋值运算符是否正确实现了深拷贝。确保析构函数正确释放内存。使用Valgrind或AddressSanitizer等工具检测。

2. 访问越界：

   • 症状：程序随机崩溃或输出乱码。
   • 排查：在operator[]和at()的调试版本中加入断言（assert(pos < m_size)）。检查append、resize等函数中的内存拷贝是否越界（使用memcpy时长度参数是否正确）。

3. 自赋值问题：

   • 症状：自赋值后对象内容被破坏。
   • 排查：在拷贝赋值运算符中，必须首先检查if (this == &other)。

4. 异常安全问题：

   • 症状：在内存分配失败时，对象状态不一致。
   • 排查：确保像我们之前实现的拷贝赋值运算符那样，遵循“先分配新资源，成功后再释放旧资源”的顺序。

5. 移动后使用源对象：

   • 症状：移动一个对象后，再使用它，结果未定义（可能是空，也可能是残留数据）。
   • 排查：将被移动的源对象置于一个明确的状态（如空字符串）。在团队中约定，被移动的对象不应再被使用，除非重新赋值。

7.3 使用工具进行诊断

• Valgrind (Memcheck)：Linux/macOS下的内存错误检测神器，能发现内存泄漏、越界访问、使用未初始化内存等问题。
• AddressSanitizer (ASan)：编译时插桩工具，比Valgrind速度快，对内存错误的检测非常高效。在GCC/Clang中使用-fsanitize=address编译。
• GDB/LLDB：调试器，用于设置断点、单步执行、查看变量内存，是定位逻辑错误的终极武器。

亲手实现一个完整的String类是一次绝佳的C++学习旅程。它强迫你去思考内存的生死、拷贝的代价、接口的设计和异常的安全。当你透彻理解了这个类的每一个字节是如何流动的，你便掌握了C++资源管理的核心心法。在面试中，你不仅能流畅地写出代码，更能自信地解释每个设计选择背后的权衡，这才是真正的“吃透”。