模擬實現(xiàn)：從strcpy到memmove的底層原理與安全實踐)
1. 項目緣起為什么我們要親手“造輪子”剛學C語言那會兒我總覺得strcpy、strcat這些函數(shù)用起來理所當然不就是庫函數(shù)嘛調(diào)用一下就行了。直到后來自己寫項目遇到了緩沖區(qū)溢出導致程序崩潰或者處理特殊字符時結(jié)果總是不對才回過頭來琢磨這些黑盒子里面到底發(fā)生了什么它們有沒有什么我沒注意到的“坑”從那時起我就養(yǎng)成了一個習慣對于核心的、常用的庫函數(shù)一定要自己動手模擬實現(xiàn)一遍。這絕不是浪費時間而是一種“知其然更知其所以然”的深度修煉。今天我們就來徹底拆解C語言中最常用的幾個字符串處理函數(shù)。我們的目標不是簡單地復述手冊而是像設計者一樣思考從零開始用最純粹的C語言一步步構(gòu)建出它們的“平替”版本。你會看到一個看似簡單的strlen在追求極致效率時可以有多種寫法一個常用的strcpy如果不注意邊界檢查可能就是安全漏洞的溫床。通過這個過程你不僅能牢牢掌握這些函數(shù)的內(nèi)部機理更能深刻理解指針操作、內(nèi)存管理和編碼安全的精髓這對于你未來無論是做嵌入式開發(fā)、系統(tǒng)編程還是應對各種筆試面試都將是極為扎實的功底。2. 模擬實現(xiàn)前的核心思想與約束在動手寫代碼之前我們必須先統(tǒng)一思想明確游戲規(guī)則。模擬實現(xiàn)不是天馬行空的創(chuàng)造而是在給定約束下的精確還原。2.1 函數(shù)原型與行為的一致性這是最高原則。我們模擬的函數(shù)其名稱、參數(shù)類型、返回類型以及最重要的——外部行為必須與標準庫函數(shù)完全一致。這意味著參數(shù)不變標準庫的strcpy聲明是char *strcpy(char *dest, const char *src);我們的模擬函數(shù)也必須是這個簽名。返回值一致標準庫的strcpy返回目標字符串的起始地址即dest我們的實現(xiàn)也必須返回dest。這個返回值常被用于鏈式調(diào)用比如strcat(strcpy(dest, src1), src2)。副作用相同函數(shù)對內(nèi)存的修改、對輸入?yún)?shù)的依賴關(guān)系必須一致。例如strcpy會修改dest指向的內(nèi)存并且依賴于src指向的以\0結(jié)尾的字符串。2.2 關(guān)于“安全性”的邊界討論這是一個關(guān)鍵且容易引起困惑的點。C標準庫中原始的字符串函數(shù)如strcpy,strcat本身不檢查目標緩沖區(qū)的大小這是它們被認為“不安全”的根源。它們的設計哲學是“程序員負責一切”追求極致的速度和簡潔。注意在我們的模擬實現(xiàn)中我們首先嚴格遵循原始函數(shù)的不安全行為進行實現(xiàn)。這是為了理解其最本質(zhì)的工作原理。之后我們會在分析章節(jié)專門探討如何在此基礎上增加安全檢查演進出strncpy、strlcpy非標準但流行等安全版本。請務必分清“模擬原始行為”和“編寫安全代碼”是兩個階段的任務。2.3 我們的“武器庫”允許使用的底層操作既然要模擬我們就不能直接調(diào)用其他的字符串庫函數(shù)否則就成了套娃。我們被允許使用的“原子操作”非常有限指針的算術(shù)運算與解引用這是核心中的核心。*p,*(p1),p等?；举x值與比較,,!,,等。循環(huán)與條件判斷while,for,if。內(nèi)存訪問通過指針讀寫內(nèi)存。我們的所有實現(xiàn)都將建立在這些基礎操作之上。好了思想準備就緒讓我們開始第一個也是最基礎的一個函數(shù)。3. 求字符串長度strlen 的多種實現(xiàn)與效率權(quán)衡strlen的功能是計算一個以空字符\0結(jié)尾的字符串的長度不包括\0本身。聽起來很簡單但實現(xiàn)方式卻能體現(xiàn)出不同的編程思維和優(yōu)化技巧。3.1 最直觀的版本計數(shù)器法這是初學者最容易想到的方法。用一個臨時指針遍歷字符串同時用一個整型變量count來記錄步數(shù)。// 版本1計數(shù)器法 size_t my_strlen_counter(const char *str) { size_t count 0; // 用于計數(shù)的變量 if (str NULL) { // 良好的習慣檢查輸入指針是否有效 return 0; // 處理空指針實際標準庫行為未定義這里我們做防御性處理 } while (*str ! \0) { // 遍歷直到遇到字符串結(jié)束符 count; str; } return count; }實現(xiàn)解析count初始為0。while循環(huán)檢查當前str指向的字符是否為\0如果不是count加1指針str向后移動一個字符指向下一個字符。循環(huán)結(jié)束時count的值就是字符串的長度。這個版本邏輯清晰易于理解但每次循環(huán)要執(zhí)行兩次加法count和str和一次比較。3.2 更C語言風格的版本指針差值法C語言中指針減指針可以得到它們之間相差的元素個數(shù)。我們可以利用這一點省去單獨的計數(shù)器。// 版本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); // 結(jié)束位置減去起始位置即為長度 }實現(xiàn)解析在開始遍歷前用start指針記錄字符串的起始地址。然后讓str指針一路走到\0的位置。最后str - start得到的就是從頭到尾走過的字符數(shù)也就是字符串長度。這個方法比計數(shù)器法更“地道”它直接利用了指針運算的特性通常效率也略高一點。3.3 追求極致的版本無分支優(yōu)化與字長讀取在一些高性能庫如Glibc的實現(xiàn)中strlen會采用更復雜、更極致的優(yōu)化。其核心思想是對齊內(nèi)存訪問現(xiàn)代CPU對對齊的內(nèi)存訪問如4字節(jié)或8字節(jié)對齊速度更快。實現(xiàn)會先處理開頭幾個不對齊的字節(jié)直到指針指向一個對齊的地址。按機器字長Word讀取一次不是讀取一個字符1字節(jié)而是讀取一個機器字比如4或8字節(jié)。這相當于同時檢查多個字符是否為\0。位運算技巧快速檢測0字節(jié)在一個字比如0x44332201中快速判斷是否有任何一個字節(jié)為0x00。這通常通過神奇的位運算公式實現(xiàn)例如((x - 0x01010101) ~x 0x80808080)對于32位系統(tǒng)。無分支循環(huán)減少或消除循環(huán)內(nèi)的條件判斷利用位運算結(jié)果來定位\0。這種實現(xiàn)非常復雜涉及大量底層知識其目的是為了在處理長字符串時獲得數(shù)倍甚至數(shù)十倍的性能提升。對于我們理解基本原理而言前兩種實現(xiàn)已經(jīng)足夠。但你需要知道一個簡單的strlen在工業(yè)級代碼中可能藏著如此深的優(yōu)化心思。4. 字符串復制strcpy 與 strncpy 的陷阱與實現(xiàn)復制函數(shù)是字符串操作中最常用也最容易出問題的地方。4.1 標準 strcpy 的模擬實現(xiàn)char *strcpy(char *dest, const char *src);將src指向的字符串包括結(jié)尾的\0復制到dest指向的內(nèi)存空間。// 模擬實現(xiàn)標準 strcpy char *my_strcpy(char *dest, const char *src) { // 參數(shù)檢查標準庫不檢查但好的模擬實現(xiàn)可以加入 // assert(dest ! NULL src ! NULL); char *ret dest; // 保存目標字符串起始地址用于返回 while ((*dest *src) ! \0) { // 循環(huán)體為空所有操作都在條件判斷中完成 } return ret; }實現(xiàn)解析這行while ((*dest *src) ! \0)是C語言中一個經(jīng)典且緊湊的寫法。它的執(zhí)行順序是將src指向的字符賦值給dest指向的位置*dest *src。判斷這個被賦值的字符是否等于\0。無論是否等于\0dest和src指針都自增1指向下一個位置。如果步驟2中判斷字符不是\0則繼續(xù)循環(huán)如果是\0則循環(huán)結(jié)束并且\0也已經(jīng)被復制過去了。這個實現(xiàn)完美復刻了標準庫的行為它假設dest指向的內(nèi)存空間足夠大能容納src的所有字符包括\0。如果dest空間不足就會發(fā)生緩沖區(qū)溢出Buffer Overflow覆蓋后面的內(nèi)存數(shù)據(jù)導致程序崩潰或產(chǎn)生安全漏洞。這是原始strcpy最大的“罪”。4.2 有限長度的復制strncpy 的模擬與誤區(qū)為了緩解溢出問題C庫提供了char *strncpy(char *dest, const char *src, size_t n);。它的邏輯是最多復制n個字符從src到dest。// 模擬實現(xiàn)標準 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]; } // 關(guān)鍵且反直覺的部分如果 i n說明 src 提前結(jié)束了需要用 \0 填充剩余空間 for ( ; i n; i) { dest[i] \0; } return ret; }實現(xiàn)解析與重大陷阱復制階段for循環(huán)在兩種情況下停止復制夠了n個字符或者遇到了src的結(jié)束符\0。填充階段這是strncpy最特殊也最容易被誤用的一點如果src的長度小于nstrncpy會用\0填充dest中剩余的所有字節(jié)直到寫滿n個字符。結(jié)尾符不確定性strncpy不保證目標字符串以\0結(jié)尾只有在兩種情況下dest會以\0結(jié)尾src的長度包括\0小于n此時dest的最后一個有效字符是填充的\0。src的長度大于等于n此時dest恰好被src的前n個字符填滿最后一個字符不是\0。踩坑實錄很多人以為strncpy是安全的strcpy直接strncpy(dest, src, sizeof(dest))。這錯了如果src很長dest會被填滿且沒有\(zhòng)0結(jié)尾。后續(xù)使用dest作為字符串的函數(shù)如printf(“%s”, dest)會一直讀取內(nèi)存直到遇到一個隨機的\0導致溢出或亂碼。正確的做法是手動確保結(jié)尾strncpy(dest, src, sizeof(dest)-1); dest[sizeof(dest)-1] \0;。4.3 更優(yōu)的選擇模擬 strlcpy 的思路正因為strncpy的怪異行為很多系統(tǒng)如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直接返回源串長度需要復制的長度 } // 計算實際能復制的字符數(shù)留一個位置給 \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 結(jié)尾 return src_len; // 返回源串長度方便調(diào)用者判斷是否被截斷 }實現(xiàn)解析strlcpy的理念是“安全第一結(jié)果可預測”。它總是保證dest以\0結(jié)尾只要size 0。它的第三個參數(shù)size指的是dest緩沖區(qū)的總大小包括\0的位置而不是最大復制字符數(shù)。這更符合直覺。返回值是src的長度。這樣調(diào)用者可以輕松判斷復制是否被截斷if (retval size) { /* 發(fā)生了截斷 */ }。雖然strlcpy不是C標準庫函數(shù)但其清晰的安全語義使得它在很多項目中成為首選。自己實現(xiàn)一個類似邏輯的函數(shù)是工程中的常見做法。5. 字符串連接strcat 與 strncat 的細節(jié)連接函數(shù)用于將一個字符串追加到另一個字符串的末尾。5.1 標準 strcat 的模擬實現(xiàn)char *strcat(char *dest, const char *src);將src字符串追加到dest字符串的末尾覆蓋dest原有的結(jié)束符\0并在連接后的新字符串末尾添加\0。// 模擬實現(xiàn)標準 strcat char *my_strcat(char *dest, const char *src) { char *ret dest; // 第一步找到 dest 字符串的結(jié)尾即 \0 的位置 while (*dest ! \0) { dest; } // 第二步從 dest 的結(jié)尾開始執(zhí)行 strcpy 操作 while ((*dest *src) ! \0) { ; } return ret; }實現(xiàn)解析這個實現(xiàn)可以看作strlen(dest)strcpy(dest_end, src)兩個操作的組合。第一個while循環(huán)定位到dest字符串的末尾\0處。第二個while循環(huán)就是我們的my_strcpy邏輯從dest的末尾開始復制src。同樣它不檢查dest剩余空間是否足夠存在緩沖區(qū)溢出風險。5.2 有限長度的連接strncat 的模擬實現(xiàn)char *strncat(char *dest, const char *src, size_t n);從src追加最多n個字符到dest末尾并總是添加一個終止空字符\0。// 模擬實現(xiàn)標準 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]; } // 關(guān)鍵無論復制了多少個字符總是在末尾添加 \0 dest[i] \0; return ret; }實現(xiàn)解析strncat比strncpy的行為要友好得多也安全得多。它先找到dest的末尾。然后從src復制最多n個非\0字符過去。最重要的一點復制完成后它總是在目標字符串的末尾添加一個\0。這意味著dest永遠是一個有效的C字符串。它不會像strncpy那樣用\0填充剩余空間。因此strncat是相對更安全的連接函數(shù)。但調(diào)用者仍需確保dest有足夠的空間容納dest原有的字符 min(n, strlen(src))個新字符 1個\0。6. 字符串比較strcmp 與 strncmp 的逐字節(jié)邏輯比較函數(shù)用于按字典序ASCII碼順序比較兩個字符串。6.1 標準 strcmp 的模擬實現(xiàn)int strcmp(const char *str1, const char *str2);比較兩個字符串。返回值為 0str1小于str2第一個不匹配字符的ASCII值在str1中小于在str2中或str1是str2的前綴。 0str1等于str2。 0str1大于str2。// 模擬實現(xiàn)標準 strcmp int my_strcmp(const char *str1, const char *str2) { // 循環(huán)比較直到遇到不相等的字符或遇到 \0 while (*str1 ! \0 *str1 *str2) { str1; str2; } // 返回兩個當前字符的ASCII差值 return *(unsigned char *)str1 - *(unsigned char *)str2; }實現(xiàn)解析while循環(huán)的條件是兩個指針都沒走到結(jié)尾*str1 ! ‘\0’并且當前字符相等*str1 *str2。只要條件滿足就繼續(xù)比較下一個字符。循環(huán)退出時有兩種可能遇到了不相等的字符。str1走到了結(jié)尾此時*str2可能是\0也可能不是。返回值計算將兩個當前字符**轉(zhuǎn)換為unsigned char**后相減。這是為了正確處理負值的char在一些系統(tǒng)上char默認為signed。例如比較”\xFF”和”\x00”如果按signed char解釋-1 - 0 -1如果按unsigned char解釋255 - 0 255。標準要求按unsigned char比較以確保結(jié)果一致。如果str1先結(jié)束且str2在相同位置也是\0則循環(huán)因*str1 ‘\0’而*str1 *str2不成立因為\0 \0為真但*str1 ! ‘\0’為假退出循環(huán)。此時*str1和*str2都是\0相減結(jié)果為0表示字符串相等。6.2 有限長度的比較strncmp 的模擬實現(xiàn)int strncmp(const char *str1, const char *str2, size_t n);比較兩個字符串的前n個字符。// 模擬實現(xià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; }實現(xiàn)解析邏輯與strcmp類似但增加了比較次數(shù)n的限制。如果n為0直接返回0相等。while循環(huán)條件--n 0確保最多比較n-1次因為先減減。同時也要滿足兩個字符串都沒結(jié)束且當前字符相等。循環(huán)退出條件可能是比較次數(shù)用盡n變?yōu)?、遇到不相等的字符、或某個字符串結(jié)束。返回值的計算方式與strcmp完全相同比較的是退出循環(huán)時的當前字符。strncmp常用于比較字符串的前綴或者當你知道只需要比較固定長度時它更安全因為它不會因為字符串缺少\0而一直讀取越界盡管標準字符串應該以\0結(jié)尾但破損的數(shù)據(jù)中可能沒有。7. 內(nèi)存操作函數(shù)的跨界模擬memcpy 與 memmove嚴格來說memcpy和memmove不是字符串函數(shù)它們處理的是內(nèi)存塊不關(guān)心\0但它們與字符串操作息息相關(guān)且實現(xiàn)思想非常經(jīng)典。7.1 內(nèi)存復制memcpy 的模擬實現(xiàn)與限制void *memcpy(void *dest, const void *src, size_t n);從src指向的位置開始復制n個字節(jié)到dest指向的位置。// 模擬實現(xiàn)標準 memcpy (基礎版本) void *my_memcpy(void *dest, const void *src, size_t n) { char *d (char *)dest; const char *s (const char *)src; // 通常的簡單實現(xiàn)按字節(jié)從前向后復制 for (size_t i 0; i n; i) { d[i] s[i]; } return dest; }實現(xiàn)解析與重大限制這個簡單的逐字節(jié)復制實現(xiàn)在大多數(shù)情況下工作良好。但是標準庫的memcpy有一個非常重要的限制它要求源內(nèi)存區(qū)域和目標內(nèi)存區(qū)域不能重疊。如果重疊其行為是未定義的Undefined Behavior。為什么考慮src和dest重疊的情況例如dest在src后面一點。當我們從前向后復制時src中尚未被復制的數(shù)據(jù)可能會先被dest覆蓋掉導致復制結(jié)果錯誤。例如想把”hello”從地址0復制到地址1期望得到”hhello”但從前向后復制會得到”hhhhh”。7.2 可處理重疊的內(nèi)存復制memmove 的模擬實現(xiàn)void *memmove(void *dest, const void *src, size_t n);功能與memcpy類似但允許源和目標內(nèi)存區(qū)域重疊。它是更安全的選擇。// 模擬實現(xiàn)標準 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直接返回 } // 判斷內(nèi)存區(qū)域是否重疊以及重疊的類型 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; }實現(xiàn)解析memmove的智慧在于復制方向的判斷。無重疊或目標在前如果dest的地址小于src的地址或者兩者不重疊從前向后復制是安全的。因為即使重疊dest在前面它覆蓋的是src已經(jīng)“用過”的舊數(shù)據(jù)區(qū)域不會影響后面待復制的數(shù)據(jù)。目標在后重疊如果dest的地址大于src的地址并且兩者重疊dest src n此時從前向后復制會破壞源數(shù)據(jù)。正確的做法是從后向前復制。從最后一個字節(jié)開始依次向前復制這樣源區(qū)域中尚未被讀取的數(shù)據(jù)就不會先被目標區(qū)域覆蓋。經(jīng)驗之談在實際編程中如果你不確定兩塊內(nèi)存是否重疊永遠優(yōu)先使用memmove。雖然它的名字暗示著“移動”但它完全能勝任memcpy的工作并且在重疊時行為是確定的?，F(xiàn)代編譯器的優(yōu)化非常智能在檢測到內(nèi)存不重疊時對memmove的調(diào)用很可能被優(yōu)化成與memcpy同樣高效的指令。用memmove代替memcpy是一個低成本的高安全習慣。8. 字符串查找strchr 與 strstr 的算法思路查找函數(shù)用于在字符串中定位字符或子串。8.1 查找字符strchr 的模擬實現(xiàn)char *strchr(const char *str, int c);在字符串str中查找第一次出現(xiàn)字符c轉(zhuǎn)換為char的位置并返回指向該位置的指針。如果未找到返回NULL。// 模擬實現(xiàn)標準 strchr char *my_strchr(const char *str, int c) { if (str NULL) { return NULL; } char ch (char)c; // 將 int 轉(zhuǎn)換為 char while (*str ! \0) { if (*str ch) { return (char *)str; // 找到返回指針。需要去除 const 限定 } str; } // 循環(huán)結(jié)束也沒找到檢查是否在找 \0 if (ch \0) { return (char *)str; // 標準規(guī)定查找 \0 應返回指向字符串結(jié)尾的指針 } return NULL; // 未找到 }實現(xiàn)解析邏輯很直接遍歷字符串逐個字符比較。有兩個細節(jié)需要注意參數(shù)c是int類型這是歷史原因為了兼容EOF通常是-1。在函數(shù)內(nèi)部需要將其轉(zhuǎn)換為char類型進行比較。查找空字符\0根據(jù)C標準strchr也可以用來查找字符串的結(jié)束符\0此時應返回指向\0的指針。我們的實現(xiàn)通過循環(huán)后的一個特殊判斷來處理這種情況。8.2 查找子串strstr 的樸素算法實現(xiàn)char *strstr(const char *haystack, const char *needle);在haystack干草堆字符串中查找第一次出現(xiàn)needle針子串的位置。// 模擬實現(xiàn)標準 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; // 內(nèi)層循環(huán)比較從 start 開始的子串是否與 needle 匹配 while (*h ! \0 *n ! \0 *h *n) { h; n; } // 判斷匹配是否成功 if (*n \0) { // needle 全部比較完畢說明找到了 return (char *)start; } if (*h \0) { // haystack 剩余部分長度已經(jīng)小于 needle不可能再找到 break; } // 本次匹配失敗start 向后移動一位繼續(xù)嘗試 start; } return NULL; // 未找到 }實現(xiàn)解析樸素算法外層循環(huán)指針start從haystack的第一個字符開始每次嘗試作為一個可能的匹配起點。內(nèi)層循環(huán)用指針h和n分別從當前的start和needle開頭開始逐個字符比較。匹配成功條件內(nèi)層循環(huán)一直進行到*n ‘\0’這意味著needle的所有字符都匹配上了函數(shù)返回當前的start指針。匹配失敗如果內(nèi)層循環(huán)因為*h ! *n而退出說明當前start位置不匹配。start向后移動一位繼續(xù)嘗試。提前終止優(yōu)化如果內(nèi)層循環(huán)因為*h ‘\0’而退出即haystack先到頭了而*n還不是\0說明剩下的haystack長度已經(jīng)比needle短不可能再匹配成功直接跳出外層循環(huán)返回NULL。這個算法被稱為“樸素匹配”或“暴力匹配”其時間復雜度在最壞情況下是O(m*n)其中m和n分別是兩個字符串的長度。對于短字符串這完全夠用。標準庫的實現(xiàn)如Glibc在檢測到needle較長時可能會使用更高效的算法如KMP算法或Boyer-Moore算法這些算法通過預處理needle可以在某些情況下達到O(mn)的線性時間復雜度。理解樸素算法是學習這些高級算法的基礎。9. 綜合測試與邊界條件思考紙上得來終覺淺絕知此事要躬行。寫完了所有模擬函數(shù)我們必須進行全面的測試尤其是各種邊界情況和異常輸入。9.1 構(gòu)建一個簡單的測試框架我們可以編寫一個簡單的main函數(shù)來測試我們的實現(xiàn)。為了嚴謹應該將我們的模擬函數(shù)與標準庫函數(shù)在相同輸入下的輸出進行對比。#include stdio.h #include string.h #include assert.h // 這里插入我們上面實現(xiàn)的所有 my_xxx 函數(shù)... 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); // 測試自我復制 (標準庫行為是未定義但我們實現(xiàn)可能工作) char self[] self; my_strcpy(self, self); // 需要我們的實現(xiàn)能處理這種情況指針相同 // 3. 測試 strncpy printf(Testing my_strncpy...\n); char dest2[10]; char src2[] HelloWorld; my_strncpy(dest2, src2, 5); dest2[5] \0; // 手動添加結(jié)束符因為 src2 長度 5 assert(strcmp(dest2, Hello) 0); char dest3[10] XXXXXX; my_strncpy(dest3, AB, 5); // dest3 現(xiàn)在應該是: 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] 的位置 // 期望結(jié)果: 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 必須考慮的邊界與異常情況通過測試我們需要特別關(guān)注以下幾類情況它們往往是Bug的藏身之處空指針NULL標準庫函數(shù)在接收空指針時行為是“未定義的”通常導致程序崩潰。我們的模擬實現(xiàn)可以選擇加入防御性檢查如返回0或NULL但要知道這偏離了標準行為。在面試或嚴格模擬時通常不考慮空指針因為調(diào)用者有責任確保參數(shù)有效。空字符串“”這是一個有效的字符串只包含一個\0。我們的函數(shù)必須能正確處理它例如strlen(“”)應返回0strstr(haystack, “”)應返回haystack。零長度操作strncpy(dest, src, 0)、memcpy(dest, src, 0)等。這些操作不應該修改任何內(nèi)存我們的實現(xiàn)需要正確處理例如直接返回dest。重疊內(nèi)存這是memcpy和memmove的關(guān)鍵區(qū)別也是strcpy在自復制時可能遇到的問題。我們的memmove實現(xiàn)必須正確處理。目標緩沖區(qū)大小這是所有“不安全”函數(shù)strcpy,strcat,sprintf等的根源問題。在模擬實現(xiàn)中我們遵循原樣但在實際項目中必須使用帶長度限制的版本strncpy、strncat、snprintf或更安全的替代品并仔細計算緩沖區(qū)大小。字符符號性在strcmp系列函數(shù)中比較時必須將char轉(zhuǎn)換為unsigned char以確保比較結(jié)果與機器符號表示無關(guān)。查找函數(shù)的返回值strchr查找\0應返回指向結(jié)尾的指針strstr查找空子串應返回原串指針。這些邊緣情況容易被忽略。10. 從模擬實現(xiàn)到工程實踐經(jīng)驗、教訓與安全編碼走完這一遍模擬實現(xiàn)我們收獲的遠不止幾行代碼。更重要的是我們洞悉了這些基礎工具的內(nèi)部邏輯、潛在陷阱和設計哲學。下面是我在實際項目中總結(jié)出的幾點核心經(jīng)驗1. 理解“未定義行為”的代價標準庫函數(shù)在很多邊界條件下如空指針、緩沖區(qū)溢出的行為是“未定義的”。這意味著編譯器可以生成任何代碼程序可能崩潰、產(chǎn)生錯誤結(jié)果、或者看似正常地運行直到某個關(guān)鍵時刻出錯。我們的模擬練習讓我們親身體驗了這些邊界從而在以后編碼時會對這些地方產(chǎn)生本能的警惕。例如在調(diào)用strcpy前你腦子里會立刻響起警報“dest的空間夠嗎”2. 優(yōu)先使用“n”版本函數(shù)但務必理解其語義strncpy、strncat、snprintf是你的朋友但它們是“帶刺的朋友”。你必須清楚strncpy不會自動添加\0可能產(chǎn)生非終止字符串。strncat和snprintf會保證添加\0只要目標空間大小參數(shù)size 0。永遠記得strncpy的n是“最大復制字符數(shù)”而strncat和snprintf的n或size是“目標緩沖區(qū)總大小”?；煜鼈儠е聻碾y。一個安全的strncpy使用模式幾乎總是成對出現(xiàn)char buf[64]; strncpy(buf, src, sizeof(buf) - 1); buf[sizeof(buf) - 1] \0; // 手動確保終止3. 考慮使用更現(xiàn)代的替代方案如果你的項目環(huán)境允許可以考慮以下更安全的方案strlcpy/strlcat來自BSD語義清晰參數(shù)是目標緩沖區(qū)總大小總是保證\0結(jié)尾返回源長度但非C標準。C11 Annex K Bounds-checking interfaces如strcpy_s,strcat_s。它們有更嚴格的運行時檢查但普及度不高且使用稍顯繁瑣。使用高級語言或庫在C中優(yōu)先使用std::string。在C中可以依賴一些經(jīng)過嚴格測試的第三方安全字符串庫。4. 內(nèi)存重疊是隱形的殺手除非你百分之百確定兩塊內(nèi)存不重疊否則對于內(nèi)存復制操作無條件使用memmove。memcpy的速度優(yōu)勢在當今編譯器優(yōu)化面前已不明顯而memmove帶來的安全性提升是實實在在的。這個習慣能幫你避免許多難以調(diào)試的詭異Bug。5. 手動實現(xiàn)是理解的終極檢驗當你對某個庫函數(shù)的行為有疑惑或者面試中被問到其實現(xiàn)時沒有比在腦子里或紙上模擬一遍其運行過程更好的方法了。這個過程強迫你考慮每一個字節(jié)、每一個指針的變化。例如你能清晰地說出while (*d *s);這個循環(huán)的結(jié)束條件嗎它為什么能正確復制\0最后記住C語言字符串的核心是“以\0結(jié)尾的字符數(shù)組”。這個簡單的約定帶來了巨大的靈活性和同樣巨大的責任。我們的模擬實現(xiàn)之旅本質(zhì)上是一次對這份責任的深度體驗。把這些函數(shù)的內(nèi)部邏輯刻在腦子里你就能在紛繁復雜的代碼中對字符串操作保持一份清醒和掌控力。 C語言字符串函數(shù)模擬實現(xiàn)：從strcpy到memmove的底層原理與安全實踐
1. 項目緣起為什么我們要親手“造輪子”剛學C語言那會兒我總覺得strcpy、strcat這些函數(shù)用起來理所當然不就是庫函數(shù)嘛調(diào)用一下就行了。直到后來自己寫項目遇到了緩沖區(qū)溢出導致程序崩潰或者處理特殊字符時結(jié)果總是不對才回過頭來琢磨這些黑盒子里面到底發(fā)生了什么它們有沒有什么我沒注意到的“坑”從那時起我就養(yǎng)成了一個習慣對于核心的、常用的庫函數(shù)一定要自己動手模擬實現(xiàn)一遍。這絕不是浪費時間而是一種“知其然更知其所以然”的深度修煉。今天我們就來徹底拆解C語言中最常用的幾個字符串處理函數(shù)。我們的目標不是簡單地復述手冊而是像設計者一樣思考從零開始用最純粹的C語言一步步構(gòu)建出它們的“平替”版本。你會看到一個看似簡單的strlen在追求極致效率時可以有多種寫法一個常用的strcpy如果不注意邊界檢查可能就是安全漏洞的溫床。通過這個過程你不僅能牢牢掌握這些函數(shù)的內(nèi)部機理更能深刻理解指針操作、內(nèi)存管理和編碼安全的精髓這對于你未來無論是做嵌入式開發(fā)、系統(tǒng)編程還是應對各種筆試面試都將是極為扎實的功底。2. 模擬實現(xiàn)前的核心思想與約束在動手寫代碼之前我們必須先統(tǒng)一思想明確游戲規(guī)則。模擬實現(xiàn)不是天馬行空的創(chuàng)造而是在給定約束下的精確還原。2.1 函數(shù)原型與行為的一致性這是最高原則。我們模擬的函數(shù)其名稱、參數(shù)類型、返回類型以及最重要的——外部行為必須與標準庫函數(shù)完全一致。這意味著參數(shù)不變標準庫的strcpy聲明是char *strcpy(char *dest, const char *src);我們的模擬函數(shù)也必須是這個簽名。返回值一致標準庫的strcpy返回目標字符串的起始地址即dest我們的實現(xiàn)也必須返回dest。這個返回值常被用于鏈式調(diào)用比如strcat(strcpy(dest, src1), src2)。副作用相同函數(shù)對內(nèi)存的修改、對輸入?yún)?shù)的依賴關(guān)系必須一致。例如strcpy會修改dest指向的內(nèi)存并且依賴于src指向的以\0結(jié)尾的字符串。2.2 關(guān)于“安全性”的邊界討論這是一個關(guān)鍵且容易引起困惑的點。C標準庫中原始的字符串函數(shù)如strcpy,strcat本身不檢查目標緩沖區(qū)的大小這是它們被認為“不安全”的根源。它們的設計哲學是“程序員負責一切”追求極致的速度和簡潔。注意在我們的模擬實現(xiàn)中我們首先嚴格遵循原始函數(shù)的不安全行為進行實現(xiàn)。這是為了理解其最本質(zhì)的工作原理。之后我們會在分析章節(jié)專門探討如何在此基礎上增加安全檢查演進出strncpy、strlcpy非標準但流行等安全版本。請務必分清“模擬原始行為”和“編寫安全代碼”是兩個階段的任務。2.3 我們的“武器庫”允許使用的底層操作既然要模擬我們就不能直接調(diào)用其他的字符串庫函數(shù)否則就成了套娃。我們被允許使用的“原子操作”非常有限指針的算術(shù)運算與解引用這是核心中的核心。*p,*(p1),p等?；举x值與比較,,!,,等。循環(huán)與條件判斷while,for,if。內(nèi)存訪問通過指針讀寫內(nèi)存。我們的所有實現(xiàn)都將建立在這些基礎操作之上。好了思想準備就緒讓我們開始第一個也是最基礎的一個函數(shù)。3. 求字符串長度strlen 的多種實現(xiàn)與效率權(quán)衡strlen的功能是計算一個以空字符\0結(jié)尾的字符串的長度不包括\0本身。聽起來很簡單但實現(xiàn)方式卻能體現(xiàn)出不同的編程思維和優(yōu)化技巧。3.1 最直觀的版本計數(shù)器法這是初學者最容易想到的方法。用一個臨時指針遍歷字符串同時用一個整型變量count來記錄步數(shù)。// 版本1計數(shù)器法 size_t my_strlen_counter(const char *str) { size_t count 0; // 用于計數(shù)的變量 if (str NULL) { // 良好的習慣檢查輸入指針是否有效 return 0; // 處理空指針實際標準庫行為未定義這里我們做防御性處理 } while (*str ! \0) { // 遍歷直到遇到字符串結(jié)束符 count; str; } return count; }實現(xiàn)解析count初始為0。while循環(huán)檢查當前str指向的字符是否為\0如果不是count加1指針str向后移動一個字符指向下一個字符。循環(huán)結(jié)束時count的值就是字符串的長度。這個版本邏輯清晰易于理解但每次循環(huán)要執(zhí)行兩次加法count和str和一次比較。3.2 更C語言風格的版本指針差值法C語言中指針減指針可以得到它們之間相差的元素個數(shù)。我們可以利用這一點省去單獨的計數(shù)器。// 版本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); // 結(jié)束位置減去起始位置即為長度 }實現(xiàn)解析在開始遍歷前用start指針記錄字符串的起始地址。然后讓str指針一路走到\0的位置。最后str - start得到的就是從頭到尾走過的字符數(shù)也就是字符串長度。這個方法比計數(shù)器法更“地道”它直接利用了指針運算的特性通常效率也略高一點。3.3 追求極致的版本無分支優(yōu)化與字長讀取在一些高性能庫如Glibc的實現(xiàn)中strlen會采用更復雜、更極致的優(yōu)化。其核心思想是對齊內(nèi)存訪問現(xiàn)代CPU對對齊的內(nèi)存訪問如4字節(jié)或8字節(jié)對齊速度更快。實現(xiàn)會先處理開頭幾個不對齊的字節(jié)直到指針指向一個對齊的地址。按機器字長Word讀取一次不是讀取一個字符1字節(jié)而是讀取一個機器字比如4或8字節(jié)。這相當于同時檢查多個字符是否為\0。位運算技巧快速檢測0字節(jié)在一個字比如0x44332201中快速判斷是否有任何一個字節(jié)為0x00。這通常通過神奇的位運算公式實現(xiàn)例如((x - 0x01010101) ~x 0x80808080)對于32位系統(tǒng)。無分支循環(huán)減少或消除循環(huán)內(nèi)的條件判斷利用位運算結(jié)果來定位\0。這種實現(xiàn)非常復雜涉及大量底層知識其目的是為了在處理長字符串時獲得數(shù)倍甚至數(shù)十倍的性能提升。對于我們理解基本原理而言前兩種實現(xiàn)已經(jīng)足夠。但你需要知道一個簡單的strlen在工業(yè)級代碼中可能藏著如此深的優(yōu)化心思。4. 字符串復制strcpy 與 strncpy 的陷阱與實現(xiàn)復制函數(shù)是字符串操作中最常用也最容易出問題的地方。4.1 標準 strcpy 的模擬實現(xiàn)char *strcpy(char *dest, const char *src);將src指向的字符串包括結(jié)尾的\0復制到dest指向的內(nèi)存空間。// 模擬實現(xiàn)標準 strcpy char *my_strcpy(char *dest, const char *src) { // 參數(shù)檢查標準庫不檢查但好的模擬實現(xiàn)可以加入 // assert(dest ! NULL src ! NULL); char *ret dest; // 保存目標字符串起始地址用于返回 while ((*dest *src) ! \0) { // 循環(huán)體為空所有操作都在條件判斷中完成 } return ret; }實現(xiàn)解析這行while ((*dest *src) ! \0)是C語言中一個經(jīng)典且緊湊的寫法。它的執(zhí)行順序是將src指向的字符賦值給dest指向的位置*dest *src。判斷這個被賦值的字符是否等于\0。無論是否等于\0dest和src指針都自增1指向下一個位置。如果步驟2中判斷字符不是\0則繼續(xù)循環(huán)如果是\0則循環(huán)結(jié)束并且\0也已經(jīng)被復制過去了。這個實現(xiàn)完美復刻了標準庫的行為它假設dest指向的內(nèi)存空間足夠大能容納src的所有字符包括\0。如果dest空間不足就會發(fā)生緩沖區(qū)溢出Buffer Overflow覆蓋后面的內(nèi)存數(shù)據(jù)導致程序崩潰或產(chǎn)生安全漏洞。這是原始strcpy最大的“罪”。4.2 有限長度的復制strncpy 的模擬與誤區(qū)為了緩解溢出問題C庫提供了char *strncpy(char *dest, const char *src, size_t n);。它的邏輯是最多復制n個字符從src到dest。// 模擬實現(xiàn)標準 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]; } // 關(guān)鍵且反直覺的部分如果 i n說明 src 提前結(jié)束了需要用 \0 填充剩余空間 for ( ; i n; i) { dest[i] \0; } return ret; }實現(xiàn)解析與重大陷阱復制階段for循環(huán)在兩種情況下停止復制夠了n個字符或者遇到了src的結(jié)束符\0。填充階段這是strncpy最特殊也最容易被誤用的一點如果src的長度小于nstrncpy會用\0填充dest中剩余的所有字節(jié)直到寫滿n個字符。結(jié)尾符不確定性strncpy不保證目標字符串以\0結(jié)尾只有在兩種情況下dest會以\0結(jié)尾src的長度包括\0小于n此時dest的最后一個有效字符是填充的\0。src的長度大于等于n此時dest恰好被src的前n個字符填滿最后一個字符不是\0。踩坑實錄很多人以為strncpy是安全的strcpy直接strncpy(dest, src, sizeof(dest))。這錯了如果src很長dest會被填滿且沒有\(zhòng)0結(jié)尾。后續(xù)使用dest作為字符串的函數(shù)如printf(“%s”, dest)會一直讀取內(nèi)存直到遇到一個隨機的\0導致溢出或亂碼。正確的做法是手動確保結(jié)尾strncpy(dest, src, sizeof(dest)-1); dest[sizeof(dest)-1] \0;。4.3 更優(yōu)的選擇模擬 strlcpy 的思路正因為strncpy的怪異行為很多系統(tǒng)如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直接返回源串長度需要復制的長度 } // 計算實際能復制的字符數(shù)留一個位置給 \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 結(jié)尾 return src_len; // 返回源串長度方便調(diào)用者判斷是否被截斷 }實現(xiàn)解析strlcpy的理念是“安全第一結(jié)果可預測”。它總是保證dest以\0結(jié)尾只要size 0。它的第三個參數(shù)size指的是dest緩沖區(qū)的總大小包括\0的位置而不是最大復制字符數(shù)。這更符合直覺。返回值是src的長度。這樣調(diào)用者可以輕松判斷復制是否被截斷if (retval size) { /* 發(fā)生了截斷 */ }。雖然strlcpy不是C標準庫函數(shù)但其清晰的安全語義使得它在很多項目中成為首選。自己實現(xiàn)一個類似邏輯的函數(shù)是工程中的常見做法。5. 字符串連接strcat 與 strncat 的細節(jié)連接函數(shù)用于將一個字符串追加到另一個字符串的末尾。5.1 標準 strcat 的模擬實現(xiàn)char *strcat(char *dest, const char *src);將src字符串追加到dest字符串的末尾覆蓋dest原有的結(jié)束符\0并在連接后的新字符串末尾添加\0。// 模擬實現(xiàn)標準 strcat char *my_strcat(char *dest, const char *src) { char *ret dest; // 第一步找到 dest 字符串的結(jié)尾即 \0 的位置 while (*dest ! \0) { dest; } // 第二步從 dest 的結(jié)尾開始執(zhí)行 strcpy 操作 while ((*dest *src) ! \0) { ; } return ret; }實現(xiàn)解析這個實現(xiàn)可以看作strlen(dest)strcpy(dest_end, src)兩個操作的組合。第一個while循環(huán)定位到dest字符串的末尾\0處。第二個while循環(huán)就是我們的my_strcpy邏輯從dest的末尾開始復制src。同樣它不檢查dest剩余空間是否足夠存在緩沖區(qū)溢出風險。5.2 有限長度的連接strncat 的模擬實現(xiàn)char *strncat(char *dest, const char *src, size_t n);從src追加最多n個字符到dest末尾并總是添加一個終止空字符\0。// 模擬實現(xiàn)標準 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]; } // 關(guān)鍵無論復制了多少個字符總是在末尾添加 \0 dest[i] \0; return ret; }實現(xiàn)解析strncat比strncpy的行為要友好得多也安全得多。它先找到dest的末尾。然后從src復制最多n個非\0字符過去。最重要的一點復制完成后它總是在目標字符串的末尾添加一個\0。這意味著dest永遠是一個有效的C字符串。它不會像strncpy那樣用\0填充剩余空間。因此strncat是相對更安全的連接函數(shù)。但調(diào)用者仍需確保dest有足夠的空間容納dest原有的字符 min(n, strlen(src))個新字符 1個\0。6. 字符串比較strcmp 與 strncmp 的逐字節(jié)邏輯比較函數(shù)用于按字典序ASCII碼順序比較兩個字符串。6.1 標準 strcmp 的模擬實現(xiàn)int strcmp(const char *str1, const char *str2);比較兩個字符串。返回值為 0str1小于str2第一個不匹配字符的ASCII值在str1中小于在str2中或str1是str2的前綴。 0str1等于str2。 0str1大于str2。// 模擬實現(xiàn)標準 strcmp int my_strcmp(const char *str1, const char *str2) { // 循環(huán)比較直到遇到不相等的字符或遇到 \0 while (*str1 ! \0 *str1 *str2) { str1; str2; } // 返回兩個當前字符的ASCII差值 return *(unsigned char *)str1 - *(unsigned char *)str2; }實現(xiàn)解析while循環(huán)的條件是兩個指針都沒走到結(jié)尾*str1 ! ‘\0’并且當前字符相等*str1 *str2。只要條件滿足就繼續(xù)比較下一個字符。循環(huán)退出時有兩種可能遇到了不相等的字符。str1走到了結(jié)尾此時*str2可能是\0也可能不是。返回值計算將兩個當前字符**轉(zhuǎn)換為unsigned char**后相減。這是為了正確處理負值的char在一些系統(tǒng)上char默認為signed。例如比較”\xFF”和”\x00”如果按signed char解釋-1 - 0 -1如果按unsigned char解釋255 - 0 255。標準要求按unsigned char比較以確保結(jié)果一致。如果str1先結(jié)束且str2在相同位置也是\0則循環(huán)因*str1 ‘\0’而*str1 *str2不成立因為\0 \0為真但*str1 ! ‘\0’為假退出循環(huán)。此時*str1和*str2都是\0相減結(jié)果為0表示字符串相等。6.2 有限長度的比較strncmp 的模擬實現(xiàn)int strncmp(const char *str1, const char *str2, size_t n);比較兩個字符串的前n個字符。// 模擬實現(xià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; }實現(xiàn)解析邏輯與strcmp類似但增加了比較次數(shù)n的限制。如果n為0直接返回0相等。while循環(huán)條件--n 0確保最多比較n-1次因為先減減。同時也要滿足兩個字符串都沒結(jié)束且當前字符相等。循環(huán)退出條件可能是比較次數(shù)用盡n變?yōu)?、遇到不相等的字符、或某個字符串結(jié)束。返回值的計算方式與strcmp完全相同比較的是退出循環(huán)時的當前字符。strncmp常用于比較字符串的前綴或者當你知道只需要比較固定長度時它更安全因為它不會因為字符串缺少\0而一直讀取越界盡管標準字符串應該以\0結(jié)尾但破損的數(shù)據(jù)中可能沒有。7. 內(nèi)存操作函數(shù)的跨界模擬memcpy 與 memmove嚴格來說memcpy和memmove不是字符串函數(shù)它們處理的是內(nèi)存塊不關(guān)心\0但它們與字符串操作息息相關(guān)且實現(xiàn)思想非常經(jīng)典。7.1 內(nèi)存復制memcpy 的模擬實現(xiàn)與限制void *memcpy(void *dest, const void *src, size_t n);從src指向的位置開始復制n個字節(jié)到dest指向的位置。// 模擬實現(xiàn)標準 memcpy (基礎版本) void *my_memcpy(void *dest, const void *src, size_t n) { char *d (char *)dest; const char *s (const char *)src; // 通常的簡單實現(xiàn)按字節(jié)從前向后復制 for (size_t i 0; i n; i) { d[i] s[i]; } return dest; }實現(xiàn)解析與重大限制這個簡單的逐字節(jié)復制實現(xiàn)在大多數(shù)情況下工作良好。但是標準庫的memcpy有一個非常重要的限制它要求源內(nèi)存區(qū)域和目標內(nèi)存區(qū)域不能重疊。如果重疊其行為是未定義的Undefined Behavior。為什么考慮src和dest重疊的情況例如dest在src后面一點。當我們從前向后復制時src中尚未被復制的數(shù)據(jù)可能會先被dest覆蓋掉導致復制結(jié)果錯誤。例如想把”hello”從地址0復制到地址1期望得到”hhello”但從前向后復制會得到”hhhhh”。7.2 可處理重疊的內(nèi)存復制memmove 的模擬實現(xiàn)void *memmove(void *dest, const void *src, size_t n);功能與memcpy類似但允許源和目標內(nèi)存區(qū)域重疊。它是更安全的選擇。// 模擬實現(xiàn)標準 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直接返回 } // 判斷內(nèi)存區(qū)域是否重疊以及重疊的類型 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; }實現(xiàn)解析memmove的智慧在于復制方向的判斷。無重疊或目標在前如果dest的地址小于src的地址或者兩者不重疊從前向后復制是安全的。因為即使重疊dest在前面它覆蓋的是src已經(jīng)“用過”的舊數(shù)據(jù)區(qū)域不會影響后面待復制的數(shù)據(jù)。目標在后重疊如果dest的地址大于src的地址并且兩者重疊dest src n此時從前向后復制會破壞源數(shù)據(jù)。正確的做法是從后向前復制。從最后一個字節(jié)開始依次向前復制這樣源區(qū)域中尚未被讀取的數(shù)據(jù)就不會先被目標區(qū)域覆蓋。經(jīng)驗之談在實際編程中如果你不確定兩塊內(nèi)存是否重疊永遠優(yōu)先使用memmove。雖然它的名字暗示著“移動”但它完全能勝任memcpy的工作并且在重疊時行為是確定的?，F(xiàn)代編譯器的優(yōu)化非常智能在檢測到內(nèi)存不重疊時對memmove的調(diào)用很可能被優(yōu)化成與memcpy同樣高效的指令。用memmove代替memcpy是一個低成本的高安全習慣。8. 字符串查找strchr 與 strstr 的算法思路查找函數(shù)用于在字符串中定位字符或子串。8.1 查找字符strchr 的模擬實現(xiàn)char *strchr(const char *str, int c);在字符串str中查找第一次出現(xiàn)字符c轉(zhuǎn)換為char的位置并返回指向該位置的指針。如果未找到返回NULL。// 模擬實現(xiàn)標準 strchr char *my_strchr(const char *str, int c) { if (str NULL) { return NULL; } char ch (char)c; // 將 int 轉(zhuǎn)換為 char while (*str ! \0) { if (*str ch) { return (char *)str; // 找到返回指針。需要去除 const 限定 } str; } // 循環(huán)結(jié)束也沒找到檢查是否在找 \0 if (ch \0) { return (char *)str; // 標準規(guī)定查找 \0 應返回指向字符串結(jié)尾的指針 } return NULL; // 未找到 }實現(xiàn)解析邏輯很直接遍歷字符串逐個字符比較。有兩個細節(jié)需要注意參數(shù)c是int類型這是歷史原因為了兼容EOF通常是-1。在函數(shù)內(nèi)部需要將其轉(zhuǎn)換為char類型進行比較。查找空字符\0根據(jù)C標準strchr也可以用來查找字符串的結(jié)束符\0此時應返回指向\0的指針。我們的實現(xiàn)通過循環(huán)后的一個特殊判斷來處理這種情況。8.2 查找子串strstr 的樸素算法實現(xiàn)char *strstr(const char *haystack, const char *needle);在haystack干草堆字符串中查找第一次出現(xiàn)needle針子串的位置。// 模擬實現(xiàn)標準 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; // 內(nèi)層循環(huán)比較從 start 開始的子串是否與 needle 匹配 while (*h ! \0 *n ! \0 *h *n) { h; n; } // 判斷匹配是否成功 if (*n \0) { // needle 全部比較完畢說明找到了 return (char *)start; } if (*h \0) { // haystack 剩余部分長度已經(jīng)小于 needle不可能再找到 break; } // 本次匹配失敗start 向后移動一位繼續(xù)嘗試 start; } return NULL; // 未找到 }實現(xiàn)解析樸素算法外層循環(huán)指針start從haystack的第一個字符開始每次嘗試作為一個可能的匹配起點。內(nèi)層循環(huán)用指針h和n分別從當前的start和needle開頭開始逐個字符比較。匹配成功條件內(nèi)層循環(huán)一直進行到*n ‘\0’這意味著needle的所有字符都匹配上了函數(shù)返回當前的start指針。匹配失敗如果內(nèi)層循環(huán)因為*h ! *n而退出說明當前start位置不匹配。start向后移動一位繼續(xù)嘗試。提前終止優(yōu)化如果內(nèi)層循環(huán)因為*h ‘\0’而退出即haystack先到頭了而*n還不是\0說明剩下的haystack長度已經(jīng)比needle短不可能再匹配成功直接跳出外層循環(huán)返回NULL。這個算法被稱為“樸素匹配”或“暴力匹配”其時間復雜度在最壞情況下是O(m*n)其中m和n分別是兩個字符串的長度。對于短字符串這完全夠用。標準庫的實現(xiàn)如Glibc在檢測到needle較長時可能會使用更高效的算法如KMP算法或Boyer-Moore算法這些算法通過預處理needle可以在某些情況下達到O(mn)的線性時間復雜度。理解樸素算法是學習這些高級算法的基礎。9. 綜合測試與邊界條件思考紙上得來終覺淺絕知此事要躬行。寫完了所有模擬函數(shù)我們必須進行全面的測試尤其是各種邊界情況和異常輸入。9.1 構(gòu)建一個簡單的測試框架我們可以編寫一個簡單的main函數(shù)來測試我們的實現(xiàn)。為了嚴謹應該將我們的模擬函數(shù)與標準庫函數(shù)在相同輸入下的輸出進行對比。#include stdio.h #include string.h #include assert.h // 這里插入我們上面實現(xiàn)的所有 my_xxx 函數(shù)... 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); // 測試自我復制 (標準庫行為是未定義但我們實現(xiàn)可能工作) char self[] self; my_strcpy(self, self); // 需要我們的實現(xiàn)能處理這種情況指針相同 // 3. 測試 strncpy printf(Testing my_strncpy...\n); char dest2[10]; char src2[] HelloWorld; my_strncpy(dest2, src2, 5); dest2[5] \0; // 手動添加結(jié)束符因為 src2 長度 5 assert(strcmp(dest2, Hello) 0); char dest3[10] XXXXXX; my_strncpy(dest3, AB, 5); // dest3 現(xiàn)在應該是: 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] 的位置 // 期望結(jié)果: 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 必須考慮的邊界與異常情況通過測試我們需要特別關(guān)注以下幾類情況它們往往是Bug的藏身之處空指針NULL標準庫函數(shù)在接收空指針時行為是“未定義的”通常導致程序崩潰。我們的模擬實現(xiàn)可以選擇加入防御性檢查如返回0或NULL但要知道這偏離了標準行為。在面試或嚴格模擬時通常不考慮空指針因為調(diào)用者有責任確保參數(shù)有效。空字符串“”這是一個有效的字符串只包含一個\0。我們的函數(shù)必須能正確處理它例如strlen(“”)應返回0strstr(haystack, “”)應返回haystack。零長度操作strncpy(dest, src, 0)、memcpy(dest, src, 0)等。這些操作不應該修改任何內(nèi)存我們的實現(xiàn)需要正確處理例如直接返回dest。重疊內(nèi)存這是memcpy和memmove的關(guān)鍵區(qū)別也是strcpy在自復制時可能遇到的問題。我們的memmove實現(xiàn)必須正確處理。目標緩沖區(qū)大小這是所有“不安全”函數(shù)strcpy,strcat,sprintf等的根源問題。在模擬實現(xiàn)中我們遵循原樣但在實際項目中必須使用帶長度限制的版本strncpy、strncat、snprintf或更安全的替代品并仔細計算緩沖區(qū)大小。字符符號性在strcmp系列函數(shù)中比較時必須將char轉(zhuǎn)換為unsigned char以確保比較結(jié)果與機器符號表示無關(guān)。查找函數(shù)的返回值strchr查找\0應返回指向結(jié)尾的指針strstr查找空子串應返回原串指針。這些邊緣情況容易被忽略。10. 從模擬實現(xiàn)到工程實踐經(jīng)驗、教訓與安全編碼走完這一遍模擬實現(xiàn)我們收獲的遠不止幾行代碼。更重要的是我們洞悉了這些基礎工具的內(nèi)部邏輯、潛在陷阱和設計哲學。下面是我在實際項目中總結(jié)出的幾點核心經(jīng)驗1. 理解“未定義行為”的代價標準庫函數(shù)在很多邊界條件下如空指針、緩沖區(qū)溢出的行為是“未定義的”。這意味著編譯器可以生成任何代碼程序可能崩潰、產(chǎn)生錯誤結(jié)果、或者看似正常地運行直到某個關(guān)鍵時刻出錯。我們的模擬練習讓我們親身體驗了這些邊界從而在以后編碼時會對這些地方產(chǎn)生本能的警惕。例如在調(diào)用strcpy前你腦子里會立刻響起警報“dest的空間夠嗎”2. 優(yōu)先使用“n”版本函數(shù)但務必理解其語義strncpy、strncat、snprintf是你的朋友但它們是“帶刺的朋友”。你必須清楚strncpy不會自動添加\0可能產(chǎn)生非終止字符串。strncat和snprintf會保證添加\0只要目標空間大小參數(shù)size 0。永遠記得strncpy的n是“最大復制字符數(shù)”而strncat和snprintf的n或size是“目標緩沖區(qū)總大小”?；煜鼈儠е聻碾y。一個安全的strncpy使用模式幾乎總是成對出現(xiàn)char buf[64]; strncpy(buf, src, sizeof(buf) - 1); buf[sizeof(buf) - 1] \0; // 手動確保終止3. 考慮使用更現(xiàn)代的替代方案如果你的項目環(huán)境允許可以考慮以下更安全的方案strlcpy/strlcat來自BSD語義清晰參數(shù)是目標緩沖區(qū)總大小總是保證\0結(jié)尾返回源長度但非C標準。C11 Annex K Bounds-checking interfaces如strcpy_s,strcat_s。它們有更嚴格的運行時檢查但普及度不高且使用稍顯繁瑣。使用高級語言或庫在C中優(yōu)先使用std::string。在C中可以依賴一些經(jīng)過嚴格測試的第三方安全字符串庫。4. 內(nèi)存重疊是隱形的殺手除非你百分之百確定兩塊內(nèi)存不重疊否則對于內(nèi)存復制操作無條件使用memmove。memcpy的速度優(yōu)勢在當今編譯器優(yōu)化面前已不明顯而memmove帶來的安全性提升是實實在在的。這個習慣能幫你避免許多難以調(diào)試的詭異Bug。5. 手動實現(xiàn)是理解的終極檢驗當你對某個庫函數(shù)的行為有疑惑或者面試中被問到其實現(xiàn)時沒有比在腦子里或紙上模擬一遍其運行過程更好的方法了。這個過程強迫你考慮每一個字節(jié)、每一個指針的變化。例如你能清晰地說出while (*d *s);這個循環(huán)的結(jié)束條件嗎它為什么能正確復制\0最后記住C語言字符串的核心是“以\0結(jié)尾的字符數(shù)組”。這個簡單的約定帶來了巨大的靈活性和同樣巨大的責任。我們的模擬實現(xiàn)之旅本質(zhì)上是一次對這份責任的深度體驗。把這些函數(shù)的內(nèi)部邏輯刻在腦子里你就能在紛繁復雜的代碼中對字符串操作保持一份清醒和掌控力。