1. 项目缘起为什么我们要亲手“造轮子”刚学C语言那会儿我总觉得strcpy、strcat这些函数用起来理所当然不就是库函数嘛调用一下就行了。直到后来自己写项目遇到了缓冲区溢出导致程序崩溃或者处理特殊字符时结果总是不对才回过头来琢磨这些黑盒子里面到底发生了什么它们有没有什么我没注意到的“坑”从那时起我就养成了一个习惯对于核心的、常用的库函数一定要自己动手模拟实现一遍。这绝不是浪费时间而是一种“知其然更知其所以然”的深度修炼。今天我们就来彻底拆解C语言中最常用的几个字符串处理函数。我们的目标不是简单地复述手册而是像设计者一样思考从零开始用最纯粹的C语言一步步构建出它们的“平替”版本。你会看到一个看似简单的strlen在追求极致效率时可以有多种写法一个常用的strcpy如果不注意边界检查可能就是安全漏洞的温床。通过这个过程你不仅能牢牢掌握这些函数的内部机理更能深刻理解指针操作、内存管理和编码安全的精髓这对于你未来无论是做嵌入式开发、系统编程还是应对各种笔试面试都将是极为扎实的功底。2. 模拟实现前的核心思想与约束在动手写代码之前我们必须先统一思想明确游戏规则。模拟实现不是天马行空的创造而是在给定约束下的精确还原。2.1 函数原型与行为的一致性这是最高原则。我们模拟的函数其名称、参数类型、返回类型以及最重要的——外部行为必须与标准库函数完全一致。这意味着参数不变标准库的strcpy声明是char *strcpy(char *dest, const char *src);我们的模拟函数也必须是这个签名。返回值一致标准库的strcpy返回目标字符串的起始地址即dest我们的实现也必须返回dest。这个返回值常被用于链式调用比如strcat(strcpy(dest, src1), src2)。副作用相同函数对内存的修改、对输入参数的依赖关系必须一致。例如strcpy会修改dest指向的内存并且依赖于src指向的以\0结尾的字符串。2.2 关于“安全性”的边界讨论这是一个关键且容易引起困惑的点。C标准库中原始的字符串函数如strcpy,strcat本身不检查目标缓冲区的大小这是它们被认为“不安全”的根源。它们的设计哲学是“程序员负责一切”追求极致的速度和简洁。注意在我们的模拟实现中我们首先严格遵循原始函数的不安全行为进行实现。这是为了理解其最本质的工作原理。之后我们会在分析章节专门探讨如何在此基础上增加安全检查演进出strncpy、strlcpy非标准但流行等安全版本。请务必分清“模拟原始行为”和“编写安全代码”是两个阶段的任务。2.3 我们的“武器库”允许使用的底层操作既然要模拟我们就不能直接调用其他的字符串库函数否则就成了套娃。我们被允许使用的“原子操作”非常有限指针的算术运算与解引用这是核心中的核心。*p,*(p1),p等。基本赋值与比较,,!,,等。循环与条件判断while,for,if。内存访问通过指针读写内存。我们的所有实现都将建立在这些基础操作之上。好了思想准备就绪让我们开始第一个也是最基础的一个函数。3. 求字符串长度strlen 的多种实现与效率权衡strlen的功能是计算一个以空字符\0结尾的字符串的长度不包括\0本身。听起来很简单但实现方式却能体现出不同的编程思维和优化技巧。3.1 最直观的版本计数器法这是初学者最容易想到的方法。用一个临时指针遍历字符串同时用一个整型变量count来记录步数。// 版本1计数器法 size_t my_strlen_counter(const char *str) { size_t count 0; // 用于计数的变量 if (str NULL) { // 良好的习惯检查输入指针是否有效 return 0; // 处理空指针实际标准库行为未定义这里我们做防御性处理 } while (*str ! \0) { // 遍历直到遇到字符串结束符 count; str; } return count; }实现解析count初始为0。while循环检查当前str指向的字符是否为\0如果不是count加1指针str向后移动一个字符指向下一个字符。循环结束时count的值就是字符串的长度。这个版本逻辑清晰易于理解但每次循环要执行两次加法count和str和一次比较。3.2 更C语言风格的版本指针差值法C语言中指针减指针可以得到它们之间相差的元素个数。我们可以利用这一点省去单独的计数器。// 版本2指针差值法 size_t my_strlen_ptr_diff(const char *str) { const char *start str; // 记录起始位置 if (str NULL) { return 0; } while (*str ! \0) { str; } return (size_t)(str - start); // 结束位置减去起始位置即为长度 }实现解析在开始遍历前用start指针记录字符串的起始地址。然后让str指针一路走到\0的位置。最后str - start得到的就是从头到尾走过的字符数也就是字符串长度。这个方法比计数器法更“地道”它直接利用了指针运算的特性通常效率也略高一点。3.3 追求极致的版本无分支优化与字长读取在一些高性能库如Glibc的实现中strlen会采用更复杂、更极致的优化。其核心思想是对齐内存访问现代CPU对对齐的内存访问如4字节或8字节对齐速度更快。实现会先处理开头几个不对齐的字节直到指针指向一个对齐的地址。按机器字长Word读取一次不是读取一个字符1字节而是读取一个机器字比如4或8字节。这相当于同时检查多个字符是否为\0。位运算技巧快速检测0字节在一个字比如0x44332201中快速判断是否有任何一个字节为0x00。这通常通过神奇的位运算公式实现例如((x - 0x01010101) ~x 0x80808080)对于32位系统。无分支循环减少或消除循环内的条件判断利用位运算结果来定位\0。这种实现非常复杂涉及大量底层知识其目的是为了在处理长字符串时获得数倍甚至数十倍的性能提升。对于我们理解基本原理而言前两种实现已经足够。但你需要知道一个简单的strlen在工业级代码中可能藏着如此深的优化心思。4. 字符串复制strcpy 与 strncpy 的陷阱与实现复制函数是字符串操作中最常用也最容易出问题的地方。4.1 标准 strcpy 的模拟实现char *strcpy(char *dest, const char *src);将src指向的字符串包括结尾的\0复制到dest指向的内存空间。// 模拟实现标准 strcpy char *my_strcpy(char *dest, const char *src) { // 参数检查标准库不检查但好的模拟实现可以加入 // assert(dest ! NULL src ! NULL); char *ret dest; // 保存目标字符串起始地址用于返回 while ((*dest *src) ! \0) { // 循环体为空所有操作都在条件判断中完成 } return ret; }实现解析这行while ((*dest *src) ! \0)是C语言中一个经典且紧凑的写法。它的执行顺序是将src指向的字符赋值给dest指向的位置*dest *src。判断这个被赋值的字符是否等于\0。无论是否等于\0dest和src指针都自增1指向下一个位置。如果步骤2中判断字符不是\0则继续循环如果是\0则循环结束并且\0也已经被复制过去了。这个实现完美复刻了标准库的行为它假设dest指向的内存空间足够大能容纳src的所有字符包括\0。如果dest空间不足就会发生缓冲区溢出Buffer Overflow覆盖后面的内存数据导致程序崩溃或产生安全漏洞。这是原始strcpy最大的“罪”。4.2 有限长度的复制strncpy 的模拟与误区为了缓解溢出问题C库提供了char *strncpy(char *dest, const char *src, size_t n);。它的逻辑是最多复制n个字符从src到dest。// 模拟实现标准 strncpy char *my_strncpy(char *dest, const char *src, size_t n) { char *ret dest; size_t i; for (i 0; i n src[i] ! \0; i) { dest[i] src[i]; } // 关键且反直觉的部分如果 i n说明 src 提前结束了需要用 \0 填充剩余空间 for ( ; i n; i) { dest[i] \0; } return ret; }实现解析与重大陷阱复制阶段for循环在两种情况下停止复制够了n个字符或者遇到了src的结束符\0。填充阶段这是strncpy最特殊也最容易被误用的一点如果src的长度小于nstrncpy会用\0填充dest中剩余的所有字节直到写满n个字符。结尾符不确定性strncpy不保证目标字符串以\0结尾只有在两种情况下dest会以\0结尾src的长度包括\0小于n此时dest的最后一个有效字符是填充的\0。src的长度大于等于n此时dest恰好被src的前n个字符填满最后一个字符不是\0。踩坑实录很多人以为strncpy是安全的strcpy直接strncpy(dest, src, sizeof(dest))。这错了如果src很长dest会被填满且没有\0结尾。后续使用dest作为字符串的函数如printf(“%s”, dest)会一直读取内存直到遇到一个随机的\0导致溢出或乱码。正确的做法是手动确保结尾strncpy(dest, src, sizeof(dest)-1); dest[sizeof(dest)-1] \0;。4.3 更优的选择模拟 strlcpy 的思路正因为strncpy的怪异行为很多系统如BSD引入了strlcpy。它的原型是size_t strlcpy(char *dest, const char *src, size_t size);其设计目标是安全且易于正确使用。// 模拟 strlcpy 的行为非标准但更安全 size_t my_strlcpy(char *dest, const char *src, size_t size) { size_t src_len my_strlen(src); // 需要先知道源串长度 size_t n; if (size 0) { return src_len; // 如果目标空间为0直接返回源串长度需要复制的长度 } // 计算实际能复制的字符数留一个位置给 \0 n (src_len size) ? (size - 1) : src_len; // 复制最多 n 个字符 for (size_t i 0; i n; i) { dest[i] src[i]; } dest[n] \0; // 无论何种情况都确保目标字符串以 \0 结尾 return src_len; // 返回源串长度方便调用者判断是否被截断 }实现解析strlcpy的理念是“安全第一结果可预测”。它总是保证dest以\0结尾只要size 0。它的第三个参数size指的是dest缓冲区的总大小包括\0的位置而不是最大复制字符数。这更符合直觉。返回值是src的长度。这样调用者可以轻松判断复制是否被截断if (retval size) { /* 发生了截断 */ }。虽然strlcpy不是C标准库函数但其清晰的安全语义使得它在很多项目中成为首选。自己实现一个类似逻辑的函数是工程中的常见做法。5. 字符串连接strcat 与 strncat 的细节连接函数用于将一个字符串追加到另一个字符串的末尾。5.1 标准 strcat 的模拟实现char *strcat(char *dest, const char *src);将src字符串追加到dest字符串的末尾覆盖dest原有的结束符\0并在连接后的新字符串末尾添加\0。// 模拟实现标准 strcat char *my_strcat(char *dest, const char *src) { char *ret dest; // 第一步找到 dest 字符串的结尾即 \0 的位置 while (*dest ! \0) { dest; } // 第二步从 dest 的结尾开始执行 strcpy 操作 while ((*dest *src) ! \0) { ; } return ret; }实现解析这个实现可以看作strlen(dest)strcpy(dest_end, src)两个操作的组合。第一个while循环定位到dest字符串的末尾\0处。第二个while循环就是我们的my_strcpy逻辑从dest的末尾开始复制src。同样它不检查dest剩余空间是否足够存在缓冲区溢出风险。5.2 有限长度的连接strncat 的模拟实现char *strncat(char *dest, const char *src, size_t n);从src追加最多n个字符到dest末尾并总是添加一个终止空字符\0。// 模拟实现标准 strncat char *my_strncat(char *dest, const char *src, size_t n) { char *ret dest; size_t dest_len my_strlen(dest); dest dest_len; // 移动到 dest 的末尾 size_t i; // 复制 src 中的字符最多 n 个或者遇到 \0 停止 for (i 0; i n src[i] ! \0; i) { dest[i] src[i]; } // 关键无论复制了多少个字符总是在末尾添加 \0 dest[i] \0; return ret; }实现解析strncat比strncpy的行为要友好得多也安全得多。它先找到dest的末尾。然后从src复制最多n个非\0字符过去。最重要的一点复制完成后它总是在目标字符串的末尾添加一个\0。这意味着dest永远是一个有效的C字符串。它不会像strncpy那样用\0填充剩余空间。因此strncat是相对更安全的连接函数。但调用者仍需确保dest有足够的空间容纳dest原有的字符 min(n, strlen(src))个新字符 1个\0。6. 字符串比较strcmp 与 strncmp 的逐字节逻辑比较函数用于按字典序ASCII码顺序比较两个字符串。6.1 标准 strcmp 的模拟实现int strcmp(const char *str1, const char *str2);比较两个字符串。返回值为 0str1小于str2第一个不匹配字符的ASCII值在str1中小于在str2中或str1是str2的前缀。 0str1等于str2。 0str1大于str2。// 模拟实现标准 strcmp int my_strcmp(const char *str1, const char *str2) { // 循环比较直到遇到不相等的字符或遇到 \0 while (*str1 ! \0 *str1 *str2) { str1; str2; } // 返回两个当前字符的ASCII差值 return *(unsigned char *)str1 - *(unsigned char *)str2; }实现解析while循环的条件是两个指针都没走到结尾*str1 ! ‘\0’并且当前字符相等*str1 *str2。只要条件满足就继续比较下一个字符。循环退出时有两种可能遇到了不相等的字符。str1走到了结尾此时*str2可能是\0也可能不是。返回值计算将两个当前字符**转换为unsigned char**后相减。这是为了正确处理负值的char在一些系统上char默认为signed。例如比较”\xFF”和”\x00”如果按signed char解释-1 - 0 -1如果按unsigned char解释255 - 0 255。标准要求按unsigned char比较以确保结果一致。如果str1先结束且str2在相同位置也是\0则循环因*str1 ‘\0’而*str1 *str2不成立因为\0 \0为真但*str1 ! ‘\0’为假退出循环。此时*str1和*str2都是\0相减结果为0表示字符串相等。6.2 有限长度的比较strncmp 的模拟实现int strncmp(const char *str1, const char *str2, size_t n);比较两个字符串的前n个字符。// 模拟实现标准 strncmp int my_strncmp(const char *str1, const char *str2, size_t n) { if (n 0) { return 0; // 比较0个字符认为相等 } while (--n 0 *str1 ! \0 *str1 *str2) { str1; str2; } return *(unsigned char *)str1 - *(unsigned char *)str2; }实现解析逻辑与strcmp类似但增加了比较次数n的限制。如果n为0直接返回0相等。while循环条件--n 0确保最多比较n-1次因为先减减。同时也要满足两个字符串都没结束且当前字符相等。循环退出条件可能是比较次数用尽n变为0、遇到不相等的字符、或某个字符串结束。返回值的计算方式与strcmp完全相同比较的是退出循环时的当前字符。strncmp常用于比较字符串的前缀或者当你知道只需要比较固定长度时它更安全因为它不会因为字符串缺少\0而一直读取越界尽管标准字符串应该以\0结尾但破损的数据中可能没有。7. 内存操作函数的跨界模拟memcpy 与 memmove严格来说memcpy和memmove不是字符串函数它们处理的是内存块不关心\0但它们与字符串操作息息相关且实现思想非常经典。7.1 内存复制memcpy 的模拟实现与限制void *memcpy(void *dest, const void *src, size_t n);从src指向的位置开始复制n个字节到dest指向的位置。// 模拟实现标准 memcpy (基础版本) void *my_memcpy(void *dest, const void *src, size_t n) { char *d (char *)dest; const char *s (const char *)src; // 通常的简单实现按字节从前向后复制 for (size_t i 0; i n; i) { d[i] s[i]; } return dest; }实现解析与重大限制这个简单的逐字节复制实现在大多数情况下工作良好。但是标准库的memcpy有一个非常重要的限制它要求源内存区域和目标内存区域不能重叠。如果重叠其行为是未定义的Undefined Behavior。为什么考虑src和dest重叠的情况例如dest在src后面一点。当我们从前向后复制时src中尚未被复制的数据可能会先被dest覆盖掉导致复制结果错误。例如想把”hello”从地址0复制到地址1期望得到”hhello”但从前向后复制会得到”hhhhh”。7.2 可处理重叠的内存复制memmove 的模拟实现void *memmove(void *dest, const void *src, size_t n);功能与memcpy类似但允许源和目标内存区域重叠。它是更安全的选择。// 模拟实现标准 memmove void *my_memmove(void *dest, const void *src, size_t n) { char *d (char *)dest; const char *s (const char *)src; if (d s || n 0) { return dest; // 源和目标相同或复制长度为0直接返回 } // 判断内存区域是否重叠以及重叠的类型 if (d s) { // 情况1目标地址在源地址之前从前向后复制是安全的 for (size_t i 0; i n; i) { d[i] s[i]; } } else { // 情况2目标地址在源地址之后或相等但前面已排除相等从后向前复制以避免覆盖 for (size_t i n; i 0; i--) { d[i - 1] s[i - 1]; } } return dest; }实现解析memmove的智慧在于复制方向的判断。无重叠或目标在前如果dest的地址小于src的地址或者两者不重叠从前向后复制是安全的。因为即使重叠dest在前面它覆盖的是src已经“用过”的旧数据区域不会影响后面待复制的数据。目标在后重叠如果dest的地址大于src的地址并且两者重叠dest src n此时从前向后复制会破坏源数据。正确的做法是从后向前复制。从最后一个字节开始依次向前复制这样源区域中尚未被读取的数据就不会先被目标区域覆盖。经验之谈在实际编程中如果你不确定两块内存是否重叠永远优先使用memmove。虽然它的名字暗示着“移动”但它完全能胜任memcpy的工作并且在重叠时行为是确定的。现代编译器的优化非常智能在检测到内存不重叠时对memmove的调用很可能被优化成与memcpy同样高效的指令。用memmove代替memcpy是一个低成本的高安全习惯。8. 字符串查找strchr 与 strstr 的算法思路查找函数用于在字符串中定位字符或子串。8.1 查找字符strchr 的模拟实现char *strchr(const char *str, int c);在字符串str中查找第一次出现字符c转换为char的位置并返回指向该位置的指针。如果未找到返回NULL。// 模拟实现标准 strchr char *my_strchr(const char *str, int c) { if (str NULL) { return NULL; } char ch (char)c; // 将 int 转换为 char while (*str ! \0) { if (*str ch) { return (char *)str; // 找到返回指针。需要去除 const 限定 } str; } // 循环结束也没找到检查是否在找 \0 if (ch \0) { return (char *)str; // 标准规定查找 \0 应返回指向字符串结尾的指针 } return NULL; // 未找到 }实现解析逻辑很直接遍历字符串逐个字符比较。有两个细节需要注意参数c是int类型这是历史原因为了兼容EOF通常是-1。在函数内部需要将其转换为char类型进行比较。查找空字符\0根据C标准strchr也可以用来查找字符串的结束符\0此时应返回指向\0的指针。我们的实现通过循环后的一个特殊判断来处理这种情况。8.2 查找子串strstr 的朴素算法实现char *strstr(const char *haystack, const char *needle);在haystack干草堆字符串中查找第一次出现needle针子串的位置。// 模拟实现标准 strstr (朴素匹配算法Brute-Force) char *my_strstr(const char *haystack, const char *needle) { if (haystack NULL || needle NULL) { return NULL; } if (*needle \0) { return (char *)haystack; // 空子串是任何字符串的子串返回原串起始位置 } const char *h; const char *n; const char *start haystack; while (*start ! \0) { h start; n needle; // 内层循环比较从 start 开始的子串是否与 needle 匹配 while (*h ! \0 *n ! \0 *h *n) { h; n; } // 判断匹配是否成功 if (*n \0) { // needle 全部比较完毕说明找到了 return (char *)start; } if (*h \0) { // haystack 剩余部分长度已经小于 needle不可能再找到 break; } // 本次匹配失败start 向后移动一位继续尝试 start; } return NULL; // 未找到 }实现解析朴素算法外层循环指针start从haystack的第一个字符开始每次尝试作为一个可能的匹配起点。内层循环用指针h和n分别从当前的start和needle开头开始逐个字符比较。匹配成功条件内层循环一直进行到*n ‘\0’这意味着needle的所有字符都匹配上了函数返回当前的start指针。匹配失败如果内层循环因为*h ! *n而退出说明当前start位置不匹配。start向后移动一位继续尝试。提前终止优化如果内层循环因为*h ‘\0’而退出即haystack先到头了而*n还不是\0说明剩下的haystack长度已经比needle短不可能再匹配成功直接跳出外层循环返回NULL。这个算法被称为“朴素匹配”或“暴力匹配”其时间复杂度在最坏情况下是O(m*n)其中m和n分别是两个字符串的长度。对于短字符串这完全够用。标准库的实现如Glibc在检测到needle较长时可能会使用更高效的算法如KMP算法或Boyer-Moore算法这些算法通过预处理needle可以在某些情况下达到O(mn)的线性时间复杂度。理解朴素算法是学习这些高级算法的基础。9. 综合测试与边界条件思考纸上得来终觉浅绝知此事要躬行。写完了所有模拟函数我们必须进行全面的测试尤其是各种边界情况和异常输入。9.1 构建一个简单的测试框架我们可以编写一个简单的main函数来测试我们的实现。为了严谨应该将我们的模拟函数与标准库函数在相同输入下的输出进行对比。#include stdio.h #include string.h #include assert.h // 这里插入我们上面实现的所有 my_xxx 函数... int main() { // 1. 测试 strlen printf(Testing my_strlen...\n); assert(my_strlen() strlen()); assert(my_strlen(hello) strlen(hello)); assert(my_strlen(a\nb\tc) strlen(a\nb\tc)); // 2. 测试 strcpy printf(Testing my_strcpy...\n); char dest1[20]; char src1[] Copy this!; assert(strcmp(my_strcpy(dest1, src1), strcpy(dest1, src1)) 0); // 测试自我复制 (标准库行为是未定义但我们实现可能工作) char self[] self; my_strcpy(self, self); // 需要我们的实现能处理这种情况指针相同 // 3. 测试 strncpy printf(Testing my_strncpy...\n); char dest2[10]; char src2[] HelloWorld; my_strncpy(dest2, src2, 5); dest2[5] \0; // 手动添加结束符因为 src2 长度 5 assert(strcmp(dest2, Hello) 0); char dest3[10] XXXXXX; my_strncpy(dest3, AB, 5); // dest3 现在应该是: A, B, \0, \0, \0, X, \0... assert(dest3[0] A); assert(dest3[1] B); assert(dest3[2] \0); // 被填充的 \0 assert(dest3[3] \0); // 被填充的 \0 assert(dest3[4] \0); // 被填充的 \0 // dest3[5] 仍然是原来的 X未被修改 // 4. 测试 strcat 和 strncat printf(Testing my_strcat my_strncat...\n); char buf1[20] Hello; my_strcat(buf1, World); assert(strcmp(buf1, Hello World) 0); char buf2[10] Hi; my_strncat(buf2, there!, 4); // 追加 the assert(strcmp(buf2, Hi the) 0); // 注意strncat 会自动加 \0 // 5. 测试 strcmp 和 strncmp printf(Testing my_strcmp my_strncmp...\n); assert(my_strcmp(apple, banana) 0); assert(my_strcmp(banana, apple) 0); assert(my_strcmp(same, same) 0); assert(my_strcmp(short, shorter) 0); // ‘\0’ 的 ASCII (0) 小于 ‘e’ (101) assert(my_strncmp(abcde, abcxx, 3) 0); // 前3个字符相同 assert(my_strncmp(abcde, abcxx, 5) 0); // 第4个字符 ‘d’ ‘x’ // 6. 测试 memcpy 和 memmove printf(Testing my_memcpy my_memmove...\n); char arr1[10] {0,1,2,3,4,5,6,7,8,9}; char arr2[10]; my_memcpy(arr2, arr1, 10); assert(memcmp(arr2, arr1, 10) 0); // 重叠测试将 arr1 中 [0,1,2,3,4] 复制到 [2,3,4,5,6] 的位置 // 期望结果: arr1 变成 [0, 1, 0, 1, 2, 3, 4, 7, 8, 9] char arr3[10] {0,1,2,3,4,5,6,7,8,9}; my_memmove(arr32, arr3, 5); assert(arr3[0]0 arr3[1]1 arr3[2]0 arr3[3]1 arr3[4]2 arr3[5]3 arr3[6]4); // 7. 测试 strchr 和 strstr printf(Testing my_strchr my_strstr...\n); char *test_str Find the needle in the haystack.; assert(my_strchr(test_str, n) strchr(test_str, n)); assert(my_strchr(test_str, z) NULL); assert(my_strchr(test_str, \0) test_str strlen(test_str)); assert(my_strstr(test_str, needle) strstr(test_str, needle)); assert(my_strstr(test_str, needle) ! NULL); assert(my_strstr(test_str, pin) NULL); assert(my_strstr(, ) ); // 空串是空串的子串 assert(my_strstr(abc, ) abc); // 空串是任何串的子串 printf(All tests passed!\n); return 0; }9.2 必须考虑的边界与异常情况通过测试我们需要特别关注以下几类情况它们往往是Bug的藏身之处空指针NULL标准库函数在接收空指针时行为是“未定义的”通常导致程序崩溃。我们的模拟实现可以选择加入防御性检查如返回0或NULL但要知道这偏离了标准行为。在面试或严格模拟时通常不考虑空指针因为调用者有责任确保参数有效。空字符串“”这是一个有效的字符串只包含一个\0。我们的函数必须能正确处理它例如strlen(“”)应返回0strstr(haystack, “”)应返回haystack。零长度操作strncpy(dest, src, 0)、memcpy(dest, src, 0)等。这些操作不应该修改任何内存我们的实现需要正确处理例如直接返回dest。重叠内存这是memcpy和memmove的关键区别也是strcpy在自复制时可能遇到的问题。我们的memmove实现必须正确处理。目标缓冲区大小这是所有“不安全”函数strcpy,strcat,sprintf等的根源问题。在模拟实现中我们遵循原样但在实际项目中必须使用带长度限制的版本strncpy、strncat、snprintf或更安全的替代品并仔细计算缓冲区大小。字符符号性在strcmp系列函数中比较时必须将char转换为unsigned char以确保比较结果与机器符号表示无关。查找函数的返回值strchr查找\0应返回指向结尾的指针strstr查找空子串应返回原串指针。这些边缘情况容易被忽略。10. 从模拟实现到工程实践经验、教训与安全编码走完这一遍模拟实现我们收获的远不止几行代码。更重要的是我们洞悉了这些基础工具的内部逻辑、潜在陷阱和设计哲学。下面是我在实际项目中总结出的几点核心经验1. 理解“未定义行为”的代价标准库函数在很多边界条件下如空指针、缓冲区溢出的行为是“未定义的”。这意味着编译器可以生成任何代码程序可能崩溃、产生错误结果、或者看似正常地运行直到某个关键时刻出错。我们的模拟练习让我们亲身体验了这些边界从而在以后编码时会对这些地方产生本能的警惕。例如在调用strcpy前你脑子里会立刻响起警报“dest的空间够吗”2. 优先使用“n”版本函数但务必理解其语义strncpy、strncat、snprintf是你的朋友但它们是“带刺的朋友”。你必须清楚strncpy不会自动添加\0可能产生非终止字符串。strncat和snprintf会保证添加\0只要目标空间大小参数size 0。永远记得strncpy的n是“最大复制字符数”而strncat和snprintf的n或size是“目标缓冲区总大小”。混淆它们会导致灾难。一个安全的strncpy使用模式几乎总是成对出现char buf[64]; strncpy(buf, src, sizeof(buf) - 1); buf[sizeof(buf) - 1] \0; // 手动确保终止3. 考虑使用更现代的替代方案如果你的项目环境允许可以考虑以下更安全的方案strlcpy/strlcat来自BSD语义清晰参数是目标缓冲区总大小总是保证\0结尾返回源长度但非C标准。C11 Annex K Bounds-checking interfaces如strcpy_s,strcat_s。它们有更严格的运行时检查但普及度不高且使用稍显繁琐。使用高级语言或库在C中优先使用std::string。在C中可以依赖一些经过严格测试的第三方安全字符串库。4. 内存重叠是隐形的杀手除非你百分之百确定两块内存不重叠否则对于内存复制操作无条件使用memmove。memcpy的速度优势在当今编译器优化面前已不明显而memmove带来的安全性提升是实实在在的。这个习惯能帮你避免许多难以调试的诡异Bug。5. 手动实现是理解的终极检验当你对某个库函数的行为有疑惑或者面试中被问到其实现时没有比在脑子里或纸上模拟一遍其运行过程更好的方法了。这个过程强迫你考虑每一个字节、每一个指针的变化。例如你能清晰地说出while (*d *s);这个循环的结束条件吗它为什么能正确复制\0最后记住C语言字符串的核心是“以\0结尾的字符数组”。这个简单的约定带来了巨大的灵活性和同样巨大的责任。我们的模拟实现之旅本质上是一次对这份责任的深度体验。把这些函数的内部逻辑刻在脑子里你就能在纷繁复杂的代码中对字符串操作保持一份清醒和掌控力。 C语言字符串函数模拟实现：从strcpy到memmove的底层原理与安全实践
1. 项目缘起为什么我们要亲手“造轮子”刚学C语言那会儿我总觉得strcpy、strcat这些函数用起来理所当然不就是库函数嘛调用一下就行了。直到后来自己写项目遇到了缓冲区溢出导致程序崩溃或者处理特殊字符时结果总是不对才回过头来琢磨这些黑盒子里面到底发生了什么它们有没有什么我没注意到的“坑”从那时起我就养成了一个习惯对于核心的、常用的库函数一定要自己动手模拟实现一遍。这绝不是浪费时间而是一种“知其然更知其所以然”的深度修炼。今天我们就来彻底拆解C语言中最常用的几个字符串处理函数。我们的目标不是简单地复述手册而是像设计者一样思考从零开始用最纯粹的C语言一步步构建出它们的“平替”版本。你会看到一个看似简单的strlen在追求极致效率时可以有多种写法一个常用的strcpy如果不注意边界检查可能就是安全漏洞的温床。通过这个过程你不仅能牢牢掌握这些函数的内部机理更能深刻理解指针操作、内存管理和编码安全的精髓这对于你未来无论是做嵌入式开发、系统编程还是应对各种笔试面试都将是极为扎实的功底。2. 模拟实现前的核心思想与约束在动手写代码之前我们必须先统一思想明确游戏规则。模拟实现不是天马行空的创造而是在给定约束下的精确还原。2.1 函数原型与行为的一致性这是最高原则。我们模拟的函数其名称、参数类型、返回类型以及最重要的——外部行为必须与标准库函数完全一致。这意味着参数不变标准库的strcpy声明是char *strcpy(char *dest, const char *src);我们的模拟函数也必须是这个签名。返回值一致标准库的strcpy返回目标字符串的起始地址即dest我们的实现也必须返回dest。这个返回值常被用于链式调用比如strcat(strcpy(dest, src1), src2)。副作用相同函数对内存的修改、对输入参数的依赖关系必须一致。例如strcpy会修改dest指向的内存并且依赖于src指向的以\0结尾的字符串。2.2 关于“安全性”的边界讨论这是一个关键且容易引起困惑的点。C标准库中原始的字符串函数如strcpy,strcat本身不检查目标缓冲区的大小这是它们被认为“不安全”的根源。它们的设计哲学是“程序员负责一切”追求极致的速度和简洁。注意在我们的模拟实现中我们首先严格遵循原始函数的不安全行为进行实现。这是为了理解其最本质的工作原理。之后我们会在分析章节专门探讨如何在此基础上增加安全检查演进出strncpy、strlcpy非标准但流行等安全版本。请务必分清“模拟原始行为”和“编写安全代码”是两个阶段的任务。2.3 我们的“武器库”允许使用的底层操作既然要模拟我们就不能直接调用其他的字符串库函数否则就成了套娃。我们被允许使用的“原子操作”非常有限指针的算术运算与解引用这是核心中的核心。*p,*(p1),p等。基本赋值与比较,,!,,等。循环与条件判断while,for,if。内存访问通过指针读写内存。我们的所有实现都将建立在这些基础操作之上。好了思想准备就绪让我们开始第一个也是最基础的一个函数。3. 求字符串长度strlen 的多种实现与效率权衡strlen的功能是计算一个以空字符\0结尾的字符串的长度不包括\0本身。听起来很简单但实现方式却能体现出不同的编程思维和优化技巧。3.1 最直观的版本计数器法这是初学者最容易想到的方法。用一个临时指针遍历字符串同时用一个整型变量count来记录步数。// 版本1计数器法 size_t my_strlen_counter(const char *str) { size_t count 0; // 用于计数的变量 if (str NULL) { // 良好的习惯检查输入指针是否有效 return 0; // 处理空指针实际标准库行为未定义这里我们做防御性处理 } while (*str ! \0) { // 遍历直到遇到字符串结束符 count; str; } return count; }实现解析count初始为0。while循环检查当前str指向的字符是否为\0如果不是count加1指针str向后移动一个字符指向下一个字符。循环结束时count的值就是字符串的长度。这个版本逻辑清晰易于理解但每次循环要执行两次加法count和str和一次比较。3.2 更C语言风格的版本指针差值法C语言中指针减指针可以得到它们之间相差的元素个数。我们可以利用这一点省去单独的计数器。// 版本2指针差值法 size_t my_strlen_ptr_diff(const char *str) { const char *start str; // 记录起始位置 if (str NULL) { return 0; } while (*str ! \0) { str; } return (size_t)(str - start); // 结束位置减去起始位置即为长度 }实现解析在开始遍历前用start指针记录字符串的起始地址。然后让str指针一路走到\0的位置。最后str - start得到的就是从头到尾走过的字符数也就是字符串长度。这个方法比计数器法更“地道”它直接利用了指针运算的特性通常效率也略高一点。3.3 追求极致的版本无分支优化与字长读取在一些高性能库如Glibc的实现中strlen会采用更复杂、更极致的优化。其核心思想是对齐内存访问现代CPU对对齐的内存访问如4字节或8字节对齐速度更快。实现会先处理开头几个不对齐的字节直到指针指向一个对齐的地址。按机器字长Word读取一次不是读取一个字符1字节而是读取一个机器字比如4或8字节。这相当于同时检查多个字符是否为\0。位运算技巧快速检测0字节在一个字比如0x44332201中快速判断是否有任何一个字节为0x00。这通常通过神奇的位运算公式实现例如((x - 0x01010101) ~x 0x80808080)对于32位系统。无分支循环减少或消除循环内的条件判断利用位运算结果来定位\0。这种实现非常复杂涉及大量底层知识其目的是为了在处理长字符串时获得数倍甚至数十倍的性能提升。对于我们理解基本原理而言前两种实现已经足够。但你需要知道一个简单的strlen在工业级代码中可能藏着如此深的优化心思。4. 字符串复制strcpy 与 strncpy 的陷阱与实现复制函数是字符串操作中最常用也最容易出问题的地方。4.1 标准 strcpy 的模拟实现char *strcpy(char *dest, const char *src);将src指向的字符串包括结尾的\0复制到dest指向的内存空间。// 模拟实现标准 strcpy char *my_strcpy(char *dest, const char *src) { // 参数检查标准库不检查但好的模拟实现可以加入 // assert(dest ! NULL src ! NULL); char *ret dest; // 保存目标字符串起始地址用于返回 while ((*dest *src) ! \0) { // 循环体为空所有操作都在条件判断中完成 } return ret; }实现解析这行while ((*dest *src) ! \0)是C语言中一个经典且紧凑的写法。它的执行顺序是将src指向的字符赋值给dest指向的位置*dest *src。判断这个被赋值的字符是否等于\0。无论是否等于\0dest和src指针都自增1指向下一个位置。如果步骤2中判断字符不是\0则继续循环如果是\0则循环结束并且\0也已经被复制过去了。这个实现完美复刻了标准库的行为它假设dest指向的内存空间足够大能容纳src的所有字符包括\0。如果dest空间不足就会发生缓冲区溢出Buffer Overflow覆盖后面的内存数据导致程序崩溃或产生安全漏洞。这是原始strcpy最大的“罪”。4.2 有限长度的复制strncpy 的模拟与误区为了缓解溢出问题C库提供了char *strncpy(char *dest, const char *src, size_t n);。它的逻辑是最多复制n个字符从src到dest。// 模拟实现标准 strncpy char *my_strncpy(char *dest, const char *src, size_t n) { char *ret dest; size_t i; for (i 0; i n src[i] ! \0; i) { dest[i] src[i]; } // 关键且反直觉的部分如果 i n说明 src 提前结束了需要用 \0 填充剩余空间 for ( ; i n; i) { dest[i] \0; } return ret; }实现解析与重大陷阱复制阶段for循环在两种情况下停止复制够了n个字符或者遇到了src的结束符\0。填充阶段这是strncpy最特殊也最容易被误用的一点如果src的长度小于nstrncpy会用\0填充dest中剩余的所有字节直到写满n个字符。结尾符不确定性strncpy不保证目标字符串以\0结尾只有在两种情况下dest会以\0结尾src的长度包括\0小于n此时dest的最后一个有效字符是填充的\0。src的长度大于等于n此时dest恰好被src的前n个字符填满最后一个字符不是\0。踩坑实录很多人以为strncpy是安全的strcpy直接strncpy(dest, src, sizeof(dest))。这错了如果src很长dest会被填满且没有\0结尾。后续使用dest作为字符串的函数如printf(“%s”, dest)会一直读取内存直到遇到一个随机的\0导致溢出或乱码。正确的做法是手动确保结尾strncpy(dest, src, sizeof(dest)-1); dest[sizeof(dest)-1] \0;。4.3 更优的选择模拟 strlcpy 的思路正因为strncpy的怪异行为很多系统如BSD引入了strlcpy。它的原型是size_t strlcpy(char *dest, const char *src, size_t size);其设计目标是安全且易于正确使用。// 模拟 strlcpy 的行为非标准但更安全 size_t my_strlcpy(char *dest, const char *src, size_t size) { size_t src_len my_strlen(src); // 需要先知道源串长度 size_t n; if (size 0) { return src_len; // 如果目标空间为0直接返回源串长度需要复制的长度 } // 计算实际能复制的字符数留一个位置给 \0 n (src_len size) ? (size - 1) : src_len; // 复制最多 n 个字符 for (size_t i 0; i n; i) { dest[i] src[i]; } dest[n] \0; // 无论何种情况都确保目标字符串以 \0 结尾 return src_len; // 返回源串长度方便调用者判断是否被截断 }实现解析strlcpy的理念是“安全第一结果可预测”。它总是保证dest以\0结尾只要size 0。它的第三个参数size指的是dest缓冲区的总大小包括\0的位置而不是最大复制字符数。这更符合直觉。返回值是src的长度。这样调用者可以轻松判断复制是否被截断if (retval size) { /* 发生了截断 */ }。虽然strlcpy不是C标准库函数但其清晰的安全语义使得它在很多项目中成为首选。自己实现一个类似逻辑的函数是工程中的常见做法。5. 字符串连接strcat 与 strncat 的细节连接函数用于将一个字符串追加到另一个字符串的末尾。5.1 标准 strcat 的模拟实现char *strcat(char *dest, const char *src);将src字符串追加到dest字符串的末尾覆盖dest原有的结束符\0并在连接后的新字符串末尾添加\0。// 模拟实现标准 strcat char *my_strcat(char *dest, const char *src) { char *ret dest; // 第一步找到 dest 字符串的结尾即 \0 的位置 while (*dest ! \0) { dest; } // 第二步从 dest 的结尾开始执行 strcpy 操作 while ((*dest *src) ! \0) { ; } return ret; }实现解析这个实现可以看作strlen(dest)strcpy(dest_end, src)两个操作的组合。第一个while循环定位到dest字符串的末尾\0处。第二个while循环就是我们的my_strcpy逻辑从dest的末尾开始复制src。同样它不检查dest剩余空间是否足够存在缓冲区溢出风险。5.2 有限长度的连接strncat 的模拟实现char *strncat(char *dest, const char *src, size_t n);从src追加最多n个字符到dest末尾并总是添加一个终止空字符\0。// 模拟实现标准 strncat char *my_strncat(char *dest, const char *src, size_t n) { char *ret dest; size_t dest_len my_strlen(dest); dest dest_len; // 移动到 dest 的末尾 size_t i; // 复制 src 中的字符最多 n 个或者遇到 \0 停止 for (i 0; i n src[i] ! \0; i) { dest[i] src[i]; } // 关键无论复制了多少个字符总是在末尾添加 \0 dest[i] \0; return ret; }实现解析strncat比strncpy的行为要友好得多也安全得多。它先找到dest的末尾。然后从src复制最多n个非\0字符过去。最重要的一点复制完成后它总是在目标字符串的末尾添加一个\0。这意味着dest永远是一个有效的C字符串。它不会像strncpy那样用\0填充剩余空间。因此strncat是相对更安全的连接函数。但调用者仍需确保dest有足够的空间容纳dest原有的字符 min(n, strlen(src))个新字符 1个\0。6. 字符串比较strcmp 与 strncmp 的逐字节逻辑比较函数用于按字典序ASCII码顺序比较两个字符串。6.1 标准 strcmp 的模拟实现int strcmp(const char *str1, const char *str2);比较两个字符串。返回值为 0str1小于str2第一个不匹配字符的ASCII值在str1中小于在str2中或str1是str2的前缀。 0str1等于str2。 0str1大于str2。// 模拟实现标准 strcmp int my_strcmp(const char *str1, const char *str2) { // 循环比较直到遇到不相等的字符或遇到 \0 while (*str1 ! \0 *str1 *str2) { str1; str2; } // 返回两个当前字符的ASCII差值 return *(unsigned char *)str1 - *(unsigned char *)str2; }实现解析while循环的条件是两个指针都没走到结尾*str1 ! ‘\0’并且当前字符相等*str1 *str2。只要条件满足就继续比较下一个字符。循环退出时有两种可能遇到了不相等的字符。str1走到了结尾此时*str2可能是\0也可能不是。返回值计算将两个当前字符**转换为unsigned char**后相减。这是为了正确处理负值的char在一些系统上char默认为signed。例如比较”\xFF”和”\x00”如果按signed char解释-1 - 0 -1如果按unsigned char解释255 - 0 255。标准要求按unsigned char比较以确保结果一致。如果str1先结束且str2在相同位置也是\0则循环因*str1 ‘\0’而*str1 *str2不成立因为\0 \0为真但*str1 ! ‘\0’为假退出循环。此时*str1和*str2都是\0相减结果为0表示字符串相等。6.2 有限长度的比较strncmp 的模拟实现int strncmp(const char *str1, const char *str2, size_t n);比较两个字符串的前n个字符。// 模拟实现标准 strncmp int my_strncmp(const char *str1, const char *str2, size_t n) { if (n 0) { return 0; // 比较0个字符认为相等 } while (--n 0 *str1 ! \0 *str1 *str2) { str1; str2; } return *(unsigned char *)str1 - *(unsigned char *)str2; }实现解析逻辑与strcmp类似但增加了比较次数n的限制。如果n为0直接返回0相等。while循环条件--n 0确保最多比较n-1次因为先减减。同时也要满足两个字符串都没结束且当前字符相等。循环退出条件可能是比较次数用尽n变为0、遇到不相等的字符、或某个字符串结束。返回值的计算方式与strcmp完全相同比较的是退出循环时的当前字符。strncmp常用于比较字符串的前缀或者当你知道只需要比较固定长度时它更安全因为它不会因为字符串缺少\0而一直读取越界尽管标准字符串应该以\0结尾但破损的数据中可能没有。7. 内存操作函数的跨界模拟memcpy 与 memmove严格来说memcpy和memmove不是字符串函数它们处理的是内存块不关心\0但它们与字符串操作息息相关且实现思想非常经典。7.1 内存复制memcpy 的模拟实现与限制void *memcpy(void *dest, const void *src, size_t n);从src指向的位置开始复制n个字节到dest指向的位置。// 模拟实现标准 memcpy (基础版本) void *my_memcpy(void *dest, const void *src, size_t n) { char *d (char *)dest; const char *s (const char *)src; // 通常的简单实现按字节从前向后复制 for (size_t i 0; i n; i) { d[i] s[i]; } return dest; }实现解析与重大限制这个简单的逐字节复制实现在大多数情况下工作良好。但是标准库的memcpy有一个非常重要的限制它要求源内存区域和目标内存区域不能重叠。如果重叠其行为是未定义的Undefined Behavior。为什么考虑src和dest重叠的情况例如dest在src后面一点。当我们从前向后复制时src中尚未被复制的数据可能会先被dest覆盖掉导致复制结果错误。例如想把”hello”从地址0复制到地址1期望得到”hhello”但从前向后复制会得到”hhhhh”。7.2 可处理重叠的内存复制memmove 的模拟实现void *memmove(void *dest, const void *src, size_t n);功能与memcpy类似但允许源和目标内存区域重叠。它是更安全的选择。// 模拟实现标准 memmove void *my_memmove(void *dest, const void *src, size_t n) { char *d (char *)dest; const char *s (const char *)src; if (d s || n 0) { return dest; // 源和目标相同或复制长度为0直接返回 } // 判断内存区域是否重叠以及重叠的类型 if (d s) { // 情况1目标地址在源地址之前从前向后复制是安全的 for (size_t i 0; i n; i) { d[i] s[i]; } } else { // 情况2目标地址在源地址之后或相等但前面已排除相等从后向前复制以避免覆盖 for (size_t i n; i 0; i--) { d[i - 1] s[i - 1]; } } return dest; }实现解析memmove的智慧在于复制方向的判断。无重叠或目标在前如果dest的地址小于src的地址或者两者不重叠从前向后复制是安全的。因为即使重叠dest在前面它覆盖的是src已经“用过”的旧数据区域不会影响后面待复制的数据。目标在后重叠如果dest的地址大于src的地址并且两者重叠dest src n此时从前向后复制会破坏源数据。正确的做法是从后向前复制。从最后一个字节开始依次向前复制这样源区域中尚未被读取的数据就不会先被目标区域覆盖。经验之谈在实际编程中如果你不确定两块内存是否重叠永远优先使用memmove。虽然它的名字暗示着“移动”但它完全能胜任memcpy的工作并且在重叠时行为是确定的。现代编译器的优化非常智能在检测到内存不重叠时对memmove的调用很可能被优化成与memcpy同样高效的指令。用memmove代替memcpy是一个低成本的高安全习惯。8. 字符串查找strchr 与 strstr 的算法思路查找函数用于在字符串中定位字符或子串。8.1 查找字符strchr 的模拟实现char *strchr(const char *str, int c);在字符串str中查找第一次出现字符c转换为char的位置并返回指向该位置的指针。如果未找到返回NULL。// 模拟实现标准 strchr char *my_strchr(const char *str, int c) { if (str NULL) { return NULL; } char ch (char)c; // 将 int 转换为 char while (*str ! \0) { if (*str ch) { return (char *)str; // 找到返回指针。需要去除 const 限定 } str; } // 循环结束也没找到检查是否在找 \0 if (ch \0) { return (char *)str; // 标准规定查找 \0 应返回指向字符串结尾的指针 } return NULL; // 未找到 }实现解析逻辑很直接遍历字符串逐个字符比较。有两个细节需要注意参数c是int类型这是历史原因为了兼容EOF通常是-1。在函数内部需要将其转换为char类型进行比较。查找空字符\0根据C标准strchr也可以用来查找字符串的结束符\0此时应返回指向\0的指针。我们的实现通过循环后的一个特殊判断来处理这种情况。8.2 查找子串strstr 的朴素算法实现char *strstr(const char *haystack, const char *needle);在haystack干草堆字符串中查找第一次出现needle针子串的位置。// 模拟实现标准 strstr (朴素匹配算法Brute-Force) char *my_strstr(const char *haystack, const char *needle) { if (haystack NULL || needle NULL) { return NULL; } if (*needle \0) { return (char *)haystack; // 空子串是任何字符串的子串返回原串起始位置 } const char *h; const char *n; const char *start haystack; while (*start ! \0) { h start; n needle; // 内层循环比较从 start 开始的子串是否与 needle 匹配 while (*h ! \0 *n ! \0 *h *n) { h; n; } // 判断匹配是否成功 if (*n \0) { // needle 全部比较完毕说明找到了 return (char *)start; } if (*h \0) { // haystack 剩余部分长度已经小于 needle不可能再找到 break; } // 本次匹配失败start 向后移动一位继续尝试 start; } return NULL; // 未找到 }实现解析朴素算法外层循环指针start从haystack的第一个字符开始每次尝试作为一个可能的匹配起点。内层循环用指针h和n分别从当前的start和needle开头开始逐个字符比较。匹配成功条件内层循环一直进行到*n ‘\0’这意味着needle的所有字符都匹配上了函数返回当前的start指针。匹配失败如果内层循环因为*h ! *n而退出说明当前start位置不匹配。start向后移动一位继续尝试。提前终止优化如果内层循环因为*h ‘\0’而退出即haystack先到头了而*n还不是\0说明剩下的haystack长度已经比needle短不可能再匹配成功直接跳出外层循环返回NULL。这个算法被称为“朴素匹配”或“暴力匹配”其时间复杂度在最坏情况下是O(m*n)其中m和n分别是两个字符串的长度。对于短字符串这完全够用。标准库的实现如Glibc在检测到needle较长时可能会使用更高效的算法如KMP算法或Boyer-Moore算法这些算法通过预处理needle可以在某些情况下达到O(mn)的线性时间复杂度。理解朴素算法是学习这些高级算法的基础。9. 综合测试与边界条件思考纸上得来终觉浅绝知此事要躬行。写完了所有模拟函数我们必须进行全面的测试尤其是各种边界情况和异常输入。9.1 构建一个简单的测试框架我们可以编写一个简单的main函数来测试我们的实现。为了严谨应该将我们的模拟函数与标准库函数在相同输入下的输出进行对比。#include stdio.h #include string.h #include assert.h // 这里插入我们上面实现的所有 my_xxx 函数... int main() { // 1. 测试 strlen printf(Testing my_strlen...\n); assert(my_strlen() strlen()); assert(my_strlen(hello) strlen(hello)); assert(my_strlen(a\nb\tc) strlen(a\nb\tc)); // 2. 测试 strcpy printf(Testing my_strcpy...\n); char dest1[20]; char src1[] Copy this!; assert(strcmp(my_strcpy(dest1, src1), strcpy(dest1, src1)) 0); // 测试自我复制 (标准库行为是未定义但我们实现可能工作) char self[] self; my_strcpy(self, self); // 需要我们的实现能处理这种情况指针相同 // 3. 测试 strncpy printf(Testing my_strncpy...\n); char dest2[10]; char src2[] HelloWorld; my_strncpy(dest2, src2, 5); dest2[5] \0; // 手动添加结束符因为 src2 长度 5 assert(strcmp(dest2, Hello) 0); char dest3[10] XXXXXX; my_strncpy(dest3, AB, 5); // dest3 现在应该是: A, B, \0, \0, \0, X, \0... assert(dest3[0] A); assert(dest3[1] B); assert(dest3[2] \0); // 被填充的 \0 assert(dest3[3] \0); // 被填充的 \0 assert(dest3[4] \0); // 被填充的 \0 // dest3[5] 仍然是原来的 X未被修改 // 4. 测试 strcat 和 strncat printf(Testing my_strcat my_strncat...\n); char buf1[20] Hello; my_strcat(buf1, World); assert(strcmp(buf1, Hello World) 0); char buf2[10] Hi; my_strncat(buf2, there!, 4); // 追加 the assert(strcmp(buf2, Hi the) 0); // 注意strncat 会自动加 \0 // 5. 测试 strcmp 和 strncmp printf(Testing my_strcmp my_strncmp...\n); assert(my_strcmp(apple, banana) 0); assert(my_strcmp(banana, apple) 0); assert(my_strcmp(same, same) 0); assert(my_strcmp(short, shorter) 0); // ‘\0’ 的 ASCII (0) 小于 ‘e’ (101) assert(my_strncmp(abcde, abcxx, 3) 0); // 前3个字符相同 assert(my_strncmp(abcde, abcxx, 5) 0); // 第4个字符 ‘d’ ‘x’ // 6. 测试 memcpy 和 memmove printf(Testing my_memcpy my_memmove...\n); char arr1[10] {0,1,2,3,4,5,6,7,8,9}; char arr2[10]; my_memcpy(arr2, arr1, 10); assert(memcmp(arr2, arr1, 10) 0); // 重叠测试将 arr1 中 [0,1,2,3,4] 复制到 [2,3,4,5,6] 的位置 // 期望结果: arr1 变成 [0, 1, 0, 1, 2, 3, 4, 7, 8, 9] char arr3[10] {0,1,2,3,4,5,6,7,8,9}; my_memmove(arr32, arr3, 5); assert(arr3[0]0 arr3[1]1 arr3[2]0 arr3[3]1 arr3[4]2 arr3[5]3 arr3[6]4); // 7. 测试 strchr 和 strstr printf(Testing my_strchr my_strstr...\n); char *test_str Find the needle in the haystack.; assert(my_strchr(test_str, n) strchr(test_str, n)); assert(my_strchr(test_str, z) NULL); assert(my_strchr(test_str, \0) test_str strlen(test_str)); assert(my_strstr(test_str, needle) strstr(test_str, needle)); assert(my_strstr(test_str, needle) ! NULL); assert(my_strstr(test_str, pin) NULL); assert(my_strstr(, ) ); // 空串是空串的子串 assert(my_strstr(abc, ) abc); // 空串是任何串的子串 printf(All tests passed!\n); return 0; }9.2 必须考虑的边界与异常情况通过测试我们需要特别关注以下几类情况它们往往是Bug的藏身之处空指针NULL标准库函数在接收空指针时行为是“未定义的”通常导致程序崩溃。我们的模拟实现可以选择加入防御性检查如返回0或NULL但要知道这偏离了标准行为。在面试或严格模拟时通常不考虑空指针因为调用者有责任确保参数有效。空字符串“”这是一个有效的字符串只包含一个\0。我们的函数必须能正确处理它例如strlen(“”)应返回0strstr(haystack, “”)应返回haystack。零长度操作strncpy(dest, src, 0)、memcpy(dest, src, 0)等。这些操作不应该修改任何内存我们的实现需要正确处理例如直接返回dest。重叠内存这是memcpy和memmove的关键区别也是strcpy在自复制时可能遇到的问题。我们的memmove实现必须正确处理。目标缓冲区大小这是所有“不安全”函数strcpy,strcat,sprintf等的根源问题。在模拟实现中我们遵循原样但在实际项目中必须使用带长度限制的版本strncpy、strncat、snprintf或更安全的替代品并仔细计算缓冲区大小。字符符号性在strcmp系列函数中比较时必须将char转换为unsigned char以确保比较结果与机器符号表示无关。查找函数的返回值strchr查找\0应返回指向结尾的指针strstr查找空子串应返回原串指针。这些边缘情况容易被忽略。10. 从模拟实现到工程实践经验、教训与安全编码走完这一遍模拟实现我们收获的远不止几行代码。更重要的是我们洞悉了这些基础工具的内部逻辑、潜在陷阱和设计哲学。下面是我在实际项目中总结出的几点核心经验1. 理解“未定义行为”的代价标准库函数在很多边界条件下如空指针、缓冲区溢出的行为是“未定义的”。这意味着编译器可以生成任何代码程序可能崩溃、产生错误结果、或者看似正常地运行直到某个关键时刻出错。我们的模拟练习让我们亲身体验了这些边界从而在以后编码时会对这些地方产生本能的警惕。例如在调用strcpy前你脑子里会立刻响起警报“dest的空间够吗”2. 优先使用“n”版本函数但务必理解其语义strncpy、strncat、snprintf是你的朋友但它们是“带刺的朋友”。你必须清楚strncpy不会自动添加\0可能产生非终止字符串。strncat和snprintf会保证添加\0只要目标空间大小参数size 0。永远记得strncpy的n是“最大复制字符数”而strncat和snprintf的n或size是“目标缓冲区总大小”。混淆它们会导致灾难。一个安全的strncpy使用模式几乎总是成对出现char buf[64]; strncpy(buf, src, sizeof(buf) - 1); buf[sizeof(buf) - 1] \0; // 手动确保终止3. 考虑使用更现代的替代方案如果你的项目环境允许可以考虑以下更安全的方案strlcpy/strlcat来自BSD语义清晰参数是目标缓冲区总大小总是保证\0结尾返回源长度但非C标准。C11 Annex K Bounds-checking interfaces如strcpy_s,strcat_s。它们有更严格的运行时检查但普及度不高且使用稍显繁琐。使用高级语言或库在C中优先使用std::string。在C中可以依赖一些经过严格测试的第三方安全字符串库。4. 内存重叠是隐形的杀手除非你百分之百确定两块内存不重叠否则对于内存复制操作无条件使用memmove。memcpy的速度优势在当今编译器优化面前已不明显而memmove带来的安全性提升是实实在在的。这个习惯能帮你避免许多难以调试的诡异Bug。5. 手动实现是理解的终极检验当你对某个库函数的行为有疑惑或者面试中被问到其实现时没有比在脑子里或纸上模拟一遍其运行过程更好的方法了。这个过程强迫你考虑每一个字节、每一个指针的变化。例如你能清晰地说出while (*d *s);这个循环的结束条件吗它为什么能正确复制\0最后记住C语言字符串的核心是“以\0结尾的字符数组”。这个简单的约定带来了巨大的灵活性和同样巨大的责任。我们的模拟实现之旅本质上是一次对这份责任的深度体验。把这些函数的内部逻辑刻在脑子里你就能在纷繁复杂的代码中对字符串操作保持一份清醒和掌控力。