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

如果你正在学习C++，尤其是从C语言过渡过来，那么“string类”绝对是你绕不开的一个坎。在C语言里，处理字符串是件挺麻烦的事，你得小心翼翼地分配char数组，计算长度，用strcpy、strcat这些函数，还得时刻提防着缓冲区溢出。但到了C++，标准库里的std::string就像个贴心的管家，帮你把内存管理、长度计算、字符串拼接这些脏活累活全包了，用起来那叫一个舒坦。

但是，舒坦归舒坦，作为一个有志于深入理解C++的程序员，我们不能只停留在“会用”的层面。面试官常问，学习路上也常困惑：std::string是怎么做到动态管理内存的？它的拷贝构造和赋值运算符重载内部是怎样的？为什么有时候传值拷贝代价很高，有时候又感觉很快？这些问题，光看文档和调用接口是得不到答案的。最好的方式，就是自己动手，模拟实现一个简化版的String类。

这不仅仅是为了应付“C++八股文”面试，更是一次绝佳的实践机会。通过这个项目，你能把C++面向对象的三大特性（封装、继承、多态）中的封装运用得淋漓尽致，同时深刻理解类的“四巨头”——构造函数、析构函数、拷贝构造函数、赋值运算符重载。你还会接触到动态内存管理、深浅拷贝、移动语义等核心概念。可以说，吃透了String类的模拟实现，你对C++内存模型和对象生命周期的理解会上一个大台阶。

我当年学C++的时候，就是被std::string内部那个神秘的“小字符串优化”给迷住了，决定自己实现一遍。过程中踩过的坑、调过的bug，比看十本书都记得牢。今天，我就把我模拟实现String类的完整过程、核心思路和那些容易掉进去的“坑”详细拆解出来，目标是让你看完之后，不仅能自己写出来，还能清楚每一个设计决策背后的“为什么”。

2. 核心设计思路与类框架搭建

在动手写代码之前，我们必须先想清楚，我们的MyString类需要哪些核心能力，以及底层数据如何组织。盲目开始很容易导致结构混乱，后期修修补补非常痛苦。

2.1 数据成员与基础属性的确定

首先，一个字符串类最核心的数据是什么？毫无疑问，是存储字符序列的那块内存。在C++中，我们通常使用char*指针来指向动态分配的堆内存。这是实现动态字符串（长度可变）的基础。

除了字符指针，我们还需要知道当前字符串的长度（size）以及当前分配的内存容量（capacity）。长度是字符串实际包含的字符数（不包含结尾的\0），容量则是为了减少频繁重新分配内存而预留的空间大小。这是一个非常经典的设计，也是std::string的基础实现方式之一。

因此，我们的类私有成员初步定为：

class MyString { private: char* _str; // 指向存储字符串的堆内存 size_t _size; // 字符串有效长度 size_t _capacity; // 当前分配的内存容量（能容纳的字符数，不包括\0） // ... 后续可能增加其他成员，如引用计数（写时拷贝）等 };

这里使用size_t类型是为了与标准库保持一致，它是一个无符号整数类型，专门用于表示大小和索引。

注意：有些简单的实现可能会省略_capacity，每次修改都精确分配_size+1的内存。但这会带来严重的性能问题，比如+=（追加）操作，每次追加一个字符都可能引发一次内存重新分配和拷贝，时间复杂度退化到O(N²)。预留容量（capacity）是实现高效动态增长的关键。

2.2 成员函数规划：从“四巨头”到常用接口

确定了数据成员，接下来就要规划这个类需要提供哪些操作。我们可以参考std::string的常用接口，但作为教学实现，我们聚焦于最核心的部分。

1. “四巨头” (The Big Four)：这是每个管理资源的类都必须妥善处理的四个特殊成员函数。

   • 构造函数：负责对象的初始化。我们需要默认构造（空字符串）、用C风格字符串构造、用另一个MyString对象构造（拷贝构造）。
   • 析构函数：负责在对象生命周期结束时，释放其动态申请的内存，防止内存泄漏。
   • 拷贝构造函数：用同类型的另一个对象来初始化新对象。这里涉及深拷贝与浅拷贝的核心区别，是重点也是难点。
   • 赋值运算符重载：将一个对象的值赋给另一个已存在的对象。同样需要处理深拷贝，并且要处理好自赋值的情况。

2. 容量相关操作：

   • size()/length()：返回字符串长度。
   • capacity()：返回当前容量。
   • empty()：判断是否为空串。
   • reserve(size_t n)：请求改变容量，为字符串预留空间。这是提升性能的关键函数。
   • resize(size_t n, char ch = '\0')：改变字符串长度，可能会截断或填充字符。

3. 元素访问：

   • operator[](size_t pos)：重载[]运算符，像数组一样访问指定位置的字符。需要提供常量版本和非常量版本。
   • at(size_t pos)：与[]类似，但通常进行边界检查，越界时抛出异常。
   • front()/back()：访问首尾字符。
   • c_str()：返回一个指向内部C风格字符串的常量指针，便于与旧式C接口交互。

4. 字符串修改：

   • append/operator+=：在末尾追加字符串或字符。
   • push_back(char ch)：在末尾追加一个字符。
   • insert：在指定位置插入字符串或字符。（实现较复杂，可作为进阶）
   • erase：删除指定位置的字符或子串。
   • clear()：清空字符串内容，但不一定释放内存（_size置0，_str[0]置\0）。

5. 字符串操作：

   • operator+：字符串拼接，通常作为非成员函数实现，返回新对象。
   • find：查找子串或字符。
   • substr：获取子串。
   • compare：比较两个字符串。

6. 流操作符重载：

   • operator<<：输出字符串到输出流（如cout）。
   • operator>>：从输入流（如cin）读取字符串到对象。

作为第一次模拟实现，我们优先完成“四巨头”、容量操作、基础访问和修改功能。find、substr等可以后续逐步添加。

2.3 深拷贝与浅拷贝：设计决策的核心

这是模拟String类最核心、最需要理解透彻的概念。假设我们有两个MyString对象：str1和str2。

• 浅拷贝：如果只是简单地将str1._str指针的值（一个内存地址）复制给str2._str，那么两个对象的_str指针将指向同一块堆内存。这会导致灾难性的后果：1) 修改其中一个，另一个也跟着变；2) 析构时，同一块内存会被释放两次，导致程序崩溃。这是C++默认的拷贝行为（按位拷贝）对指针成员带来的问题。
• 深拷贝：我们的目标是让str2拥有一份和str1内容完全一样，但独立的字符串副本。这意味着，在拷贝时，我们需要为str2重新申请一块足够大的堆内存，然后把str1._str指向的字符串内容逐字节复制到这块新内存中。这样，两个对象就完全独立了，互不影响。

因此，在我们的拷贝构造函数和赋值运算符重载中，必须实现深拷贝。这是模拟实现String类区别于普通类的关键。

3. 核心成员函数的逐步实现与详解

理论铺垫完毕，现在进入实战环节。我们将按照从简到繁的顺序，一步步实现各个成员函数。我会在代码中插入大量注释，解释每一行代码的意图和注意事项。

3.1 构造与析构：生命周期的起点与终点

我们先从对象的“生”与“死”开始。

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

MyString::MyString() : _str(new char[1]) // 为'\0'分配1字节空间 , _size(0) , _capacity(0) { _str[0] = '\0'; // 确保是空字符串 }

这里有一个细节：我们为_str分配了1字节的空间来存放结尾的\0，并将_capacity设为0。这是一种常见的实现方式，表示当前没有预留额外空间。你也可以选择初始_capacity为15（配合后续可能的小字符串优化），但这里我们保持简单。

2. 用C风格字符串构造这是最常用的构造函数之一。

MyString::MyString(const char* str) : _str(nullptr) , _size(0) , _capacity(0) { if (str == nullptr) { // 处理空指针，按空字符串处理 _str = new char[1]; _str[0] = '\0'; } else { _size = strlen(str); _capacity = _size; // 初始容量刚好够用，不预留 _str = new char[_capacity + 1]; // +1 给'\0' strcpy(_str, str); // 拷贝内容，包括'\0' } }

实操心得：一定要检查传入的char*是否为nullptr。虽然标准库的std::string从nullptr构造是未定义行为，但作为一个健壮的实现，我们应该防御性编程，避免程序因此崩溃。这里我们选择将其视为空字符串处理。

3. 拷贝构造函数（深拷贝实现）

MyString::MyString(const MyString& other) : _str(nullptr) , _size(other._size) , _capacity(other._capacity) { // 关键步骤：深拷贝 _str = new char[_capacity + 1]; strcpy(_str, other._str); // 复制内容 // memcpy(_str, other._str, _size + 1); // 使用memcpy也可以，效率略高 }

看，这就是深拷贝：我们为当前对象（this）申请了一块新的、大小足够的内存，然后把源对象（other）的内容复制过来。从此，this和other井水不犯河水。

4. 析构函数对象死亡时，必须释放它申请的资源。

MyString::~MyString() { if (_str) { delete[] _str; // 释放字符数组 _str = nullptr; // 防止野指针（好习惯） _size = _capacity = 0; } }

重要提示：new[]必须搭配delete[]使用。如果误用delete（没有[]），可能只释放了数组的第一个元素，导致内存泄漏。这是C++新手常犯的错误。

3.2 容量管理：reserve与resize的玄机

容量管理是MyString高效运行的关键。我们先实现两个基础查询函数：

size_t MyString::size() const { return _size; } size_t MyString::capacity() const { return _capacity; } bool MyString::empty() const { return _size == 0; }

1.reserve(size_t n)：预留空间这个函数承诺至少分配能容纳n个字符的内存（不包括\0）。如果请求的n小于等于当前_capacity，则什么都不做（标准库行为）。否则，重新分配一块大小为n的新内存，将旧数据拷贝过去，并更新_capacity。

void MyString::reserve(size_t n) { if (n > _capacity) { char* newStr = new char[n + 1]; // 申请新空间 strcpy(newStr, _str); // 拷贝数据 delete[] _str; // 释放旧空间 _str = newStr; _capacity = n; } // 如果 n <= _capacity，标准库规定什么都不做，我们遵循这一规定。 }

性能考量：reserve是优化连续追加操作的利器。比如，如果你知道最终要拼接一个很长的字符串，可以提前reserve一个足够大的容量，避免在循环中多次重新分配和拷贝。

2.resize(size_t n, char ch)：调整大小这个函数改变字符串的_size。如果n > _size，则在末尾填充字符ch（默认\0）直到长度达到n；如果n < _size，则截断字符串（相当于erase从n开始的部分）。

void MyString::resize(size_t n, char ch) { if (n > _size) { // 需要扩容并填充 if (n > _capacity) { // 需要重新分配内存，通常以一定策略扩容（如2倍） // 这里简单起见，直接reserve到n reserve(n); } // 填充字符 for (size_t i = _size; i < n; ++i) { _str[i] = ch; } _str[n] = '\0'; // 设置新的结尾 _size = n; } else if (n < _size) { // 截断 _str[n] = '\0'; _size = n; } // n == _size 时，什么都不做 }

注意，resize可能会改变_size，但不一定改变_capacity（当n <= _capacity时）。它和reserve的侧重点不同。

3.3 元素访问与修改：让类用起来像内置类型

1. 重载下标运算符operator[]为了让MyString能像数组一样访问，我们需要重载[]。注意，要提供常量版本和非常量版本。

// 非常量版本，允许修改 char& MyString::operator[](size_t pos) { // 通常不进行边界检查，以追求最高效率（与数组行为一致） // assert(pos < _size); // 调试时可以用assert检查 return _str[pos]; } // 常量版本，用于const对象，不允许修改 const char& MyString::operator[](size_t pos) const { // assert(pos < _size); return _str[pos]; }

提供常量版本是为了让const MyString对象也能使用[]运算符（只读）。这是C++重载运算符时需要考虑的常见情况。

2. 实现c_str()和data()c_str()返回一个以\0结尾的C风格字符串常量指针，便于与C库函数交互。

const char* MyString::c_str() const { return _str; }

在C++11之后，data()方法也返回一个指向内部数组的指针，对于std::string，它现在也保证以\0结尾。我们简单实现为返回_str即可。

3. 追加操作append与operator+=追加是字符串最常用的操作之一。我们先实现一个通用的append。

MyString& MyString::append(const char* str) { if (str == nullptr) return *this; // 防御性编程 size_t len = strlen(str); if (_size + len > _capacity) { // 容量不足，需要扩容 // 常见的扩容策略：新容量 = max(旧容量*2, 新所需大小) reserve(_size + len); // 这里我们直接扩到刚好够用，实际库可能按倍数扩 } strcpy(_str + _size, str); // 从原字符串结尾开始拷贝 _size += len; return *this; // 支持链式调用 } // 用append来实现 += MyString& MyString::operator+=(const char* str) { return append(str); } MyString& MyString::operator+=(const MyString& str) { return append(str.c_str()); } MyString& MyString::operator+=(char ch) { push_back(ch); return *this; }

append的核心逻辑是：1) 计算需要的新空间；2) 如果不够就扩容；3) 拷贝新内容到末尾；4) 更新_size。返回*this的引用是为了支持像s1 += s2 += s3这样的链式调用。

4. 尾插字符push_back这是一个更基础的操作，经常在循环中被调用。

void MyString::push_back(char ch) { if (_size == _capacity) { // 容量已满，需要扩容 // 如果_capacity为0，则扩到1，否则扩到2倍（常见策略） reserve(_capacity == 0 ? 1 : _capacity * 2); } _str[_size] = ch; ++_size; _str[_size] = '\0'; // 别忘了维护结尾的\0 }

注意扩容策略：当容量为0时，我们分配1个字符的空间（加上\0是2字节）。之后每次满容，就将容量翻倍。这是一种在时间效率和空间效率之间取得平衡的经典策略，能保证多次push_back的均摊时间复杂度为O(1)。

3.4 赋值运算符重载：处理自赋值的艺术

赋值运算符重载operator=是“四巨头”中最需要小心处理的一个。它需要完成深拷贝，并且必须正确处理自赋值（str = str）的情况。

MyString& MyString::operator=(const MyString& other) { // 1. 检查自赋值 if (this == &other) { return *this; // 如果是自己给自己赋值，直接返回 } // 2. 释放当前对象的旧资源 delete[] _str; // 3. 分配新资源并拷贝数据（深拷贝） _size = other._size; _capacity = other._capacity; _str = new char[_capacity + 1]; strcpy(_str, other._str); // 4. 返回当前对象的引用以支持链式赋值 return *this; }

避坑指南：自赋值检查if (this == &other)至关重要。如果没有这步检查，在自赋值时，delete[] _str会先释放掉自己的内存，紧接着new char[...]试图从other._str（也就是刚刚被释放的同一块内存）拷贝数据，这会导致访问已释放内存的未定义行为，通常是程序崩溃。这是一个经典的面试考点。

3.5 流操作符重载：让输入输出更自然

为了让我们的MyString能像内置类型一样用cout和cin操作，我们需要重载<<和>>运算符。它们通常被实现为类的友元函数或非成员函数。

1. 输出运算符operator<<

// 在类声明中添加友元声明: friend std::ostream& operator<<(std::ostream& os, const MyString& str); std::ostream& operator<<(std::ostream& os, const MyString& str) { os << str._str; // 直接输出内部的C字符串 return os; // 返回流引用以支持链式输出 }

实现很简单，因为ostream已经支持输出const char*。

2. 输入运算符operator>>输入稍微复杂点，因为我们需要从流中读取一个“单词”（默认遇到空白字符停止）。

std::istream& operator>>(std::istream& is, MyString& str) { // 先清空目标字符串 str.clear(); char ch; // 跳过开头的空白字符 while (is.get(ch) && std::isspace(ch)) { // 什么也不做，只是跳过 } // 如果流状态正常且读到了非空白字符 if (is) { do { str.push_back(ch); // 将字符追加到字符串 } while (is.get(ch) && !std::isspace(ch)); // 继续读直到遇到空白或EOF // 如果因为遇到空白而停止，需要把空白字符放回流中 if (is && std::isspace(ch)) { is.unget(); // 回退一个字符 } } return is; }

这里我们使用了push_back，它会自动处理内存扩容。注意unget()的用法，它把最后读取的空白字符放回流中，以免影响后续的输入操作。这是为了模拟std::cin >> std::string的标准行为。

4. 进阶优化与深度思考

实现了基础版本后，我们的MyString已经具备了核心功能。但一个工业级的字符串类远不止于此。下面探讨几个常见的进阶优化方向，这些也是面试中常被深入追问的点。

4.1 拷贝控制优化：移动语义（C++11）

在C++11之前，我们只有拷贝构造和拷贝赋值。如果函数返回一个局部MyString对象，会发生什么？编译器会调用拷贝构造函数创建一个临时对象，然后析构局部对象，效率不高。C++11引入了移动语义来解决这个问题。

移动构造和移动赋值的核心思想是“资源窃取”：直接“拿走”源对象（通常是即将消亡的临时对象）的资源，而不是深拷贝。这要求源对象处于“可被移动”的状态（通常通过右值引用&&标识）。

移动构造函数实现：

MyString::MyString(MyString&& other) noexcept // noexcept 声明不抛异常，利于优化 : _str(other._str) , _size(other._size) , _capacity(other._capacity) { // 将源对象置于有效但可析构的状态 other._str = nullptr; other._size = 0; other._capacity = 0; }

看，这里没有new和strcpy！我们只是把other内部的指针“偷”了过来，然后把other的指针置为空。这样，当other被析构时，delete[] nullptr是安全的。这比深拷贝快得多。

移动赋值运算符实现：

MyString& MyString::operator=(MyString&& other) noexcept { // 检查自赋值（移动自赋值虽然罕见，但应处理） if (this != &other) { // 释放当前对象的资源 delete[] _str; // 窃取资源 _str = other._str; _size = other._size; _capacity = other._capacity; // 置空源对象 other._str = nullptr; other._size = 0; other._capacity = 0; } return *this; }

实现了移动语义后，像MyString s3 = std::move(s1);或者函数返回MyString时，编译器会优先选择移动操作，大幅提升性能。

4.2 小字符串优化（SSO）

这是std::string在许多实现中采用的经典优化。其思想是：对于很短的字符串（比如15或22个字符以内），不将其存储在堆上，而是直接存储在对象内部的某个缓冲区中。这样，短字符串的构造、拷贝、析构就完全不需要动态内存分配，速度极快，也减少了堆内存碎片。

实现SSO会显著增加类的复杂性。你需要：

1. 在类内部定义一个固定大小的字符数组（如char _small_buffer[16]）。
2. 需要一个标志位（或利用指针的最后一位）来区分当前字符串是处于“小字符串”模式（存储在缓冲区）还是“长字符串”模式（存储在堆）。
3. 所有成员函数（构造、拷贝、赋值、修改、访问等）都需要根据当前模式分支处理。

这是一个高级话题，通常只在追求极致性能或深入理解标准库实现时才会去模拟。对于学习目的，理解其原理比完整实现更重要。

4.3 写时拷贝（Copy-On-Write, COW）

另一种优化策略。其核心是：多个MyString对象可以共享同一块字符串内存。只有当某个对象需要修改字符串内容时（“写”操作），才真正执行深拷贝。这可以节省大量拷贝操作的内存和时间。

实现COW需要：

1. 在堆内存的头部（或单独的结构中）维护一个引用计数。
2. 拷贝构造函数和赋值运算符不再深拷贝，而是让新对象指向同一块内存，并将引用计数加1。
3. 在operator[]（非常量版本）、append、push_back等任何可能修改内容的函数调用时，检查引用计数。如果计数大于1，说明有多个对象共享，则需要先执行深拷贝（“写时”拷贝），然后再修改。

COW在多线程环境下需要谨慎处理引用计数的原子性。现代C++标准库的实现中，std::string通常不再使用COW，因为移动语义的引入已经解决了大部分性能问题，而COW在多线程下的开销和复杂性使其优势不再明显。

5. 完整代码示例与测试

将上述所有部分组合起来，我们就得到了一个相对完整的MyString类。下面提供一个整合后的头文件概览和简单的测试用例。

MyString.h (部分)

#ifndef MYSTRING_H #define MYSTRING_H #include <iostream> #include <cstring> #include <cassert> class MyString { public: // 构造函数 MyString(); MyString(const char* str); MyString(const MyString& other); // 拷贝构造 MyString(MyString&& other) noexcept; // 移动构造 (C++11) // 析构函数 ~MyString(); // 赋值运算符 MyString& operator=(const MyString& other); // 拷贝赋值 MyString& operator=(MyString&& other) noexcept; // 移动赋值 (C++11) // 容量 size_t size() const { return _size; } size_t capacity() const { return _capacity; } bool empty() const { return _size == 0; } void reserve(size_t n); void resize(size_t n, char ch = '\0'); // 元素访问 char& operator[](size_t pos); const char& operator[](size_t pos) const; const char* c_str() const { return _str; } // 修改 void push_back(char ch); MyString& append(const char* str); MyString& operator+=(const char* str); MyString& operator+=(const MyString& str); MyString& operator+=(char ch); void clear(); // 友元函数 friend std::ostream& operator<<(std::ostream& os, const MyString& str); friend std::istream& operator>>(std::istream& is, MyString& str); private: char* _str; size_t _size; size_t _capacity; }; // 非成员函数：字符串拼接 MyString operator+(const MyString& lhs, const MyString& rhs); #endif // MYSTRING_H

测试用例示例 (test.cpp)

#include "MyString.h" #include <iostream> int main() { // 测试构造 MyString s1; // 默认构造 MyString s2("Hello"); // C字符串构造 MyString s3 = s2; // 拷贝构造 std::cout << "s1: \"" << s1 << "\", size=" << s1.size() << std::endl; std::cout << "s2: \"" << s2 << "\", size=" << s2.size() << std::endl; std::cout << "s3: \"" << s3 << "\", size=" << s3.size() << std::endl; // 测试赋值 s1 = "World"; // 赋值 std::cout << "After assignment, s1: \"" << s1 << "\"" << std::endl; // 测试自赋值 s1 = s1; std::cout << "After self-assignment, s1: \"" << s1 << "\"" << std::endl; // 测试追加和+= s2 += " "; s2 += s1; std::cout << "s2 after +=: \"" << s2 << "\"" << std::endl; // 应输出 "Hello World" // 测试[] s2[0] = 'h'; std::cout << "After s2[0]='h': \"" << s2 << "\"" << std::endl; // 应输出 "hello World" // 测试输入输出 MyString s4; std::cout << "Please enter a string: "; std::cin >> s4; std::cout << "You entered: \"" << s4 << "\"" << std::endl; // 测试容量管理 MyString s5; std::cout << "Initial capacity of s5: " << s5.capacity() << std::endl; for(int i = 0; i < 100; ++i) { s5.push_back('a' + (i % 26)); } std::cout << "After 100 push_back, size=" << s5.size() << ", capacity=" << s5.capacity() << std::endl; return 0; }

运行这个测试程序，观察输出是否符合预期，是检验你的MyString类是否正确工作的最好方式。

6. 常见问题与调试技巧实录

在实现过程中，你几乎一定会遇到各种问题。下面是我踩过的一些坑和解决方法。

问题1：程序在拷贝或赋值后崩溃（如“double free or corruption”）

• 原因：几乎可以肯定是浅拷贝惹的祸。两个对象的_str指向了同一块内存，析构时被delete了两次。
• 排查：检查拷贝构造函数和赋值运算符重载。确保它们执行了深拷贝（使用new[]和strcpy/memcpy），而不是简单的指针赋值。
• 技巧：在拷贝构造和赋值运算符的第一行和最后一行加上打印语句，观察它们是否被调用，以及调用时_str的地址。确保拷贝后两个对象的_str指向不同的地址。

问题2：使用+=或push_back后字符串内容乱码或程序崩溃

• 原因：内存越界。可能是在追加时没有正确计算新长度，或者reserve逻辑有误，导致_str指向的内存空间不足。
• 排查：
  1. 检查append和push_back函数中，扩容的条件判断是否正确。通常是if (_size + new_len > _capacity)。
  2. 检查reserve函数，确保新分配的内存大小是n + 1（为\0留位置）。
  3. 在每次修改_size后，是否都正确地设置了_str[_size] = '\0'？
• 工具：使用Valgrind（Linux/Mac）或Visual Studio的内存调试工具来检测内存越界和泄漏。

问题3：operator=处理自赋值时崩溃

• 原因：没有进行自赋值检查 (if (this == &other))。在自赋值时，先delete[] _str，然后试图从other._str（已被释放）拷贝数据。
• 解决：务必在赋值运算符重载的开头加上自赋值检查。

问题4：operator[]的常量版本缺失导致const对象无法使用

• 现象：const MyString str("hello"); char c = str[0];编译报错。
• 原因：编译器尝试调用非常量版本的operator[]，但该版本返回char&，允许修改，这与const对象语义冲突。
• 解决：重载一个常量版本的operator[]，返回const char&。

问题5：输入运算符>>读取包含空格的字符串

• 需求：默认的operator>>遇到空格就停止。如果想读取一行（包含空格），需要实现类似std::getline的功能。
• 实现思路：可以创建一个新的成员函数或友元函数getline(std::istream&, MyString&, char delim='\n')，使用istream::getline或循环读取直到遇到分隔符。

调试心法：

1. 最小化复现：当遇到bug时，尝试写一个最简单的、能重现问题的测试程序。这能帮你快速定位问题函数。
2. 打印大法好：在怀疑的函数开始、结束和关键分支处打印对象的状态（_str地址、_size、_capacity），这是最直接有效的调试手段之一。
3. 善用调试器：学会使用GDB或IDE的调试器设置断点、单步执行、查看变量值。特别是观察指针在每一步的变化。
4. 内存检查工具：在Linux/macOS下，养成用valgrind --leak-check=full ./your_program检查内存泄漏和越界的习惯。在Windows下，Visual Studio的调试运行时库也能提供很多帮助。

模拟实现一个String类，就像一次C++核心概念的深度游。从基本的类设计、资源管理（RAII思想），到深拷贝、操作符重载，再到进阶的移动语义、SSO优化，每一个环节都对应着C++编程中的一个重要知识点。自己动手敲一遍，调试通过，并且理解每一行代码背后的“为什么”，比你读十篇教程都管用。希望这篇超详细的拆解能成为你探索C++对象模型之旅上的一块坚实垫脚石。如果在实现中遇到任何问题，随时可以带着你的代码来讨论。