1. 项目概述为什么从string类开始你的C进阶之路如果你已经学完了C的基础语法比如变量、循环、判断甚至接触了指针和数组那么恭喜你你已经推开了C世界的大门。但接下来很多人会陷入一个迷茫期感觉知识点都懂但一上手写稍微复杂点的程序就无从下手代码写得又长又乱还总出内存错误。这时候你需要一个能串联起你所有零散知识并带你真正理解C“面向对象”和“资源管理”核心思想的练手项目。在我看来亲手实现一个简化版的std::string类就是这个阶段最完美的“毕业设计”。std::string是C标准库中使用频率最高的类之一它封装了动态字符数组让我们能像操作基本类型一样方便地处理文本。但它的便利背后隐藏着C几乎所有的核心难点动态内存管理、深拷贝与浅拷贝、构造函数与析构函数RAII思想、运算符重载、迭代器概念等等。很多面试官喜欢问string类的实现不是因为它偏门恰恰是因为它太经典能全面考察一个C程序员的基本功是否扎实。所以这个系列的第11篇我们不只满足于教你如何使用std::string的find、substr这些API那是语法手册的工作我们要做两件更有价值的事第一系统梳理string类的基本语法和常用方法让你知其然第二也是更重要的带你从零开始一步步实现一个我们自己的MyString类。在这个过程中你会真切地体会到那些书本上枯燥的概念是如何在代码中“活”过来的。当你成功运行起自己写的字符串类并让它和标准库的string一样工作时你对C的理解会上升一个全新的层次。2. string类基本语法与核心操作全解析在动手造轮子之前我们必须先彻底了解这个轮子应该长什么样、怎么用。std::string是一个功能极其丰富的类但我们先从最核心、最常用的部分开始掌握。2.1 对象的创建与初始化多种姿势各有讲究创建字符串对象C提供了多种构造函数对应不同的使用场景。#include iostream #include string using namespace std; int main() { // 1. 默认构造创建一个空字符串 string emptyStr; cout 空字符串: \ emptyStr \, 长度: emptyStr.length() endl; // 2. 用C风格字符串初始化 const char* cstr Hello, C; string strFromC(cstr); cout 从C字符串构造: strFromC endl; // 3. 用另一个string对象初始化拷贝构造 string copyStr(strFromC); cout 拷贝构造: copyStr endl; // 4. 用部分字符序列初始化 string partStr(Hello World, 5); // 取前5个字符 Hello cout 部分构造: partStr endl; // 5. 填充n个相同字符 string repeatStr(10, A); // AAAAAAAAAA cout 重复字符构造: repeatStr endl; // 6. 使用初始化列表 (C11) string initListStr {H, i, !}; cout 初始化列表构造: initListStr endl; return 0; }注意第2种方式string strFromC(cstr);要求传入的C风格字符串必须以空字符\0结尾否则会导致未定义行为如内存越界读取。这是从C过渡到C时一个常见的陷阱。2.2 字符串的“增删改查”像操作数组一样自然string类重载了[]运算符让我们可以像访问数组一样访问和修改字符串中的单个字符。但这里有一个关键区别operator[]不进行边界检查访问越界是未定义行为而.at(index)成员函数会进行边界检查如果越界会抛出std::out_of_range异常。在追求性能的代码中常用[]在需要安全性的场景用.at()。修改操作是字符串处理的核心。append,insert,erase,replace这几个函数功能强大但需要特别注意它们的参数和返回值。string str I learning C; // 追加字符串 str.append( and Python); // str 变为 I learning C and Python str is fun; // 更常用的方式重载了运算符 // 在指定位置插入 str.insert(2, am ); // 在索引2处插入str 变为 I am learning C and Python is fun // 第一个参数是位置第二个是待插入的字符串 // 删除字符 str.erase(0, 4); // 从索引0开始删除4个字符移除 I am 剩下 learning C and Python is fun str.erase(5, 7); // 从索引5i开始删除7个字符移除 ing C要小心计算位置和长度 // 替换子串 str.replace(0, 8, Mastering); // 从索引0开始将8个字符learnin替换为Mastering cout 最终字符串: str endl; // 输出: Mastering C and Python is fun实操心得insert,erase,replace这些会改变字符串长度的操作在内部可能涉及内存的重新分配和大量字符的移动在循环中频繁使用它们尤其是在长字符串的开头进行操作可能会导致性能问题。如果需要在字符串前端进行大量修改有时考虑使用std::dequechar或先反转处理再反转回来可能是更好的选择。查找操作主要依靠find系列函数。它们返回的是匹配子串第一个字符的位置索引类型是size_t。如果没找到则返回一个特殊的常量string::npos。string text C is powerful and C is fast.; size_t pos; // 查找第一次出现 pos text.find(C); if (pos ! string::npos) { cout 第一次找到C在位置: pos endl; // 输出 0 } // 从指定位置开始查找 pos text.find(C, 1); // 从索引1开始找 if (pos ! string::npos) { cout 从位置1开始找到C在: pos endl; // 输出 17 } // 查找字符 pos text.find(p); // 查找字符p cout 字符p首次出现位置: pos endl; // 输出 8 // 反向查找从后往前 pos text.rfind(is); // 找最后一个is cout 最后一个is在位置: pos endl; // 输出 22 // 查找首次出现的任意一个指定字符 pos text.find_first_of(aeiou); // 找第一个元音字母 cout 第一个元音字母在位置: pos endl; // 输出 i在位置5 // 检查是否找到 if (text.find(Java) string::npos) { cout 字符串中不包含Java endl; }2.3 字符串比较与连接运算符重载的优雅体现C的string类重载了全套的关系运算符,!,,,,和连接运算符,这使得字符串操作变得异常直观和简洁。string s1 apple; string s2 banana; string s3 apple; // 比较 cout boolalpha; // 让cout输出true/false而不是1/0 cout s1 s3: (s1 s3) endl; // true cout s1 ! s2: (s1 ! s2) endl; // true cout s1 s2: (s1 s2) endl; // true按字典序比较 cout s2 s1: (s2 s1) endl; // true // 连接 string greeting Hello, string(World) !; // 注意Hello, World 是错误的因为两个字符串字面量不能直接相加 greeting Have a nice day.; cout greeting endl; // Hello, World! Have a nice day.注意事项operator在连接字符串时会生成新的临时对象。如果在循环中进行大量字符串连接如result result something;会因为反复的内存分配、拷贝和释放导致性能低下。这种情况下应该使用运算符或者使用std::ostringstream或者在C11之后使用append()方法它们性能更好。2.4 获取子串与字符串转换数据交换的桥梁substr方法用于提取子串它不会修改原字符串而是返回一个新的string对象。string filename project_backup_20231015.tar.gz; // 提取文件名不含路径和最后一个扩展名 size_t lastSlash filename.find_last_of(/); // 假设有路径这里没找到返回npos size_t lastDot filename.find_last_of(.); if (lastDot ! string::npos) { // 提取从开始到最后一个点之前的部分 string nameWithoutExt filename.substr(0, lastDot); // 提取扩展名 string extension filename.substr(lastDot 1); cout 主文件名: nameWithoutExt endl; // project_backup_20231015.tar cout 扩展名: extension endl; // gz } // substr 两个参数起始位置长度可选默认为到结尾 string dateStr 2023-10-15; string year dateStr.substr(0, 4); // 2023 string month dateStr.substr(5, 2); // 10 string day dateStr.substr(8, 2); // 15与C语言及其他API交互时经常需要与const char*和char数组转换。string cppStr Modern C; // string - const char* (C风格字符串) const char* cStyleStr cppStr.c_str(); // 最常用用于传入需要只读字符串的C函数 const char* dataPtr cppStr.data(); // C17前与c_str()基本一致C17后返回非const指针 // string - char* (可修改的缓冲区) —— 危险操作 // 直接获取内部指针并修改是未定义行为因为string可能采用写时复制等优化。 // 正确做法是拷贝到自己的缓冲区。 char buffer[100]; strcpy(buffer, cppStr.c_str()); // 确保buffer足够大 // 数字与字符串互转 (C11) int num 42; string numStr to_string(num); // 42 double pi 3.14159; string piStr to_string(pi); // 3.141590 string countStr 100; int count stoi(countStr); // 100 string floatStr 3.14; float fval stof(floatStr); // 3.14f踩坑记录c_str()返回的指针在字符串对象被修改或销毁后就会失效。一个典型错误是const char* p someString.c_str(); someString.append(more); cout p;此时p可能指向已失效的内存。如果需要持久化这个C字符串应该用strcpy拷贝到自己的内存中。3. 深入原理为什么string类需要我们自己实现在开始写代码之前我们必须想清楚一个根本问题C语言用char array和\0不是也能处理字符串吗为什么还需要一个string类我们实现它究竟要解决哪些痛点3.1 C风格字符串的“七宗罪”手动内存管理你必须精确计算字符串长度用malloc/new分配用free/delete释放稍有不慎就会内存泄漏或重复释放。缓冲区溢出strcpy,strcat等函数不检查目标缓冲区大小是安全漏洞的温床。长度计算低效strlen需要遍历整个字符串直到找到\0时间复杂度是 O(n)。修改繁琐插入、删除字符需要手动移动后面所有的字符极易出错。深拷贝陷阱直接赋值char*只是拷贝了指针两个变量指向同一块内存一个修改会影响另一个真正的拷贝需要手动strcpy。比较不便不能用比较内容必须用strcmp。资源释放责任不清谁分配谁释放在函数间传递时这个责任链很容易断裂。std::string的设计正是通过类的封装和RAIIResource Acquisition Is Initialization思想来自动化地解决所有这些问题。RAII是C的核心哲学简单说就是在构造函数中获取资源如分配内存在析构函数中释放资源。这样只要对象生命周期结束资源必定被释放杜绝了内存泄漏。3.2 我们的MyString类设计蓝图我们不追求一次性实现标准库的全部复杂功能比如迭代器、分配器、SSO短字符串优化等而是聚焦于最核心的机制设计一个简化版的MyString。它需要具备以下核心特征封装一个动态字符数组内部使用char* m_data指针来管理堆上的字符数组并在末尾存储\0。记录自身长度用一个size_t m_size成员变量记录字符串的实际长度不含\0这样求长度就是 O(1) 操作。记录容量用一个size_t m_capacity记录当前分配的内存能容纳多少字符不含\0这是为了减少频繁重新分配realloc的开销即容量capacity通常大于等于大小size。实现六大基本函数这是C类设计的基石。构造函数初始化对象分配内存。拷贝构造函数实现深拷贝防止两个对象共享内存。拷贝赋值运算符同样需要深拷贝并且要处理自赋值和释放旧内存。移动构造函数C11提升性能转移资源所有权。移动赋值运算符C11同上。析构函数释放m_data指向的内存。实现常用操作如c_str(),length(),append(),operator[],operator,operator等。这个设计蓝图就是我们接下来编码的“施工图”。4. MyString类核心实现从构造函数到运算符重载现在我们进入最激动人心的环节动手实现MyString。我会将完整的代码拆解开来并逐段解释其背后的设计决策和注意事项。4.1 类的声明与基础成员首先我们定义类的框架和私有成员。// MyString.h #ifndef MYSTRING_H #define MYSTRING_H #include cstddef // for size_t #include iostream class MyString { private: char* m_data; // 指向堆上字符数组的指针 size_t m_size; // 字符串当前长度不含\0 size_t m_capacity; // 当前分配的内存容量不含\0 // 一个内部工具函数用于确保有足够容量 void reserve(size_t new_capacity); public: // ---------- 六大基本函数 ---------- // 1. 默认构造函数 MyString(); // 2. 从C风格字符串构造 MyString(const char* cstr); // 3. 拷贝构造函数 MyString(const MyString other); // 4. 拷贝赋值运算符 MyString operator(const MyString other); // 5. 析构函数 ~MyString(); // ---------- 基础功能接口 ---------- // 获取C风格字符串 const char* c_str() const; // 获取长度 size_t size() const; size_t length() const; // 通常与size()相同 // 判断是否为空 bool empty() const; // 获取容量 size_t capacity() const; // ---------- 操作函数 ---------- // 追加字符串 MyString append(const char* str); MyString append(const MyString str); // 清空字符串 void clear(); // 访问/修改字符不检查边界 char operator[](size_t index); const char operator[](size_t index) const; // ---------- 运算符重载 ---------- // 连接运算符 MyString operator(const MyString rhs) const; // 复合赋值运算符 MyString operator(const MyString rhs); // 比较运算符 bool operator(const MyString rhs) const; bool operator!(const MyString rhs) const; // ---------- 友元函数 ---------- // 输出流运算符重载方便用cout打印 friend std::ostream operator(std::ostream os, const MyString str); }; #endif // MYSTRING_H关键点解析私有成员m_data,m_size,m_capacity是核心。我们将字符串长度和容量存储下来避免了每次求长度都要遍历的消耗。reserve私有方法这是一个内部辅助函数用于预分配内存。很多操作如append都需要检查容量是否足够不够则扩容。将其独立出来符合代码复用原则。两个operator[]一个返回char允许修改一个返回const char用于 const 对象这是重载运算符的常见做法。友元函数operator为了能直接cout myString我们需要重载输出流运算符因为它需要访问MyString的私有成员m_data所以声明为友元。4.2 内存管理基石构造、拷贝与析构这是整个类的灵魂所在也是最容易出错的地方。// MyString.cpp (部分) #include MyString.h #include cstring // for strlen, strcpy, strcmp #include algorithm // for std::swap (C11) // 工具函数分配内存并初始化为空字符串 static char* allocate_and_copy(const char* src, size_t len) { if (src nullptr) len 0; char* dest new char[len 1]; // 多分配1个字节给\0 if (len 0) { std::strcpy(dest, src); } else { dest[0] \0; } return dest; } // 1. 默认构造函数 MyString::MyString() : m_data(new char[1]), m_size(0), m_capacity(0) { m_data[0] \0; // 空字符串 } // 2. 从C风格字符串构造 MyString::MyString(const char* cstr) { if (cstr) { m_size std::strlen(cstr); m_capacity m_size; m_data allocate_and_copy(cstr, m_size); } else { // 处理空指针构造一个空字符串 m_size 0; m_capacity 0; m_data new char[1]; m_data[0] \0; } } // 3. 拷贝构造函数深拷贝 MyString::MyString(const MyString other) { m_size other.m_size; m_capacity other.m_capacity; m_data allocate_and_copy(other.m_data, m_size); } // 4. 拷贝赋值运算符深拷贝并处理自赋值 MyString MyString::operator(const MyString other) { // 1. 防止自赋值a a; if (this other) { return *this; } // 2. 释放当前对象持有的旧内存 delete[] m_data; // 3. 分配新内存并拷贝数据 m_size other.m_size; m_capacity other.m_capacity; m_data allocate_and_copy(other.m_data, m_size); // 4. 返回当前对象的引用以支持链式赋值 a b c; return *this; } // 5. 析构函数 MyString::~MyString() { delete[] m_data; // 释放堆内存 // 良好的习惯将指针置空防止悬空指针虽然对象即将销毁 m_data nullptr; m_size 0; m_capacity 0; }深度解构“为什么”为什么默认构造函数要分配1字节为了统一性。m_data必须指向一个合法的、以\0结尾的字符数组。分配1字节并存入\0使得c_str()总能返回一个有效的C字符串即使它是空的。也可以选择让m_data为nullptr但这样c_str()就需要返回一个静态的空字符串常量实现稍复杂。拷贝构造与拷贝赋值的区别拷贝构造函数是创建新对象时被调用如MyString s2(s1);或MyString s2 s1;注意这是初始化不是赋值。拷贝赋值运算符是对象已存在用另一个对象的值来覆盖它如s2 s1;。拷贝赋值必须处理自赋值和释放旧资源而拷贝构造不需要因为新对象还没有资源。为什么拷贝赋值要检查自赋值如果不检查a a;这样的语句会先delete[] m_data;把自身的内存释放掉然后试图从other.m_data也就是刚刚被释放的内存拷贝数据这会导致未定义行为通常是程序崩溃。为什么析构函数里delete[]而不是delete因为m_data是通过new char[...]分配的数组必须用数组形式的delete[]来释放以确保调用每个数组元素的析构函数对于基本类型char没区别但对于类对象至关重要。用错会导致内存泄漏。实操心得拷贝交换Copy-and-Swap惯用法上面实现的拷贝赋值运算符是“经典写法”但它不是异常安全的。如果在allocate_and_copy中new失败抛出异常此时m_data已经被释放对象处于无效状态。更健壮的写法是“拷贝交换”MyString MyString::operator(MyString other) { // 注意参数是值传递会调用拷贝构造 swap(*this, other); // 交换当前对象和临时对象other的内容 return *this; } // 临时对象other离开作用域其析构函数会释放旧的资源这需要实现一个swap成员函数或友元函数。它天然是异常安全的并且自动处理了自赋值。这是现代C中更推崇的实现方式。4.3 容量管理reserve与动态扩容字符串在追加内容时如果当前容量不够就需要重新分配更大的内存。这是一个关键的性能优化点。// MyString.cpp (续) void MyString::reserve(size_t new_capacity) { if (new_capacity m_capacity) { return; // 请求的容量不大于当前容量什么都不做 } // 常见的扩容策略不是每次只加1而是按几何级数增长例如翻倍 // 这能保证多次append的平摊时间复杂度是O(n)而不是O(n^2) size_t actual_new_capacity new_capacity; // 一个简单的策略至少翻倍避免频繁扩容 if (new_capacity m_capacity * 2) { actual_new_capacity m_capacity * 2; } // 如果这是第一次分配m_capacity0确保至少分配一些空间 if (actual_new_capacity 0) { actual_new_capacity 16; // 一个常见的初始容量 } // 分配新内存 char* new_data new char[actual_new_capacity 1]; // 1 for \0 // 拷贝旧数据 if (m_data) { std::strcpy(new_data, m_data); } else { new_data[0] \0; } // 释放旧内存 delete[] m_data; // 更新指针和容量 m_data new_data; m_capacity actual_new_capacity; // m_size 不变 }扩容策略的学问如果每次append一个字符就重新分配刚好够大的内存那么连续appendn个字符的时间复杂度将是 O(123...n) O(n²)这是不可接受的。倍增策略或按1.5倍增长是标准库容器的通用做法。虽然它可能浪费一些内存平均浪费约25%-50%但将平摊时间复杂度降到了 O(n)是典型的“空间换时间”。4.4 常用功能实现append, operator[], 比较与连接有了reserve实现其他功能就相对简单了。// MyString.cpp (续) size_t MyString::size() const { return m_size; } size_t MyString::length() const { return m_size; } bool MyString::empty() const { return m_size 0; } size_t MyString::capacity() const { return m_capacity; } const char* MyString::c_str() const { return m_data ? m_data : ; } char MyString::operator[](size_t index) { // 注意这里没有进行边界检查使用者必须确保 index m_size // 标准库的 operator[] 也不检查追求性能。 return m_data[index]; } const char MyString::operator[](size_t index) const { return m_data[index]; } MyString MyString::append(const char* str) { if (str nullptr || str[0] \0) { return *this; // 追加空字符串直接返回 } size_t append_len std::strlen(str); size_t new_size m_size append_len; // 确保容量足够 if (new_size m_capacity) { reserve(new_size); } // 将新字符串拷贝到原字符串的末尾 std::strcpy(m_data m_size, str); // strcpy会自动复制结尾的\0 m_size new_size; return *this; // 支持链式调用 s.append(a).append(b); } MyString MyString::append(const MyString str) { return append(str.c_str()); } void MyString::clear() { // 并不释放内存只是将字符串置空 if (m_data) { m_data[0] \0; } m_size 0; // m_capacity 保持不变便于后续重用 } // 连接运算符返回一个新对象 MyString MyString::operator(const MyString rhs) const { MyString result(*this); // 拷贝当前对象 result.append(rhs); // 追加rhs return result; // 返回新对象可能会触发返回值优化RVO } // 复合赋值运算符 MyString MyString::operator(const MyString rhs) { append(rhs); return *this; } // 比较运算符 bool MyString::operator(const MyString rhs) const { if (m_size ! rhs.m_size) { return false; // 长度不同肯定不等 } return std::strcmp(m_data, rhs.m_data) 0; } bool MyString::operator!(const MyString rhs) const { return !(*this rhs); } // 输出流运算符 std::ostream operator(std::ostream os, const MyString str) { if (str.m_data) { os str.m_data; } return os; }实现细节剖析operator[]的边界问题我们选择了和标准库一致的不检查策略。如果需要安全版本可以实现一个at(size_t)函数并在其中抛出异常。append的效率先计算新长度再检查扩容最后用strcpy拷贝。strcpy会拷贝源字符串的\0所以我们不需要手动添加。operator与operator返回一个新对象是“值语义”修改自身并返回引用是“复合赋值”。的实现通常借助或拷贝构造加append。注意operator通常应该实现为全局函数以支持hello myStr这样的操作但为了简化我们这里只实现了成员函数版本。clear()的设计它不释放内存只将大小设为0并在开头放\0。这符合“清空字符串但保留容量”的常见需求避免下次添加字符时立即重新分配。5. 测试与验证让我们的MyString跑起来写完了代码必须进行全面的测试。我们写一个简单的测试程序来验证核心功能。// test_mystring.cpp #include MyString.h #include iostream #include cassert void test_construction() { std::cout 测试构造 std::endl; MyString s1; // 默认构造 assert(s1.size() 0); assert(std::strcmp(s1.c_str(), ) 0); std::cout s1: \ s1 \ (size s1.size() ) std::endl; MyString s2(Hello); // C字符串构造 assert(s2.size() 5); assert(std::strcmp(s2.c_str(), Hello) 0); std::cout s2: \ s2 \ (size s2.size() ) std::endl; MyString s3(s2); // 拷贝构造 assert(s3 s2); s2[0] h; // 修改s2不应影响s3深拷贝测试 assert(s3[0] H); std::cout s2 after modify: \ s2 \ std::endl; std::cout s3 (copy of original s2): \ s3 \ std::endl; } void test_assignment() { std::cout \n 测试赋值 std::endl; MyString s1(Original); MyString s2; s2 s1; // 拷贝赋值 assert(s2 s1); s1 s1; // 自赋值不应崩溃 assert(s1 MyString(Original)); std::cout s1: \ s1 \ std::endl; std::cout s2 after s2 s1: \ s2 \ std::endl; } void test_append_and_operator() { std::cout \n 测试追加与运算符 std::endl; MyString s(Hello); s.append(, ); s.append(MyString(World)); s !; assert(s MyString(Hello, World!)); std::cout After append and : \ s \ std::endl; MyString s2 MyString(C) is powerful; // 测试连接注意字面量需要隐式转换 // 实际上上面的代码需要MyString有相应的构造函数这里为了测试我们分步写 MyString part1(C); MyString part2( is ); MyString part3(powerful); MyString s3 part1 part2 part3; std::cout s3 (part1part2part3): \ s3 \ std::endl; } void test_access_and_compare() { std::cout \n 测试访问与比较 std::endl; MyString s(ABCD); assert(s[0] A); s[0] a; // 非const版本应允许修改 assert(s[0] a); std::cout After s[0]a: \ s \ std::endl; const MyString cs(ConstString); assert(cs[0] C); // const版本用于只读访问 // cs[0] c; // 这行如果取消注释应该编译报错 assert(MyString(abc) MyString(abc)); assert(MyString(abc) ! MyString(abcd)); std::cout Comparison tests passed. std::endl; } void test_capacity() { std::cout \n 测试容量管理 std::endl; MyString s; std::cout Empty string capacity: s.capacity() std::endl; for (int i 0; i 30; i) { s.append(x); if (i 5 || i 10 || i 20 || i 29) { std::cout After append (i1) chars, size s.size() , capacity s.capacity() std::endl; } } // 观察输出容量应该是按某种策略如翻倍增长的 } int main() { test_construction(); test_assignment(); test_append_and_operator(); test_access_and_compare(); test_capacity(); std::cout \n 所有测试通过 std::endl; return 0; }编译并运行这个测试程序例如g -stdc11 -o test test_mystring.cpp MyString.cpp你应该能看到各个功能的输出并且程序不会崩溃或断言失败。通过测试我们验证了MyString类的深拷贝、赋值、追加、比较等核心功能的正确性。6. 常见问题、陷阱与进阶思考在实现和使用字符串类的过程中你会遇到各种各样的问题。这里我总结了一些典型的“坑”和进阶知识点。6.1 内存相关陷阱排查表问题现象可能原因解决方案程序崩溃Segmentation fault1. 访问了未初始化的m_data如拷贝构造未正确分配内存。2. 访问越界operator[]索引超出m_size。3. 使用了已释放的内存悬空指针如在c_str()返回的指针后修改了字符串。1. 检查所有构造函数是否都正确初始化了m_data。2. 在operator[]中添加断言assert(index m_size)调试或使用带检查的at()函数。3. 记住c_str()返回的指针在字符串修改后可能失效如需持久化请拷贝。内存泄漏1. 析构函数未delete[] m_data。2. 拷贝赋值运算符中在分配新内存前忘记释放旧内存。3. 在重新分配内存reserve时忘记释放旧内存。1. 确保析构函数正确释放资源。2. 遵循“先分配新再释放旧最后替换指针”或使用“拷贝交换”惯用法。3. 使用工具如 Valgrind (Linux) 或 Dr. Memory (Windows) 检测内存泄漏。数据损坏或奇怪输出1. 深拷贝失败两个对象共享同一块内存一个修改影响另一个。2. 字符串末尾忘记添加\0。3.strcpy等函数操作了重叠的内存区域未定义行为。1. 仔细检查拷贝构造函数和拷贝赋值运算符确保是真正的内存拷贝。2. 在所有修改字符串长度的操作后确保m_data[m_size] \0。3. 避免对m_data及其偏移进行可能重叠的拷贝必要时用memmove。自赋值导致崩溃在拷贝赋值运算符operator中直接delete[] m_data然后从other.m_data拷贝而other就是自己。在operator开头添加自赋值检查if (this other) return *this;6.2 性能优化与进阶特性我们实现的MyString是一个教学版本而std::string在实际实现中做了大量优化短字符串优化SSO, Small String Optimization对于很短的字符串例如15字节以内直接将其存储在对象自身的栈内存中而不是堆上。这避免了小字符串动态分配的开销极大地提升了性能。这是现代std::string实现如GCC、Clang的libc的标配。写时复制COW, Copy-On-Write一些旧的实现如GCC 4.x之前的libstdc采用此技术。多个string对象可以共享同一块内存只有当某个对象需要修改内容时才真正进行拷贝。这能节省内存和拷贝时间但在多线程环境下需要复杂的同步机制因此C11后的标准库通常不再使用COW因为移动语义提供了更好的性能保证。移动语义C11我们只实现了基本的拷贝控制函数。完整的实现还应该包括移动构造函数和移动赋值运算符。它们通过“窃取”临时对象右值的资源来避免不必要的深拷贝对于提升返回MyString的函数性能至关重要。异常安全我们的reserve和拷贝赋值在new失败时会抛出std::bad_alloc异常。需要确保在异常发生时对象仍处于有效状态基本保证或不变状态强保证。拷贝交换惯用法提供了强异常安全保证。6.3 关于迭代器与算法兼容性标准库的string提供了迭代器begin(),end()使其能与algorithm中的泛型算法如std::sort,std::find无缝协作。为我们的MyString添加迭代器支持是一个很好的进阶练习你需要定义iterator和const_iterator类型并实现相应的begin(),end()等方法迭代器本质上可以就是一个char*的包装。实现一个完整的string类是一项庞大的工程但通过这个简化版的实现你已经抓住了最核心的精髓RAII管理资源、深拷贝与浅拷贝的区别、运算符重载的语法、以及动态数组的基本管理。下次当你在代码中轻松写下std::string s hello;时你会对背后发生的所有事情有更深刻的理解。这才是学习C乃至任何系统编程语言的正确方式——不仅会用更要理解其背后的机制。
1. 项目概述为什么从string类开始你的C进阶之路如果你已经学完了C的基础语法比如变量、循环、判断甚至接触了指针和数组那么恭喜你你已经推开了C世界的大门。但接下来很多人会陷入一个迷茫期感觉知识点都懂但一上手写稍微复杂点的程序就无从下手代码写得又长又乱还总出内存错误。这时候你需要一个能串联起你所有零散知识并带你真正理解C“面向对象”和“资源管理”核心思想的练手项目。在我看来亲手实现一个简化版的std::string类就是这个阶段最完美的“毕业设计”。std::string是C标准库中使用频率最高的类之一它封装了动态字符数组让我们能像操作基本类型一样方便地处理文本。但它的便利背后隐藏着C几乎所有的核心难点动态内存管理、深拷贝与浅拷贝、构造函数与析构函数RAII思想、运算符重载、迭代器概念等等。很多面试官喜欢问string类的实现不是因为它偏门恰恰是因为它太经典能全面考察一个C程序员的基本功是否扎实。所以这个系列的第11篇我们不只满足于教你如何使用std::string的find、substr这些API那是语法手册的工作我们要做两件更有价值的事第一系统梳理string类的基本语法和常用方法让你知其然第二也是更重要的带你从零开始一步步实现一个我们自己的MyString类。在这个过程中你会真切地体会到那些书本上枯燥的概念是如何在代码中“活”过来的。当你成功运行起自己写的字符串类并让它和标准库的string一样工作时你对C的理解会上升一个全新的层次。2. string类基本语法与核心操作全解析在动手造轮子之前我们必须先彻底了解这个轮子应该长什么样、怎么用。std::string是一个功能极其丰富的类但我们先从最核心、最常用的部分开始掌握。2.1 对象的创建与初始化多种姿势各有讲究创建字符串对象C提供了多种构造函数对应不同的使用场景。#include iostream #include string using namespace std; int main() { // 1. 默认构造创建一个空字符串 string emptyStr; cout 空字符串: \ emptyStr \, 长度: emptyStr.length() endl; // 2. 用C风格字符串初始化 const char* cstr Hello, C; string strFromC(cstr); cout 从C字符串构造: strFromC endl; // 3. 用另一个string对象初始化拷贝构造 string copyStr(strFromC); cout 拷贝构造: copyStr endl; // 4. 用部分字符序列初始化 string partStr(Hello World, 5); // 取前5个字符 Hello cout 部分构造: partStr endl; // 5. 填充n个相同字符 string repeatStr(10, A); // AAAAAAAAAA cout 重复字符构造: repeatStr endl; // 6. 使用初始化列表 (C11) string initListStr {H, i, !}; cout 初始化列表构造: initListStr endl; return 0; }注意第2种方式string strFromC(cstr);要求传入的C风格字符串必须以空字符\0结尾否则会导致未定义行为如内存越界读取。这是从C过渡到C时一个常见的陷阱。2.2 字符串的“增删改查”像操作数组一样自然string类重载了[]运算符让我们可以像访问数组一样访问和修改字符串中的单个字符。但这里有一个关键区别operator[]不进行边界检查访问越界是未定义行为而.at(index)成员函数会进行边界检查如果越界会抛出std::out_of_range异常。在追求性能的代码中常用[]在需要安全性的场景用.at()。修改操作是字符串处理的核心。append,insert,erase,replace这几个函数功能强大但需要特别注意它们的参数和返回值。string str I learning C; // 追加字符串 str.append( and Python); // str 变为 I learning C and Python str is fun; // 更常用的方式重载了运算符 // 在指定位置插入 str.insert(2, am ); // 在索引2处插入str 变为 I am learning C and Python is fun // 第一个参数是位置第二个是待插入的字符串 // 删除字符 str.erase(0, 4); // 从索引0开始删除4个字符移除 I am 剩下 learning C and Python is fun str.erase(5, 7); // 从索引5i开始删除7个字符移除 ing C要小心计算位置和长度 // 替换子串 str.replace(0, 8, Mastering); // 从索引0开始将8个字符learnin替换为Mastering cout 最终字符串: str endl; // 输出: Mastering C and Python is fun实操心得insert,erase,replace这些会改变字符串长度的操作在内部可能涉及内存的重新分配和大量字符的移动在循环中频繁使用它们尤其是在长字符串的开头进行操作可能会导致性能问题。如果需要在字符串前端进行大量修改有时考虑使用std::dequechar或先反转处理再反转回来可能是更好的选择。查找操作主要依靠find系列函数。它们返回的是匹配子串第一个字符的位置索引类型是size_t。如果没找到则返回一个特殊的常量string::npos。string text C is powerful and C is fast.; size_t pos; // 查找第一次出现 pos text.find(C); if (pos ! string::npos) { cout 第一次找到C在位置: pos endl; // 输出 0 } // 从指定位置开始查找 pos text.find(C, 1); // 从索引1开始找 if (pos ! string::npos) { cout 从位置1开始找到C在: pos endl; // 输出 17 } // 查找字符 pos text.find(p); // 查找字符p cout 字符p首次出现位置: pos endl; // 输出 8 // 反向查找从后往前 pos text.rfind(is); // 找最后一个is cout 最后一个is在位置: pos endl; // 输出 22 // 查找首次出现的任意一个指定字符 pos text.find_first_of(aeiou); // 找第一个元音字母 cout 第一个元音字母在位置: pos endl; // 输出 i在位置5 // 检查是否找到 if (text.find(Java) string::npos) { cout 字符串中不包含Java endl; }2.3 字符串比较与连接运算符重载的优雅体现C的string类重载了全套的关系运算符,!,,,,和连接运算符,这使得字符串操作变得异常直观和简洁。string s1 apple; string s2 banana; string s3 apple; // 比较 cout boolalpha; // 让cout输出true/false而不是1/0 cout s1 s3: (s1 s3) endl; // true cout s1 ! s2: (s1 ! s2) endl; // true cout s1 s2: (s1 s2) endl; // true按字典序比较 cout s2 s1: (s2 s1) endl; // true // 连接 string greeting Hello, string(World) !; // 注意Hello, World 是错误的因为两个字符串字面量不能直接相加 greeting Have a nice day.; cout greeting endl; // Hello, World! Have a nice day.注意事项operator在连接字符串时会生成新的临时对象。如果在循环中进行大量字符串连接如result result something;会因为反复的内存分配、拷贝和释放导致性能低下。这种情况下应该使用运算符或者使用std::ostringstream或者在C11之后使用append()方法它们性能更好。2.4 获取子串与字符串转换数据交换的桥梁substr方法用于提取子串它不会修改原字符串而是返回一个新的string对象。string filename project_backup_20231015.tar.gz; // 提取文件名不含路径和最后一个扩展名 size_t lastSlash filename.find_last_of(/); // 假设有路径这里没找到返回npos size_t lastDot filename.find_last_of(.); if (lastDot ! string::npos) { // 提取从开始到最后一个点之前的部分 string nameWithoutExt filename.substr(0, lastDot); // 提取扩展名 string extension filename.substr(lastDot 1); cout 主文件名: nameWithoutExt endl; // project_backup_20231015.tar cout 扩展名: extension endl; // gz } // substr 两个参数起始位置长度可选默认为到结尾 string dateStr 2023-10-15; string year dateStr.substr(0, 4); // 2023 string month dateStr.substr(5, 2); // 10 string day dateStr.substr(8, 2); // 15与C语言及其他API交互时经常需要与const char*和char数组转换。string cppStr Modern C; // string - const char* (C风格字符串) const char* cStyleStr cppStr.c_str(); // 最常用用于传入需要只读字符串的C函数 const char* dataPtr cppStr.data(); // C17前与c_str()基本一致C17后返回非const指针 // string - char* (可修改的缓冲区) —— 危险操作 // 直接获取内部指针并修改是未定义行为因为string可能采用写时复制等优化。 // 正确做法是拷贝到自己的缓冲区。 char buffer[100]; strcpy(buffer, cppStr.c_str()); // 确保buffer足够大 // 数字与字符串互转 (C11) int num 42; string numStr to_string(num); // 42 double pi 3.14159; string piStr to_string(pi); // 3.141590 string countStr 100; int count stoi(countStr); // 100 string floatStr 3.14; float fval stof(floatStr); // 3.14f踩坑记录c_str()返回的指针在字符串对象被修改或销毁后就会失效。一个典型错误是const char* p someString.c_str(); someString.append(more); cout p;此时p可能指向已失效的内存。如果需要持久化这个C字符串应该用strcpy拷贝到自己的内存中。3. 深入原理为什么string类需要我们自己实现在开始写代码之前我们必须想清楚一个根本问题C语言用char array和\0不是也能处理字符串吗为什么还需要一个string类我们实现它究竟要解决哪些痛点3.1 C风格字符串的“七宗罪”手动内存管理你必须精确计算字符串长度用malloc/new分配用free/delete释放稍有不慎就会内存泄漏或重复释放。缓冲区溢出strcpy,strcat等函数不检查目标缓冲区大小是安全漏洞的温床。长度计算低效strlen需要遍历整个字符串直到找到\0时间复杂度是 O(n)。修改繁琐插入、删除字符需要手动移动后面所有的字符极易出错。深拷贝陷阱直接赋值char*只是拷贝了指针两个变量指向同一块内存一个修改会影响另一个真正的拷贝需要手动strcpy。比较不便不能用比较内容必须用strcmp。资源释放责任不清谁分配谁释放在函数间传递时这个责任链很容易断裂。std::string的设计正是通过类的封装和RAIIResource Acquisition Is Initialization思想来自动化地解决所有这些问题。RAII是C的核心哲学简单说就是在构造函数中获取资源如分配内存在析构函数中释放资源。这样只要对象生命周期结束资源必定被释放杜绝了内存泄漏。3.2 我们的MyString类设计蓝图我们不追求一次性实现标准库的全部复杂功能比如迭代器、分配器、SSO短字符串优化等而是聚焦于最核心的机制设计一个简化版的MyString。它需要具备以下核心特征封装一个动态字符数组内部使用char* m_data指针来管理堆上的字符数组并在末尾存储\0。记录自身长度用一个size_t m_size成员变量记录字符串的实际长度不含\0这样求长度就是 O(1) 操作。记录容量用一个size_t m_capacity记录当前分配的内存能容纳多少字符不含\0这是为了减少频繁重新分配realloc的开销即容量capacity通常大于等于大小size。实现六大基本函数这是C类设计的基石。构造函数初始化对象分配内存。拷贝构造函数实现深拷贝防止两个对象共享内存。拷贝赋值运算符同样需要深拷贝并且要处理自赋值和释放旧内存。移动构造函数C11提升性能转移资源所有权。移动赋值运算符C11同上。析构函数释放m_data指向的内存。实现常用操作如c_str(),length(),append(),operator[],operator,operator等。这个设计蓝图就是我们接下来编码的“施工图”。4. MyString类核心实现从构造函数到运算符重载现在我们进入最激动人心的环节动手实现MyString。我会将完整的代码拆解开来并逐段解释其背后的设计决策和注意事项。4.1 类的声明与基础成员首先我们定义类的框架和私有成员。// MyString.h #ifndef MYSTRING_H #define MYSTRING_H #include cstddef // for size_t #include iostream class MyString { private: char* m_data; // 指向堆上字符数组的指针 size_t m_size; // 字符串当前长度不含\0 size_t m_capacity; // 当前分配的内存容量不含\0 // 一个内部工具函数用于确保有足够容量 void reserve(size_t new_capacity); public: // ---------- 六大基本函数 ---------- // 1. 默认构造函数 MyString(); // 2. 从C风格字符串构造 MyString(const char* cstr); // 3. 拷贝构造函数 MyString(const MyString other); // 4. 拷贝赋值运算符 MyString operator(const MyString other); // 5. 析构函数 ~MyString(); // ---------- 基础功能接口 ---------- // 获取C风格字符串 const char* c_str() const; // 获取长度 size_t size() const; size_t length() const; // 通常与size()相同 // 判断是否为空 bool empty() const; // 获取容量 size_t capacity() const; // ---------- 操作函数 ---------- // 追加字符串 MyString append(const char* str); MyString append(const MyString str); // 清空字符串 void clear(); // 访问/修改字符不检查边界 char operator[](size_t index); const char operator[](size_t index) const; // ---------- 运算符重载 ---------- // 连接运算符 MyString operator(const MyString rhs) const; // 复合赋值运算符 MyString operator(const MyString rhs); // 比较运算符 bool operator(const MyString rhs) const; bool operator!(const MyString rhs) const; // ---------- 友元函数 ---------- // 输出流运算符重载方便用cout打印 friend std::ostream operator(std::ostream os, const MyString str); }; #endif // MYSTRING_H关键点解析私有成员m_data,m_size,m_capacity是核心。我们将字符串长度和容量存储下来避免了每次求长度都要遍历的消耗。reserve私有方法这是一个内部辅助函数用于预分配内存。很多操作如append都需要检查容量是否足够不够则扩容。将其独立出来符合代码复用原则。两个operator[]一个返回char允许修改一个返回const char用于 const 对象这是重载运算符的常见做法。友元函数operator为了能直接cout myString我们需要重载输出流运算符因为它需要访问MyString的私有成员m_data所以声明为友元。4.2 内存管理基石构造、拷贝与析构这是整个类的灵魂所在也是最容易出错的地方。// MyString.cpp (部分) #include MyString.h #include cstring // for strlen, strcpy, strcmp #include algorithm // for std::swap (C11) // 工具函数分配内存并初始化为空字符串 static char* allocate_and_copy(const char* src, size_t len) { if (src nullptr) len 0; char* dest new char[len 1]; // 多分配1个字节给\0 if (len 0) { std::strcpy(dest, src); } else { dest[0] \0; } return dest; } // 1. 默认构造函数 MyString::MyString() : m_data(new char[1]), m_size(0), m_capacity(0) { m_data[0] \0; // 空字符串 } // 2. 从C风格字符串构造 MyString::MyString(const char* cstr) { if (cstr) { m_size std::strlen(cstr); m_capacity m_size; m_data allocate_and_copy(cstr, m_size); } else { // 处理空指针构造一个空字符串 m_size 0; m_capacity 0; m_data new char[1]; m_data[0] \0; } } // 3. 拷贝构造函数深拷贝 MyString::MyString(const MyString other) { m_size other.m_size; m_capacity other.m_capacity; m_data allocate_and_copy(other.m_data, m_size); } // 4. 拷贝赋值运算符深拷贝并处理自赋值 MyString MyString::operator(const MyString other) { // 1. 防止自赋值a a; if (this other) { return *this; } // 2. 释放当前对象持有的旧内存 delete[] m_data; // 3. 分配新内存并拷贝数据 m_size other.m_size; m_capacity other.m_capacity; m_data allocate_and_copy(other.m_data, m_size); // 4. 返回当前对象的引用以支持链式赋值 a b c; return *this; } // 5. 析构函数 MyString::~MyString() { delete[] m_data; // 释放堆内存 // 良好的习惯将指针置空防止悬空指针虽然对象即将销毁 m_data nullptr; m_size 0; m_capacity 0; }深度解构“为什么”为什么默认构造函数要分配1字节为了统一性。m_data必须指向一个合法的、以\0结尾的字符数组。分配1字节并存入\0使得c_str()总能返回一个有效的C字符串即使它是空的。也可以选择让m_data为nullptr但这样c_str()就需要返回一个静态的空字符串常量实现稍复杂。拷贝构造与拷贝赋值的区别拷贝构造函数是创建新对象时被调用如MyString s2(s1);或MyString s2 s1;注意这是初始化不是赋值。拷贝赋值运算符是对象已存在用另一个对象的值来覆盖它如s2 s1;。拷贝赋值必须处理自赋值和释放旧资源而拷贝构造不需要因为新对象还没有资源。为什么拷贝赋值要检查自赋值如果不检查a a;这样的语句会先delete[] m_data;把自身的内存释放掉然后试图从other.m_data也就是刚刚被释放的内存拷贝数据这会导致未定义行为通常是程序崩溃。为什么析构函数里delete[]而不是delete因为m_data是通过new char[...]分配的数组必须用数组形式的delete[]来释放以确保调用每个数组元素的析构函数对于基本类型char没区别但对于类对象至关重要。用错会导致内存泄漏。实操心得拷贝交换Copy-and-Swap惯用法上面实现的拷贝赋值运算符是“经典写法”但它不是异常安全的。如果在allocate_and_copy中new失败抛出异常此时m_data已经被释放对象处于无效状态。更健壮的写法是“拷贝交换”MyString MyString::operator(MyString other) { // 注意参数是值传递会调用拷贝构造 swap(*this, other); // 交换当前对象和临时对象other的内容 return *this; } // 临时对象other离开作用域其析构函数会释放旧的资源这需要实现一个swap成员函数或友元函数。它天然是异常安全的并且自动处理了自赋值。这是现代C中更推崇的实现方式。4.3 容量管理reserve与动态扩容字符串在追加内容时如果当前容量不够就需要重新分配更大的内存。这是一个关键的性能优化点。// MyString.cpp (续) void MyString::reserve(size_t new_capacity) { if (new_capacity m_capacity) { return; // 请求的容量不大于当前容量什么都不做 } // 常见的扩容策略不是每次只加1而是按几何级数增长例如翻倍 // 这能保证多次append的平摊时间复杂度是O(n)而不是O(n^2) size_t actual_new_capacity new_capacity; // 一个简单的策略至少翻倍避免频繁扩容 if (new_capacity m_capacity * 2) { actual_new_capacity m_capacity * 2; } // 如果这是第一次分配m_capacity0确保至少分配一些空间 if (actual_new_capacity 0) { actual_new_capacity 16; // 一个常见的初始容量 } // 分配新内存 char* new_data new char[actual_new_capacity 1]; // 1 for \0 // 拷贝旧数据 if (m_data) { std::strcpy(new_data, m_data); } else { new_data[0] \0; } // 释放旧内存 delete[] m_data; // 更新指针和容量 m_data new_data; m_capacity actual_new_capacity; // m_size 不变 }扩容策略的学问如果每次append一个字符就重新分配刚好够大的内存那么连续appendn个字符的时间复杂度将是 O(123...n) O(n²)这是不可接受的。倍增策略或按1.5倍增长是标准库容器的通用做法。虽然它可能浪费一些内存平均浪费约25%-50%但将平摊时间复杂度降到了 O(n)是典型的“空间换时间”。4.4 常用功能实现append, operator[], 比较与连接有了reserve实现其他功能就相对简单了。// MyString.cpp (续) size_t MyString::size() const { return m_size; } size_t MyString::length() const { return m_size; } bool MyString::empty() const { return m_size 0; } size_t MyString::capacity() const { return m_capacity; } const char* MyString::c_str() const { return m_data ? m_data : ; } char MyString::operator[](size_t index) { // 注意这里没有进行边界检查使用者必须确保 index m_size // 标准库的 operator[] 也不检查追求性能。 return m_data[index]; } const char MyString::operator[](size_t index) const { return m_data[index]; } MyString MyString::append(const char* str) { if (str nullptr || str[0] \0) { return *this; // 追加空字符串直接返回 } size_t append_len std::strlen(str); size_t new_size m_size append_len; // 确保容量足够 if (new_size m_capacity) { reserve(new_size); } // 将新字符串拷贝到原字符串的末尾 std::strcpy(m_data m_size, str); // strcpy会自动复制结尾的\0 m_size new_size; return *this; // 支持链式调用 s.append(a).append(b); } MyString MyString::append(const MyString str) { return append(str.c_str()); } void MyString::clear() { // 并不释放内存只是将字符串置空 if (m_data) { m_data[0] \0; } m_size 0; // m_capacity 保持不变便于后续重用 } // 连接运算符返回一个新对象 MyString MyString::operator(const MyString rhs) const { MyString result(*this); // 拷贝当前对象 result.append(rhs); // 追加rhs return result; // 返回新对象可能会触发返回值优化RVO } // 复合赋值运算符 MyString MyString::operator(const MyString rhs) { append(rhs); return *this; } // 比较运算符 bool MyString::operator(const MyString rhs) const { if (m_size ! rhs.m_size) { return false; // 长度不同肯定不等 } return std::strcmp(m_data, rhs.m_data) 0; } bool MyString::operator!(const MyString rhs) const { return !(*this rhs); } // 输出流运算符 std::ostream operator(std::ostream os, const MyString str) { if (str.m_data) { os str.m_data; } return os; }实现细节剖析operator[]的边界问题我们选择了和标准库一致的不检查策略。如果需要安全版本可以实现一个at(size_t)函数并在其中抛出异常。append的效率先计算新长度再检查扩容最后用strcpy拷贝。strcpy会拷贝源字符串的\0所以我们不需要手动添加。operator与operator返回一个新对象是“值语义”修改自身并返回引用是“复合赋值”。的实现通常借助或拷贝构造加append。注意operator通常应该实现为全局函数以支持hello myStr这样的操作但为了简化我们这里只实现了成员函数版本。clear()的设计它不释放内存只将大小设为0并在开头放\0。这符合“清空字符串但保留容量”的常见需求避免下次添加字符时立即重新分配。5. 测试与验证让我们的MyString跑起来写完了代码必须进行全面的测试。我们写一个简单的测试程序来验证核心功能。// test_mystring.cpp #include MyString.h #include iostream #include cassert void test_construction() { std::cout 测试构造 std::endl; MyString s1; // 默认构造 assert(s1.size() 0); assert(std::strcmp(s1.c_str(), ) 0); std::cout s1: \ s1 \ (size s1.size() ) std::endl; MyString s2(Hello); // C字符串构造 assert(s2.size() 5); assert(std::strcmp(s2.c_str(), Hello) 0); std::cout s2: \ s2 \ (size s2.size() ) std::endl; MyString s3(s2); // 拷贝构造 assert(s3 s2); s2[0] h; // 修改s2不应影响s3深拷贝测试 assert(s3[0] H); std::cout s2 after modify: \ s2 \ std::endl; std::cout s3 (copy of original s2): \ s3 \ std::endl; } void test_assignment() { std::cout \n 测试赋值 std::endl; MyString s1(Original); MyString s2; s2 s1; // 拷贝赋值 assert(s2 s1); s1 s1; // 自赋值不应崩溃 assert(s1 MyString(Original)); std::cout s1: \ s1 \ std::endl; std::cout s2 after s2 s1: \ s2 \ std::endl; } void test_append_and_operator() { std::cout \n 测试追加与运算符 std::endl; MyString s(Hello); s.append(, ); s.append(MyString(World)); s !; assert(s MyString(Hello, World!)); std::cout After append and : \ s \ std::endl; MyString s2 MyString(C) is powerful; // 测试连接注意字面量需要隐式转换 // 实际上上面的代码需要MyString有相应的构造函数这里为了测试我们分步写 MyString part1(C); MyString part2( is ); MyString part3(powerful); MyString s3 part1 part2 part3; std::cout s3 (part1part2part3): \ s3 \ std::endl; } void test_access_and_compare() { std::cout \n 测试访问与比较 std::endl; MyString s(ABCD); assert(s[0] A); s[0] a; // 非const版本应允许修改 assert(s[0] a); std::cout After s[0]a: \ s \ std::endl; const MyString cs(ConstString); assert(cs[0] C); // const版本用于只读访问 // cs[0] c; // 这行如果取消注释应该编译报错 assert(MyString(abc) MyString(abc)); assert(MyString(abc) ! MyString(abcd)); std::cout Comparison tests passed. std::endl; } void test_capacity() { std::cout \n 测试容量管理 std::endl; MyString s; std::cout Empty string capacity: s.capacity() std::endl; for (int i 0; i 30; i) { s.append(x); if (i 5 || i 10 || i 20 || i 29) { std::cout After append (i1) chars, size s.size() , capacity s.capacity() std::endl; } } // 观察输出容量应该是按某种策略如翻倍增长的 } int main() { test_construction(); test_assignment(); test_append_and_operator(); test_access_and_compare(); test_capacity(); std::cout \n 所有测试通过 std::endl; return 0; }编译并运行这个测试程序例如g -stdc11 -o test test_mystring.cpp MyString.cpp你应该能看到各个功能的输出并且程序不会崩溃或断言失败。通过测试我们验证了MyString类的深拷贝、赋值、追加、比较等核心功能的正确性。6. 常见问题、陷阱与进阶思考在实现和使用字符串类的过程中你会遇到各种各样的问题。这里我总结了一些典型的“坑”和进阶知识点。6.1 内存相关陷阱排查表问题现象可能原因解决方案程序崩溃Segmentation fault1. 访问了未初始化的m_data如拷贝构造未正确分配内存。2. 访问越界operator[]索引超出m_size。3. 使用了已释放的内存悬空指针如在c_str()返回的指针后修改了字符串。1. 检查所有构造函数是否都正确初始化了m_data。2. 在operator[]中添加断言assert(index m_size)调试或使用带检查的at()函数。3. 记住c_str()返回的指针在字符串修改后可能失效如需持久化请拷贝。内存泄漏1. 析构函数未delete[] m_data。2. 拷贝赋值运算符中在分配新内存前忘记释放旧内存。3. 在重新分配内存reserve时忘记释放旧内存。1. 确保析构函数正确释放资源。2. 遵循“先分配新再释放旧最后替换指针”或使用“拷贝交换”惯用法。3. 使用工具如 Valgrind (Linux) 或 Dr. Memory (Windows) 检测内存泄漏。数据损坏或奇怪输出1. 深拷贝失败两个对象共享同一块内存一个修改影响另一个。2. 字符串末尾忘记添加\0。3.strcpy等函数操作了重叠的内存区域未定义行为。1. 仔细检查拷贝构造函数和拷贝赋值运算符确保是真正的内存拷贝。2. 在所有修改字符串长度的操作后确保m_data[m_size] \0。3. 避免对m_data及其偏移进行可能重叠的拷贝必要时用memmove。自赋值导致崩溃在拷贝赋值运算符operator中直接delete[] m_data然后从other.m_data拷贝而other就是自己。在operator开头添加自赋值检查if (this other) return *this;6.2 性能优化与进阶特性我们实现的MyString是一个教学版本而std::string在实际实现中做了大量优化短字符串优化SSO, Small String Optimization对于很短的字符串例如15字节以内直接将其存储在对象自身的栈内存中而不是堆上。这避免了小字符串动态分配的开销极大地提升了性能。这是现代std::string实现如GCC、Clang的libc的标配。写时复制COW, Copy-On-Write一些旧的实现如GCC 4.x之前的libstdc采用此技术。多个string对象可以共享同一块内存只有当某个对象需要修改内容时才真正进行拷贝。这能节省内存和拷贝时间但在多线程环境下需要复杂的同步机制因此C11后的标准库通常不再使用COW因为移动语义提供了更好的性能保证。移动语义C11我们只实现了基本的拷贝控制函数。完整的实现还应该包括移动构造函数和移动赋值运算符。它们通过“窃取”临时对象右值的资源来避免不必要的深拷贝对于提升返回MyString的函数性能至关重要。异常安全我们的reserve和拷贝赋值在new失败时会抛出std::bad_alloc异常。需要确保在异常发生时对象仍处于有效状态基本保证或不变状态强保证。拷贝交换惯用法提供了强异常安全保证。6.3 关于迭代器与算法兼容性标准库的string提供了迭代器begin(),end()使其能与algorithm中的泛型算法如std::sort,std::find无缝协作。为我们的MyString添加迭代器支持是一个很好的进阶练习你需要定义iterator和const_iterator类型并实现相应的begin(),end()等方法迭代器本质上可以就是一个char*的包装。实现一个完整的string类是一项庞大的工程但通过这个简化版的实现你已经抓住了最核心的精髓RAII管理资源、深拷贝与浅拷贝的区别、运算符重载的语法、以及动态数组的基本管理。下次当你在代码中轻松写下std::string s hello;时你会对背后发生的所有事情有更深刻的理解。这才是学习C乃至任何系统编程语言的正确方式——不仅会用更要理解其背后的机制。
![[C++]内存管理：串顺序存储的内存回收](http://pic.xiahunao.cn/yaotu/[C++]内存管理：串顺序存储的内存回收)
