C语言字符串操作实战：利用strstr与memmove高效删除子串

1. 项目概述：一个看似简单却暗藏玄机的字符串操作

今天想聊一个在C语言学习和面试中高频出现，但又常常被轻视的经典问题：如何实现删除字符串中的指定子串。乍一看，这问题简单得有点“小儿科”——不就是找到子串，然后把后面的字符往前挪吗？很多新手朋友可能随手就能写个循环嵌套，觉得大功告成。但如果你真这么想，那可能就错过了理解C语言字符串操作精髓，以及提升代码健壮性和效率的绝佳机会。

这个项目标题“用C语言实现删除字符串中的子串+C 库函数：strstr()、memmove()、strcpy()、memset()、strlen()”已经为我们指明了核心：它不仅仅是一个功能实现，更是一次对C标准库中几个关键字符串/内存操作函数的深度理解和综合运用实战。strstr负责查找，memmove负责安全地“搬运”内存，strcpy和memset看似简单却各有适用场景，strlen则是我们操作的基础尺子。把这些函数像乐高积木一样正确、高效地组合起来，解决一个实际问题，远比单独背诵它们的函数原型有意义得多。

无论是正在啃《C语言程序设计》的学生，准备技术面试的求职者，还是希望夯实基础的开发者，通过亲手实现这个功能并深入理解背后的“为什么”，你都能获得远超代码本身的收获：对指针、内存布局、函数边界条件的深刻认知，以及写出既正确又优雅的C代码的能力。我们这就开始，一步步拆解这个“麻雀虽小，五脏俱全”的经典案例。

2. 核心思路拆解与方案选型

在动手写代码之前，我们必须把问题想清楚。删除字符串中子串，本质上是一个查找并覆盖的过程。假设我们有一个源字符串src和一个待删除的子串sub，我们需要在src中找出所有sub出现的位置，然后将该位置之后的所有字符（不包括被删除的子串）向前移动，覆盖掉这个子串。

2.1 为什么不能简单地用循环和指针“硬挪”？

很多初学者的第一反应是写两层循环：外层遍历字符串，内层比较子串。一旦匹配成功，就用另一个循环把后面的字符逐个向前赋值。这个方法在逻辑上可行，但存在几个明显问题：

1. 效率低下：每次删除（哪怕只删除一个字符）都可能引发大量字符的逐个移动，时间复杂度在最坏情况下会接近 O(n*m)。
2. 代码冗长易错：需要手动处理字符串结束符\0，指针的加减运算稍有不慎就会导致越界或错误。
3. 未充分利用标准库：C标准库提供了高度优化、久经考验的函数，重复造轮子不仅增加工作量，还容易引入bug。

2.2 基于标准库的高效方案设计

标题给出的函数列表就是我们的“工具箱”。一个高效且健壮的方案流程如下：

1. 查找定位：使用strstr()函数在源字符串中查找子串首次出现的位置。这是整个算法的“眼睛”。
2. 计算长度：使用strlen()获取源字符串和子串的长度，为后续内存移动提供精确计量。
3. 安全移除：找到子串后，需要将子串之后的部分整体前移。这里的关键是不能使用strcpy()，因为源和目的内存区域可能存在重叠（我们正是要把后面的内容拷贝到前面来）。此时必须使用memmove()，它是专门为处理重叠内存区域拷贝而设计的。
4. 循环与结束：完成一次删除后，在新的字符串中继续查找子串（因为删除后可能产生了新的匹配），直到strstr()返回NULL，表示已无更多子串。
5. 结果输出：最终，源字符串缓冲区中的内容就是删除所有子串后的结果。

这个方案将时间复杂度优化到了接近 O(n)，因为strstr和memmove的实现通常都经过高度优化，并且我们避免了嵌套循环内的逐个字符操作。

注意：这里我们明确排除了使用strcpy()来执行删除操作。strcpy(dest, src)在dest和src内存区域重叠时行为是未定义的，极有可能导致错误结果或程序崩溃。这是一个非常重要的知识点。

3. 核心函数深度解析与避坑指南

在实现之前，我们必须吃透这几个核心函数，了解它们的脾气秉性，否则极易踩坑。

3.1 strstr() – 字符串查找器

char *strstr(const char *haystack, const char *needle);这个函数在haystack（干草堆）中查找needle（针）第一次出现的位置，返回指向该位置的指针；如果没找到，返回NULL。

关键点与避坑：

• 参数检查：虽然标准规定传入NULL指针行为未定义，但健壮的代码应该自己检查。如果needle是空字符串，根据C99标准，应返回haystack。
• 返回值的使用：返回的指针指向的是haystack中匹配开始的位置。我们需要保存这个指针，因为它决定了从哪里开始删除。
• 查找的连续性：在一次删除操作后，下一次查找的起点应该是当前删除操作完成后的新字符串的当前位置，而不是简单地从之前找到的位置后继续。因为字符串内容已经改变了。

3.2 memmove() vs memcpy() & strcpy() – 内存搬运大师

void *memmove(void *dest, const void *src, size_t n);这是本项目的灵魂函数。它的作用是从src指向的内存地址拷贝n个字节到dest指向的内存地址。它与memcpy()的关键区别在于，memmove()会先将源数据拷贝到一个临时缓冲区，然后再拷贝到目标地址，从而安全地处理源和目标内存区域重叠的情况。而memcpy()则假定它们不重叠，重叠时行为未定义。

为什么这里必须用memmove？假设字符串是“hello world”，要删除“lo”。找到“lo”在位置p。我们需要把p+2（即” world”的起始位置）开始的内容，移动到p的位置。源（p+2）和目标（p）是重叠的！memcpy(p, p+2, len)会导致数据损坏。而memmove能正确处理这种情况。

参数计算：n应该拷贝多少字节？应该是子串之后剩余字符串的长度 + 1（包括结尾的\0）。我们可以用strlen(found_position + sub_len)来获取剩余字符串长度，然后+1来包含\0。

3.3 strlen() – 长度测量员

size_t strlen(const char *str);返回字符串长度，不包括结尾的\0。这个函数看似简单，但要注意它是通过遍历字符串直到遇到\0来计数的，时间复杂度是 O(n)。在循环中频繁调用strlen可能成为性能瓶颈。在本项目中，我们可以在循环开始前获取一次子串长度，在循环内根据需要计算剩余部分长度。

3.4 strcpy() 和 memset() – 本项目的“配角”

在本项目的核心删除逻辑中，strcpy()并不适用，原因已述。memset()通常用于将一段内存设置为特定的值。在本项目中，一个可能的用法是在删除子串后，将字符串末尾空出来的部分（如果有的话）用\0填充，以确保字符串正确终止，并且避免残留的旧字符造成混淆。但这并非必须，因为memmove已经将末尾的\0一并移动了。

4. 分步实现与代码精讲

理论清晰后，我们开始动手实现。我将提供一个完整、健壮且带有详细注释的版本。

4.1 函数接口设计

首先，明确我们的函数原型。由于C语言中字符串通常存储在字符数组中，我们的操作会直接修改传入的缓冲区。一个经典的接口设计是：void delete_substr(char *str, const char *sub);

• str：指向待处理的字符串缓冲区的指针。函数将直接修改这块内存。
• sub：指向待删除子串的指针。

这个设计简单直接，但调用者必须确保str指向的缓冲区足够大且可修改（即不能是字符串常量）。

4.2 完整实现代码

#include <stdio.h> #include <string.h> #include <assert.h> /** * @brief 从字符串 str 中删除所有子串 sub 的出现。 * @param str 待处理的字符串（会被修改）。 * @param sub 待删除的子串。 * @note 该函数直接修改传入的 str 缓冲区。 */ void delete_all_substr(char *str, const char *sub) { // 防御性编程：检查输入指针是否有效 if (str == NULL || sub == NULL) { return; // 或进行错误处理，如 fprintf(stderr, "Invalid input\n"); } size_t sub_len = strlen(sub); // 如果子串为空，则无需任何操作（根据strstr语义，空串被视为匹配开头） if (sub_len == 0) { return; } // 主循环：持续查找并删除，直到字符串中不再包含子串 char *pos = NULL; while ((pos = strstr(str, sub)) != NULL) { // 计算需要移动的尾部字符串的起始位置和长度 char *tail_start = pos + sub_len; // 子串之后的部分 size_t tail_len = strlen(tail_start) + 1; // +1 为了包含结尾的 '\0' // 使用 memmove 安全地重叠内存拷贝 memmove(pos, tail_start, tail_len); // 注意：删除后，str 的内容已经改变，循环条件中的 strstr 会基于新字符串继续查找 } } /** * @brief 从字符串 str 中删除子串 sub 的第一次出现。 * @param str 待处理的字符串（会被修改）。 * @param sub 待删除的子串。 * @return 指向删除操作后字符串的指针（通常就是 str）。如果未找到子串，返回原 str。 */ char *delete_first_substr(char *str, const char *sub) { if (str == NULL || sub == NULL) { return str; } char *pos = strstr(str, sub); if (pos != NULL) { size_t sub_len = strlen(sub); size_t tail_len = strlen(pos + sub_len) + 1; memmove(pos, pos + sub_len, tail_len); } return str; }

4.3 代码逐行精讲与避坑点

1. 输入验证：if (str == NULL || sub == NULL) return;这是健壮代码的第一步。直接操作空指针会导致程序崩溃。
2. 处理空子串：if (sub_len == 0) return;这是一个边界条件。strstr(str, "")通常会返回str，这会导致无限循环或错误操作。我们提前处理这种情况。
3. 核心循环：while ((pos = strstr(str, sub)) != NULL)这是一个非常简洁高效的写法。每次循环都从当前字符串str的开头查找子串。pos记录了本次找到的位置。
4. 计算移动参数：
   • char *tail_start = pos + sub_len;这指向了被删除子串之后的第一个字符。
   • size_t tail_len = strlen(tail_start) + 1;这里+1是整个实现中最容易忽略的关键点。strlen(tail_start)只计算了\0之前的字符数。我们必须把\0也一起移动过来，才能保证移动后的字符串正确终止。忘记+1会导致新字符串没有结束符，后续操作（如printf、strlen）会读取到后面的垃圾数据，直至遇到一个偶然的\0，引发不可预知的错误。
5. 执行移动：memmove(pos, tail_start, tail_len);这就是执行“删除”的魔法语句。它将尾部字符串（含\0）安全地搬运到子串开始的位置，实现了覆盖删除。
6. 循环继续：移动完成后，while循环的条件会再次执行strstr(str, sub)。由于str指向的缓冲区内容已经更新，所以它会从新的字符串中继续查找是否还有匹配的子串。例如，删除“aa”中的“a”，第一次删除后字符串变为“a”，第二次strstr(“a”, “a”)依然能找到，直到字符串为空。

关于delete_first_substr函数：它只删除第一次出现的子串。有时我们只需要这个功能。它的实现是delete_all_substr的简化版，只执行一次查找和移动。返回值的设计模仿了标准库风格，方便链式调用。

5. 测试用例与边界条件处理

写好了函数，必须进行全面的测试。以下是一些必须考虑的测试场景：

int main() { char str1[100] = "hello world, hello universe!"; printf("原始: %s\n", str1); delete_all_substr(str1, "hello "); printf("删除'hello '后: %s\n", str1); // 预期: "world, universe!" // 测试子串在末尾 char str2[100] = "This is a test string test"; delete_all_substr(str2, "test"); printf("删除'test'后: %s\n", str2); // 预期: "This is a string " // 测试子串重叠出现 char str3[100] = "aaaa"; delete_all_substr(str3, "aa"); printf("删除'aa'后: %s\n", str3); // 这是一个有趣案例！预期结果是什么？ // 第一次删除前两个'a'，字符串变为"aa"，继续查找删除，最终变为空串""。 // 测试空子串 char str4[100] = "normal string"; delete_all_substr(str4, ""); printf("删除空串后: %s\n", str4); // 预期: "normal string" (不变) // 测试子串不存在 char str5[100] = "original"; delete_all_substr(str5, "xyz"); printf("删除不存在的'xyz'后: %s\n", str5); // 预期: "original" (不变) // 测试字符串为空 char str6[100] = ""; delete_all_substr(str6, "something"); printf("空字符串删除后: %s\n", str6); // 预期: "" (不变) // 测试只删除第一次出现 char str7[100] = "repeat repeat repeat"; delete_first_substr(str7, "repeat "); printf("仅删除第一次'repeat '后: %s\n", str7); // 预期: "repeat repeat" return 0; }

运行这些测试，观察输出是否符合预期，是验证函数正确性的最好方法。特别是重叠删除（“aaaa”中删除“aa”）和空串处理，是常见的思维盲区。

6. 常见问题、性能分析与优化

在实际使用和面试中，围绕这个实现会衍生出许多深入的问题。

6.1 为什么循环中不更新str指针？

细心的读者会发现，在delete_all_substr的循环里，我们始终用strstr(str, sub)，这个str是最初传入的指针，一直没变。而字符串内容在memmove后头部可能已经改变了（如果从开头删除），但str指向的地址没变，这有问题吗？没有问题。str是一个指向字符数组首地址的指针。memmove移动的是该指针所指向缓冲区里的内容。无论内容怎么变，str这个“门牌号”始终指向这块内存的开始。strstr每次都是从这块内存的起始地址开始搜索新的内容，逻辑是正确的。如果我们在循环里让str = pos;反而会出错，因为跳过了已经被检查和处理过的前半部分。

6.2 内存重叠的陷阱再探讨

我们强调必须用memmove。为了加深理解，可以思考：如果非要用strcpy来实现这个移动，怎么写才是安全的？ 答案是：无法安全实现。因为strcpy在拷贝时不知道长度，它遇到\0才停止。在重叠的情况下，源字符串的\0可能在拷贝过程中被覆盖，导致strcpy停不下来，直到发生缓冲区溢出或访问到非法内存。这是一个根本性的设计限制。

6.3 性能分析与潜在优化

我们的算法时间复杂度可以近似认为是 O(n*m)，其中 n 是原串长度，m 是子串长度，这主要是strstr的最坏情况复杂度。memmove的复杂度是 O(k)，k 是每次需要移动的尾部长度。

• 优化点1：避免重复计算子串长度。我们在循环外只计算一次sub_len，这是好的。
• 优化点2：减少strlen调用。在循环内，我们使用了strlen(tail_start)来计算尾部长度。如果待删除的子串很长，或者删除操作很多，这里可以优化。我们可以通过指针运算直接得到尾部长度：size_t tail_len = (str + strlen(str)) - tail_start + 1;。但前提是我们要在循环内维护当前字符串的长度，这增加了状态管理的复杂度。对于大多数情况，当前的写法清晰度优先，性能开销可接受。
• 优化点3：使用更高效的查找算法。标准库的strstr实现通常已经足够高效（可能使用了 KMP、Boyer-Moore 等算法）。但在极端性能要求的场景下，可以自己实现特定的查找逻辑。

6.4 一个进阶挑战：不分配额外空间，原地删除所有指定字符

这是一个相关的经典面试题。例如，删除字符串中的所有空格。思路更简单：使用两个指针（或索引），一个快指针p_fast用于遍历原字符串，一个慢指针p_slow用于指向下一个有效字符的存放位置。当p_fast指向的字符不是要删除的字符时，就将其拷贝到p_slow的位置，然后两个指针都前进；否则，只有p_fast前进。最后在p_slow的位置写入\0。这个方法只需要一次遍历，时间复杂度 O(n)，且是严格的原地操作。

void remove_char(char *str, char c) { if (str == NULL) return; char *dst = str; // 慢指针 char *src = str; // 快指针 while (*src) { if (*src != c) { *dst++ = *src; } src++; } *dst = '\0'; }

理解了这个“双指针”技巧，再回头看我们的删除子串函数，会发现其核心思想有相通之处，只不过“判断是否要删除”的逻辑从“单个字符是否相等”变成了“是否匹配一个子串”。

7. 项目总结与扩展思考

通过这个“删除字符串中子串”的项目，我们完成了一次对C语言字符串和内存操作的深度遍历。它远不止于几行代码，而是串联起了指针、数组、内存管理、标准库函数应用和边界条件处理等多个核心知识点。

我个人在实现和教学这个案例时，最深的体会是：C语言的简洁和强大背后，是对程序员责任的严格要求。每一个函数的选择（memmovevsmemcpy）、每一个边界条件的判断（空串、NULL指针）、每一次长度的计算（是否包含\0），都直接关系到程序的正确性与安全性。忽略其中任何一点，都可能埋下难以察觉的bug。

这个项目可以很自然地扩展到其他相关功能：

• 替换子串：找到子串后，不是删除，而是用另一个字符串替换它。这需要处理新子串长度不同带来的内存伸缩问题，可能涉及realloc（如果字符串在堆上）或确保缓冲区足够大。
• 分割字符串：基于一个分隔符子串，将字符串分割成多个部分。这通常需要动态数组或链表来保存结果。
• 实现一个简单的字符串处理库：将删除、替换、查找、分割等功能封装成一组函数，并统一处理内存分配错误。

最后，建议你不仅仅停留在阅读和理解上。打开你的编辑器（无论是VSCode、CLion还是简单的文本编辑器配合GCC），把代码敲一遍，运行不同的测试用例，甚至故意写一些有bug的版本（比如把memmove换成memcpy），观察会发生什么。这种从“知道”到“做到”再到“理解为什么必须这样做”的过程，才是提升C语言功力的不二法门。