C语言字符串函数底层实现：手写strcpy、strcat、strcmp详解

1. 项目概述：为什么我们要亲手“造轮子”？

在C语言的世界里，<string.h>库中的strcpy、strcat、strcmp这几个函数，几乎是每个开发者入门时就会接触到的老朋友。它们负责字符串的拷贝、连接和比较，是处理文本数据的基石。很多教程和面试题都会告诉你它们的用法，但如果你只是停留在“调用”的层面，那就像只会开车却不懂发动机原理一样，遇到复杂路况或车辆故障时，往往会束手无策。

这个项目的核心，就是让我们暂时忘掉现成的库函数，从零开始，用最基础的C语言语法，模拟实现这三个函数。这绝不是一个“无用功”的练习。恰恰相反，它是一次深入理解计算机底层如何处理字符串、如何管理内存、以及如何编写健壮代码的绝佳机会。通过亲手实现，你会深刻理解为什么strcpy要返回目标指针、strcat在连接时如何处理结束符、strcmp比较的底层逻辑是什么。这些理解，能让你在未来的开发中，无论是排查一个诡异的字符串乱码问题，还是设计一个高性能的文本处理模块，都拥有更清晰的思路和更扎实的底气。

2. 核心思路与设计考量

模拟实现标准库函数，首要原则是行为一致性。我们的函数应该尽可能在功能上与标准库函数保持一致，包括函数原型、返回值、以及边界条件下的行为。但这并不意味着我们要照搬黑盒。在实现过程中，我们会加入自己的思考和设计，并重点剖析那些容易被忽略的细节。

2.1 函数原型与接口设计

标准库的函数原型是我们的蓝本：

• char *strcpy(char *dest, const char *src);
• char *strcat(char *dest, const char *src);
• int strcmp(const char *str1, const char *str2);

我们需要严格遵循这些原型。这里有几个关键点：

1. 参数类型：dest（目标）通常不是const，因为我们要修改它；src（源）必须是const，承诺不会修改源字符串，这是良好的接口契约。
2. 返回值：strcpy和strcat返回dest的起始地址，这支持了“链式调用”，例如strcat(strcpy(dest, src1), src2)。strcmp返回一个整数，表示两个字符串的大小关系。
3. 头文件：我们模拟的函数不应包含<string.h>，以避免命名冲突。通常我们会将自己的实现放在一个单独的头文件（如my_string.h）和源文件中。

2.2 核心逻辑拆解

在动手写代码前，我们先在脑子里把流程过一遍：

• strcpy：将src指向的字符串（包括结束符\0）逐个字符复制到dest指向的内存空间，直到遇到src的\0为止。
• strcat：首先找到dest字符串的结束符\0的位置，然后从这个位置开始，执行一次strcpy操作，将src字符串追加过去。
• strcmp：逐个比较str1和str2对应位置的字符的ASCII码值。如果遇到不相等的字符，或者任一字符串的结束符\0，则停止比较，并根据差值返回结果。

这个看似简单的逻辑背后，隐藏着指针操作、内存重叠、空指针、缓冲区溢出等一大堆“坑”。我们的实现不仅要功能正确，更要健壮和安全。

3. 核心细节解析与避坑指南

3.1 指针操作：一切的核心

C语言的字符串本质是字符数组，通过指针来访问。模拟这些函数，就是学习指针算术的经典案例。

• while (*dest++ = *src++)：这是strcpy一种非常简洁的写法。它同时完成了取值、赋值、指针后移和循环判断（赋值表达式的值就是所赋的值，\0的值为0，即false）。但新手容易在这里迷惑运算的优先级和副作用。
• 保存起始地址：因为dest指针在操作过程中会不断后移，为了最后能返回起始地址，必须在开始时用一个临时指针（如char *ret = dest;）保存下来。

3.2 边界条件与健壮性考虑

这是区分“学生作业”和“工业级代码”的关键。

1. 空指针（NULL）检查：标准库函数对传入NULL指针的行为是“未定义的”（Undefined Behavior, UB），通常会导致程序崩溃（段错误）。但在我们自己实现时，出于健壮性考虑，可以（也应该）加入NULL检查。这是一个很好的编程习惯。

   if (dest == NULL || src == NULL) { // 可以返回NULL，或者用assert断言，或者进行其他错误处理 return dest; // 或 return NULL; }

   注意：加入NULL检查会使我们的函数行为与标准库略有不同，在严格模拟的场景下需要注明。但在实际项目中，对输入参数进行有效性检查是防御性编程的基本要求。

2. 缓冲区溢出（Buffer Overflow）：这是C语言字符串操作最著名、最危险的安全漏洞。strcpy和strcat本身不检查dest指向的内存空间是否足够容纳src的内容。如果不够，就会覆盖相邻内存，导致数据损坏或安全漏洞。标准库提供了更安全的版本strncpy和strncat。在我们的模拟实现中，虽然无法从根本上解决这个问题（因为函数原型限制了参数），但我们必须在注释和文档中强烈警告调用者：必须确保dest有足够的空间！

3. 内存重叠（Overlapping）：如果src和dest所指向的内存区域有重叠（例如dest = src+1），标准库函数的行为是未定义的。我们的简单实现很可能会得到错误的结果。处理内存重叠需要更复杂的逻辑（通常需要判断指针位置，决定是从前往后还是从后往前拷贝），这超出了基础模拟的范围，但作为一个进阶思考点，值得了解。

4. 分步实现与代码精讲

下面，我们逐一实现这三个函数，并配上详细的逐行解读。

4.1my_strcpy：字符串拷贝的模拟实现

/** * 模拟实现标准库函数 strcpy * @param dest: 目标字符串起始地址，必须有足够空间 * @param src: 源字符串起始地址 * @return: 目标字符串 dest 的起始地址 */ char* my_strcpy(char* dest, const char* src) { // 参数检查（增强健壮性） if (dest == NULL || src == NULL) { // 这里选择返回dest，与调用时传入的dest一致。 // 更严格的做法可以是返回NULL或使用assert。 return dest; } // 保存目标字符串的起始地址，因为后续dest指针会移动 char* ret = dest; // 核心拷贝循环 // 表达式 (*dest++ = *src++) 的执行顺序： // 1. 取 *src 的值 // 2. 将该值赋给 *dest // 3. 赋值表达式本身的值就是所赋的值（即 *src 的值） // 4. 判断该值是否为 '\0'（即0，在C中为假） // 5. 无论是否赋值成功，dest 和 src 指针都自增1 // 当拷贝到 src 的 '\0' 时，先将 '\0' 赋给 *dest，然后表达式值为0，循环结束。 while ((*dest++ = *src++) != '\0') { // 循环体为空，所有操作都在条件判断中完成 ; } // 上述循环等价于更简洁的写法： while (*dest++ = *src++); // 但显式地写出 != '\0' 对于初学者理解更有帮助。 return ret; // 返回之前保存的起始地址 }

实操心得：

• 很多教材喜欢用while (*dest++ = *src++);这种极简写法，它确实优雅且高效。但在实际项目和教学初期，我更推荐显式地写出!= ‘\0‘，因为意图更清晰，可读性更好。代码首先是写给人看的。
• ret指针是必要的。我曾见过新手直接返回dest，此时dest已经指向字符串末尾，返回错误。

4.2my_strcat：字符串连接的模拟实现

/** * 模拟实现标准库函数 strcat * @param dest: 目标字符串起始地址，必须有足够空间容纳连接后的结果 * @param src: 要追加的源字符串起始地址 * @return: 目标字符串 dest 的起始地址 */ char* my_strcat(char* dest, const char* src) { // 参数检查 if (dest == NULL || src == NULL) { return dest; } char* ret = dest; // 保存起始地址 // 第一步：找到 dest 字符串的结尾（即 '\0' 的位置） // 这个循环只移动指针，不进行赋值 while (*dest != '\0') { dest++; } // 循环结束后，dest 指向 dest 字符串的结束符 '\0’ // 第二步：从 dest 当前位置（原字符串的结尾）开始，执行 strcpy 操作 while ((*dest++ = *src++) != '\0') { ; } return ret; }

避坑技巧：

• my_strcat可以理解为找到dest结尾 + my_strcpy。第一个while循环千万不能写成while (*dest++ != ‘\0‘);，因为这样循环结束后，dest指针指向的是\0的下一个位置，而不是\0本身。后续的拷贝就会从错误的位置开始，导致连接后的字符串开头多出一个“空洞”（未初始化值）或直接出错。
• 同样需要警惕缓冲区溢出。strcat的溢出风险是双重的：调用者必须确保dest有足够空间存放原内容+新内容+‘\0‘。

4.3my_strcmp：字符串比较的模拟实现

/** * 模拟实现标准库函数 strcmp * @param str1: 要比较的第一个字符串 * @param str2: 要比较的第二个字符串 * @return: 整数值 * 若 str1 < str2，则返回一个负整数（通常是差值 -1 或字符ASCII码差值） * 若 str1 == str2，则返回 0 * 若 str1 > str2，则返回一个正整数（通常是差值 1 或字符ASCII码差值） */ int my_strcmp(const char* str1, const char* str2) { // 参数检查 if (str1 == NULL || str2 == NULL) { // 处理空指针的一种方式：定义NULL指针小于任何有效字符串，或直接断言。 // 为简单起见，这里假设输入有效。实际可加入处理逻辑。 // 例如：if (str1 == NULL && str2 == NULL) return 0; // else if (str1 == NULL) return -1; // else return 1; } // 核心比较循环 // 只要两个指针指向的字符相等且不为 '\0'，就继续比较下一个 while (*str1 != '\0' && *str1 == *str2) { str1++; str2++; } // 循环结束的条件有三个： // 1. *str1 == '\0' 且 *str2 == '\0'：两字符串完全相等，此时 *str1 - *str2 = 0 // 2. *str1 == '\0' 但 *str2 != '\0'：str1较短，此时 *str1 - *str2 < 0 // 3. *str1 != *str2：在某个位置字符不相等，此时差值 (*str1 - *str2) 即反映了大小关系 // 4. *str2 == '\0' 但 *str1 != '\0'：str2较短，包含在情况3中，因为此时 *str1 != *str2 (0) // 返回当前字符的ASCII码差值 return *(unsigned char*)str1 - *(unsigned char*)str2; }

关键解析：

• 循环条件：while (*str1 != ‘\0‘ && *str1 == *str2)是精妙之处。它先确保str1没到头（如果str1到头，str2无论是什么，比较结果已定），再判断当前字符是否相等。这个顺序很重要。
• 返回值：标准只要求返回正、负、零，不规定具体值。但许多实现（如Glibc）返回字符的ASCII码差值，这样信息量更大。我们采用这种方式。
• 类型转换：(unsigned char*)强制转换是关键一步！因为char类型可能是有符号的（范围-128~127）。如果直接相减，比较字符‘\xff‘（255）和‘\0‘（0），有符号的char会将其视为-1，计算-1 - 0 = -1，这符合“小于”的语义。但为了与将char当作无符号处理的常见行为保持一致，并避免符号扩展带来的意外，转换为unsigned char是更稳妥、更通用的做法。这是一个非常细微但重要的专业细节。

5. 测试用例与常见问题排查

实现完了，不测试就是纸上谈兵。编写全面的测试用例是巩固理解、发现BUG的最佳方式。

5.1 基础功能测试

#include <stdio.h> #include <string.h> // 用于和标准库函数对比结果 // 假设我们的模拟函数声明在 my_string.h 中 #include “my_string.h” void test_basic() { char dest[20]; const char* src = “Hello, World!”; // 测试 my_strcpy my_strcpy(dest, src); printf(“my_strcpy: %s\n”, dest); // 应输出: Hello, World! // 测试 my_strcat char dest_cat[50] = “Hello, “; // 注意初始化并预留足够空间 my_strcat(dest_cat, “World!”); printf(“my_strcat: %s\n”, dest_cat); // 应输出: Hello, World! // 测试 my_strcmp int cmp1 = my_strcmp(“apple”, “apple”); int cmp2 = my_strcmp(“apple”, “banana”); int cmp3 = my_strcmp(“banana”, “apple”); printf(“my_strcmp(‘apple‘, ‘apple‘): %d\n”, cmp1); // 应输出: 0 printf(“my_strcmp(‘apple‘, ‘banana‘): %d\n”, cmp2); // 应输出: 负数 printf(“my_strcmp(‘banana‘, ‘apple‘): %d\n”, cmp3); // 应输出: 正数 }

5.2 边界与异常测试

这是体现我们代码健壮性的地方。

void test_edge_cases() { char buf[10]; // 1. 测试空字符串 my_strcpy(buf, “”); printf(“Copy empty string: ‘%s‘ (length=%lu)\n”, buf, strlen(buf)); my_strcat(buf, “”); // 连接空字符串 printf(“After cat empty string: ‘%s‘\n”, buf); int cmp_empty = my_strcmp(“”, “”); printf(“Compare two empty strings: %d\n”, cmp_empty); // 应为0 // 2. 测试与标准库结果一致性（进阶） char dest_std[20], dest_my[20]; src = “Test”; strcpy(dest_std, src); my_strcpy(dest_my, src); if (strcmp(dest_std, dest_my) == 0) { printf(“my_strcpy matches standard lib!\n”); } // 3. 测试返回值（链式调用） char chain[30]; my_strcat(my_strcpy(chain, “Hello”), “ World!”); printf(“Chain call result: %s\n”, chain); // 应输出: Hello World! // 4. 【危险！仅用于理解，实际项目避免】缓冲区不足演示 // char small_buf[5]; // my_strcpy(small_buf, “This is a very long string”); // 缓冲区溢出！ // printf(“%s\n”, small_buf); // 行为未定义，可能崩溃或输出乱码 }

5.3 常见问题排查表

在实际编写和调试过程中，你可能会遇到以下问题：

6. 从模拟实现到实际应用的思考

亲手实现一遍之后，我们再回看标准库函数，感受会完全不同。你不再把它当作一个魔法黑盒，而是明白了它内部每一个字节是如何流动的。这种理解带来几个最直接的收益：

第一，调试能力质的飞跃。当程序因为字符串操作崩溃时，你脑子里能立刻浮现出可能的原因：是不是指针为NULL了？是不是缓冲区写穿了？是不是内存重叠了？你能更有针对性地使用调试器查看内存内容，定位问题根源。

第二，写出更安全的代码。知道了strcpy的危险，你会在项目中本能地避免使用它，转而使用strncpy、snprintf或者更安全的字符串库。你会养成“先检查，后操作”的习惯，对来自外部的字符串数据保持警惕。

第三，理解更高级抽象的基础。许多高级语言（如C++的std::string、Python的str）的字符串类，其底层优化（如短字符串优化、写时复制）和接口设计，都能从C语言这些基础操作中找到影子。理解了底层，学习上层就会事半功倍。

最后，我个人在带新人时，一定会让他做这个练习。它像一面镜子，能清晰地照出一个开发者对指针、内存和基础逻辑的掌握程度。代码虽小，五脏俱全。希望你在实现的过程中，不仅得到了几个可以运行的函数，更收获了对C语言更深一层的那种“掌控感”。编程的世界里，知其然并知其所以然，永远是通往高手之路的基石。