C++ string类模拟实现：从深拷贝到内存管理的完整指南

1. 项目概述：为什么我们要“手撕”string类？

在C++的学习道路上，尤其是从C语言过渡到C++的“初阶”阶段，string类绝对是一个绕不开的核心。标准库里的std::string用起来太方便了，+=、find、substr，几个操作符和函数调用就能完成复杂的字符串处理。但正是这种“方便”，让很多初学者对它的内部机制感到神秘和疏远。指针、内存管理、深浅拷贝这些底层概念，仿佛被一层优雅的封装隔开了。

所以，“手撕string类”——也就是不依赖标准库，从零开始模拟实现一个自己的string类——就成了一个极具价值的练手项目。这绝不是重复造轮子，而是一次深度的“外科手术式”学习。通过亲手实现MyString的构造函数、拷贝控制、运算符重载和常用接口，你能把《C++ Primer》里那些关于类、动态内存、重载、模板的抽象理论，变成一行行有血有肉的代码。你会真切地体会到，为什么要有拷贝构造函数和赋值运算符重载（深拷贝问题），为什么析构函数里要delete[]，reserve和resize到底有什么区别。这个过程，是理解C++面向对象和资源管理思想的绝佳路径。

我当年学到这里时，也是照着书把String类写了一遍，编译通过后那种成就感，比调用一百次std::string都要强烈。更重要的是，面试中“实现一个简单的string类”几乎是经典中的经典，它能考察你C++功底的方方面面。接下来，我就带你从零开始，一步步构建一个功能完整的MyString类，我会把每个设计决策背后的“为什么”讲清楚，并分享我踩过的那些坑。

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

在动键盘敲代码之前，我们必须先想清楚这个MyString类要怎么设计。目标是模拟std::string的核心行为，但不必追求与标准库完全一致（标准库的实现极其复杂且高度优化）。我们的设计需要把握几个核心原则：安全性、易用性和教学性。

2.1 数据成员的设计：基石决定上层建筑

一个字符串类最核心的数据是什么？是字符序列本身以及描述这个序列的信息。

class MyString { private: char* _str; // 指向动态分配的字符数组，用于存储字符串内容，以'\0'结尾 size_t _size; // 当前字符串的实际有效长度（不包含结尾的'\0'） size_t _capacity; // 当前为字符串分配的存储空间总大小（可容纳的字符数，不含'\0'） };

为什么这样设计？

• char* _str：这是C风格字符串的根基。我们选择在堆上动态分配内存，这样字符串的长度就可以在运行时自由变化，这是实现append、+=等操作的基础。使用指针而非固定数组，赋予了类动态成长的能力。
• size_t _size：必须单独记录长度。如果每次都调用strlen(_str)来获取长度，时间复杂度是O(N)，在循环中将是灾难。将长度缓存起来，任何需要获取长度的操作（如size()、length()）都可以在O(1)时间内完成。
• size_t _capacity：这是实现高效内存管理的关键。想象一下，如果没有_capacity，每次push_back一个字符都要重新分配一块刚好大一点的新内存，然后把旧数据拷贝过去，这效率太低了。_capacity允许我们进行“容量预分配”，比如一次性申请足够未来一段时间使用的内存，减少频繁内存分配和拷贝的开销。_capacity通常 >=_size。

这就是经典的“容量-大小”分离模型，也是std::vector、std::string等容器的通用设计。

2.2 成员函数规划：接口与行为

我们需要实现哪些函数？可以参照std::string的常用接口进行分类：

1. 构造与析构：默认构造、C字符串构造、拷贝构造、析构。
2. 容量操作：size,capacity,empty,clear,reserve,resize。
3. 元素访问：operator[](const 和 non-const 版本)。
4. 修改操作：append,push_back,operator+=,assign,insert,erase。
5. 字符串操作：c_str,find,substr。
6. 非成员函数：流插入<<和流提取>>运算符重载，以及关系运算符==,!=,<等。

我们的实现将聚焦于最核心、最能体现知识点的部分，构建一个可用的最小功能集合。

3. 核心实现：从构造到析构的生命周期管理

让我们从类的“生老病死”开始，这是C++资源管理最核心的部分。

3.1 构造函数：赋予对象初始状态

默认构造函数：创建一个空的MyString对象。

MyString::MyString() : _str(new char[1]) // 分配1个char的空间 , _size(0) , _capacity(0) { _str[0] = '\0'; // 空字符串必须以'\0'结尾 }

注意：这里为_str分配了1字节的空间并放置\0，而不是让_str为nullptr。这样做是为了保证c_str()函数始终返回一个有效的C风格字符串指针（指向\0），符合大多数使用习惯，避免空指针解引用。_capacity设为0，表示没有预分配额外空间。

带参构造函数（从C字符串构造）：这是最常用的构造方式。

MyString::MyString(const char* str) : _size(strlen(str)) { // 计算需要的容量，通常我们让初始容量等于长度，或者略大一点（比如2倍） _capacity = _size; _str = new char[_capacity + 1]; // +1 用于存放结尾的'\0' strcpy(_str, str); // 拷贝内容，包括结尾的'\0' }

这里有一个关键细节：new分配的大小是_capacity + 1。因为_capacity记录的是可存储的有效字符数，不包括结尾的\0。所以实际分配的内存需要多一个字节来存放这个终止符。strcpy会连同\0一起拷贝过来。

3.2 拷贝构造函数与赋值运算符：深拷贝的艺术

这是模拟实现string类的重中之重，也是面试必考点。核心问题是“浅拷贝”与“深拷贝”。

浅拷贝的灾难：如果使用编译器生成的默认拷贝构造函数，它只会进行成员变量的逐字节拷贝（浅拷贝）。对于指针_str，这意味着两个MyString对象的_str指针指向同一块堆内存。当这两个对象析构时，同一块内存会被delete[]两次，导致程序崩溃。同时，修改其中一个字符串会影响到另一个，这完全违背了对象的独立性。

深拷贝的实现：我们必须自己实现拷贝语义，为新的对象分配独立的内存。

// 拷贝构造函数 MyString::MyString(const MyString& s) : _size(s._size) , _capacity(s._capacity) { _str = new char[_capacity + 1]; strcpy(_str, s._str); // 深拷贝：复制内容，而非指针 } // 赋值运算符重载 (现代写法) MyString& MyString::operator=(MyString s) { // 注意！这里参数是值传递，会调用拷贝构造生成临时对象 swap(s); // 交换当前对象和临时对象s的内容 return *this; // 临时对象s在函数结束时析构，会释放掉旧内存 } // 辅助的swap函数 void MyString::swap(MyString& s) { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); }

赋值运算符的现代写法解析：

1. 参数MyString s采用传值方式。当执行str1 = str2时，会调用拷贝构造函数，创建出一个str2的副本s。这个s拥有独立的内存。
2. 在函数体内，调用swap(*this, s)，将当前对象（*this，即str1）的旧内容与s的新内容进行交换。交换后，*this拥有了s（即str2副本）的内容，而s拥有了*this的旧内容。
3. 函数返回时，局部对象s被销毁，其析构函数会释放掉它现在持有的旧内存（也就是原来str1的内存）。 这种写法异常优雅，它利用了拷贝构造函数来完成资源分配，利用析构函数来完成资源释放，代码简洁且异常安全（即使在拷贝时发生异常，*this的原始状态也不会被破坏）。

3.3 析构函数：资源的最终释放

析构函数的职责很明确：释放对象生命周期内申请的资源。

MyString::~MyString() { delete[] _str; // 释放动态数组 _str = nullptr; // 良好的习惯，防止悬空指针 _size = _capacity = 0; }

实操心得：在delete[]后将指针置为nullptr是一个好习惯。虽然对象即将销毁，这个操作看似多余，但在某些调试场景或继承体系中，可以避免误用已释放的内存。同时，将_size和_capacity归零，使对象处于一个明确的状态。

4. 容量相关操作：高效内存管理的核心

reserve和resize是string类中容易混淆但至关重要的两个函数，它们直接关系到程序的性能和内存使用。

4.1 reserve：预留空间，减少扩容次数

reserve的目的是增加字符串的容量(_capacity)，为后续添加字符预留空间，但不会改变当前字符串的内容和长度(_size)。

void MyString::reserve(size_t n) { if (n > _capacity) { // 只有请求的容量大于当前容量时才需要操作 char* newstr = new char[n + 1]; // 分配新空间，+1给'\0' strcpy(newstr, _str); // 拷贝原有数据 delete[] _str; // 释放旧空间 _str = newstr; // 指向新空间 _capacity = n; // 更新容量 } // 如果 n <= _capacity，标准规定 reserve() 可能什么都不做，也可能缩小容量。 // 我们这里实现一个简单的版本，只处理扩容。 }

应用场景：如果你预先知道将要拼接一个很长的字符串，可以先调用reserve预留足够空间，避免在append或+=操作中发生多次“分配-拷贝-释放”的昂贵过程。

MyString str; str.reserve(1000); // 一次性预留1000字符空间 for(int i = 0; i < 1000; ++i) { str.push_back('a'); // 这1000次push_back都不会触发重新分配 }

4.2 resize：改变大小，可能初始化新元素

resize用于改变字符串的当前大小(_size)。它的行为更复杂：

• 如果n <= _size：将_size减小到n，并在_str[n]位置放入\0（截断字符串）。容量_capacity不变。
• 如果n > _size：将字符串扩展到n个字符。如果n超过了当前_capacity，则需要像reserve一样扩容。对于多出来的新位置（_size到n-1），需要填充指定的字符（默认为\0）。

void MyString::resize(size_t n, char ch = '\0') { if (n > _size) { // 需要扩容 if (n > _capacity) { reserve(n); // 复用reserve函数，可能扩容得比n更大（取决于reserve策略） } // 填充新字符 for (size_t i = _size; i < n; ++i) { _str[i] = ch; } _str[n] = '\0'; // 设置新的结尾 _size = n; } else { // 截断 _str[n] = '\0'; _size = n; } }

与reserve的关键区别：

4.3 push_back 与 append：如何实现高效添加

push_back是添加单个字符，append是添加字符串或另一个MyString对象。它们的实现都需要考虑容量是否足够。

void MyString::push_back(char ch) { if (_size == _capacity) { // 空间已满，需要扩容 // 常见的扩容策略：如果容量为0，扩容到4（或其它初始值）；否则扩容到2倍。 reserve(_capacity == 0 ? 4 : _capacity * 2); } _str[_size] = ch; ++_size; _str[_size] = '\0'; // 别忘了维护结尾的'\0' } MyString& MyString::append(const char* str) { size_t len = strlen(str); if (_size + len > _capacity) { // 现有空间不足 reserve(_size + len); // 扩容到刚好能放下新旧内容的大小 } strcpy(_str + _size, str); // 从原字符串结尾处开始拷贝 _size += len; // strcpy已经拷贝了'\0'，所以不需要再添加 return *this; // 支持链式调用，如 str.append("hello").append(" world"); }

扩容策略的思考：上面的push_back采用了“2倍扩容”策略。这是一种在时间效率和空间效率之间取得平衡的常见做法。一次扩容的均摊时间复杂度是O(1)。你也可以像append里那样，精确扩容到所需大小。std::string的具体策略由实现定义，但通常也是某种倍数增长。

5. 运算符重载：让类用起来像内置类型

运算符重载是C++让自定义类型用起来像内置类型的关键。对于string类，[]、+=、+、<<、>>以及关系运算符的重载至关重要。

5.1 下标运算符operator[]

我们需要提供const和non-const两个版本，以分别支持常量对象和非常量对象的访问。

// 非常量版本，可以修改返回的字符引用 char& MyString::operator[](size_t pos) { assert(pos < _size); // 使用断言检查越界，发布版本可替换为更温和的检查 return _str[pos]; } // 常量版本，返回常量引用，禁止修改 const char& MyString::operator[](size_t pos) const { assert(pos < _size); return _str[pos]; }

为什么需要两个版本？当一个const MyString对象调用operator[]时，编译器会选择const版本，从而保证不会通过它修改对象内容，这是C++ const正确性的体现。

5.2 流插入与流提取operator<<和operator>>

这两个通常重载为全局友元函数。

// 流插入：输出字符串内容 std::ostream& operator<<(std::ostream& out, const MyString& s) { out << s._str; // 直接输出内部的C字符串指针 return out; } // 流提取：读取输入到字符串（简化版，不考虑空格处理等复杂情况） std::istream& operator>>(std::istream& in, MyString& s) { s.clear(); // 先清空原内容 char ch; ch = in.get(); // 使用get()读取单个字符 // 一个简单的实现：一直读到换行或文件尾 while (ch != '\n' && ch != EOF) { s.push_back(ch); ch = in.get(); } return in; }

注意：这个operator>>的实现非常基础，它会把一整行（直到换行）读入。标准的std::cin >> string是以空白字符（空格、制表符、换行）为分隔的。要实现标准行为，逻辑会更复杂，需要处理缓冲区。这里提供的是一个教学用的清晰版本。

5.3 关系运算符==,!=,<等

这些运算符用于比较两个MyString对象。我们可以利用已有的C库函数strcmp。

bool operator==(const MyString& lhs, const MyString& rhs) { return strcmp(lhs.c_str(), rhs.c_str()) == 0; } bool operator!=(const MyString& lhs, const MyString& rhs) { return !(lhs == rhs); // 复用 operator== } bool operator<(const MyString& lhs, const MyString& rhs) { return strcmp(lhs.c_str(), rhs.c_str()) < 0; } // 其他如 >, <=, >= 可以类似地基于 < 和 == 实现

实现技巧：像!=、>、<=、>=这类运算符，通常不需要重新实现所有逻辑，可以复用==和<的定义，这既减少了代码量，也保证了逻辑的一致性。

6. 其他常用接口实现

6.1 c_str 与 data

这两个函数都返回指向内部字符数组的指针，对于MyString这个简单实现，它们可以是一样的。c_str()保证返回一个以\0结尾的C风格字符串。

const char* MyString::c_str() const { return _str; } const char* MyString::data() const { return _str; } // 在C++17后，data()也返回非const指针，这里我们只实现const版本。

6.2 find：查找子串或字符

实现一个简单的查找功能，这里以查找字符为例。

size_t MyString::find(char ch, size_t pos = 0) const { assert(pos <= _size); // 起始位置不能超过长度 for (size_t i = pos; i < _size; ++i) { if (_str[i] == ch) { return i; // 找到，返回下标 } } return npos; // 未找到，返回一个特殊值 } // 类内静态成员变量声明 static const size_t npos = -1;

关于npos：npos是std::string中表示“未找到”或“最大可能值”的静态常量，通常定义为-1（对于size_t是无符号整型的最大值）。我们需要在类外定义它：const size_t MyString::npos = -1;。

6.3 substr：获取子串

返回从指定位置开始、指定长度的新字符串。

MyString MyString::substr(size_t pos, size_t len = npos) const { assert(pos <= _size); size_t realLen = len; if (len == npos || pos + len > _size) { realLen = _size - pos; // 如果len为npos或超出范围，则取到字符串结尾 } MyString sub; sub.reserve(realLen); // 预分配空间 for (size_t i = 0; i < realLen; ++i) { sub.push_back(_str[pos + i]); } return sub; // 返回值，会触发拷贝构造（或RVO优化） }

7. 常见问题、调试技巧与避坑指南

自己实现一个类，编译通过只是第一步，让它稳定、正确地运行才是挑战。下面是我在实现和教学过程中总结的一些典型问题和技巧。

7.1 内存问题：泄漏、越界与重复释放

这是手写字符串类最容易出错的地方。

1. 内存泄漏：忘记在析构函数中delete[] _str，或者在reserve、resize等函数中分配了新内存却忘记释放旧内存。

   • 排查工具：在Linux/macOS下可以使用valgrind，在Windows下可以使用Visual Studio的内存诊断工具或Dr. Memory。
   • 技巧：遵循“谁申请，谁释放”的原则。在类中，构造函数new，析构函数就必须delete。任何重新new的操作前，都要检查是否需要先delete旧的。

2. 越界访问：在operator[]、find、substr等函数中，下标pos没有进行有效性检查。

   • 解决方案：使用assert(pos < _size)进行调试期检查。在发布版本中，可以改为抛出异常（如std::out_of_range）或返回一个安全值（但这可能掩盖错误）。

3. 重复释放：主要发生在没有正确实现拷贝构造和赋值运算符，导致多个对象共享同一块内存，析构时被多次delete[]。

   • 典型症状：程序运行时崩溃，错误信息常与堆损坏相关。
   • 根治方法：务必实现“深拷贝”的拷贝构造函数和赋值运算符重载。理解“三/五法则”：如果一个类需要自定义析构函数、拷贝构造函数或拷贝赋值运算符，那么它很可能需要全部三个（C++11后还有移动构造和移动赋值）。

7.2 关于\0结尾的维护

我们的MyString内部维护的是一个C风格字符串，必须以\0结尾。很多bug都源于忘记维护这个终止符。

• 在push_back、append、resize（截断时）等改变字符串内容的函数末尾，必须确保_str[_size] = '\0'。
• strcpy在拷贝时会把源字符串的\0一并拷贝过来，所以用它完成的拷贝操作后不需要额外添加。
• 但在push_back单个字符后，需要手动添加。

7.3 赋值运算符的“自赋值”问题

在传统的赋值运算符实现中（非上面介绍的现代写法），需要警惕自赋值str = str。

// 传统写法（不推荐，仅用于说明问题） MyString& MyString::operator=(const MyString& s) { if (this != &s) { // 自赋值检查 delete[] _str; // 先释放自己的内存 _size = s._size; _capacity = s._capacity; _str = new char[_capacity + 1]; strcpy(_str, s._str); } return *this; }

如果没有if (this != &s)检查，在自赋值时，delete[] _str会先释放掉自己的内存，紧接着s._str（和this->_str是同一块内存）就变成了野指针，new和strcpy会导致未定义行为。而之前介绍的“现代写法”通过传值参数和swap，天然地避免了自赋值问题，是更优的选择。

7.4 测试驱动开发

不要写完所有代码再测试。应该写一个函数，测试一个功能。

void TestMyString() { // 1. 构造测试 MyString s1; MyString s2("hello"); MyString s3(s2); // 拷贝构造 assert(strcmp(s2.c_str(), s3.c_str()) == 0); // 2. 赋值测试 MyString s4; s4 = s2; // 赋值运算 assert(s4 == s2); // 3. 修改测试 s2.push_back('!'); assert(s2.size() == 6); s2.append(" world"); assert(s2 == "hello! world"); // 4. 容量测试 MyString s5; size_t old_cap = s5.capacity(); for(int i = 0; i < 100; ++i) s5.push_back('a'); assert(s5.capacity() > old_cap); // 应该发生了扩容 // 5. 查找与子串测试 size_t pos = s2.find('w'); MyString sub = s2.substr(pos, 5); assert(sub == "world"); std::cout << "All tests passed!" << std::endl; }

系统地编写测试用例，能帮你快速定位是哪个接口的实现出了问题。

7.5 更进一步：迭代器、移动语义与SSO

当你完成了基础版本后，可以尝试挑战更高级的特性，这能让你对现代C++有更深的理解：

• 迭代器：为MyString实现begin()、end()等函数，使其能用于范围for循环 (for (char ch : mystr)) 和标准库算法。
• 移动语义：实现移动构造函数和移动赋值运算符。这对于从函数返回MyString对象（如substr）能带来巨大的性能提升，避免不必要的深拷贝。
• SSO：研究std::string的“短字符串优化”。许多标准库实现会对很短的字符串（如15或22字节以内）直接存储在对象内部，而不进行堆分配，这能极大提升小字符串操作的性能。实现SSO是模拟string类的终极挑战。

手撕一个string类，就像一次完整的C++语法和思想体检。它强迫你去思考内存管理、拷贝控制、接口设计、运算符重载等核心问题。当你自己实现的MyString能够稳定运行并通过各种测试时，你对C++的理解就已经上了一个坚实的台阶。这个过程中遇到的每一个编译错误和运行时崩溃，都是你最宝贵的经验。