C语言 -- string.h中函数功能详解与手动实现 - 02（常用函数memcpy、memmove、strcpy、strdup、strcat、strtok...）

蔚落 2023-01-04 14:32 167阅读 0赞

### 内容预览 ###

*   *  3.5、搬迁类型 --- 函数功能详细说明 ：将内存空间中内容移动、复制到另一内存空间
     *  3.6、搬迁类型 --- 函数功能测试与手动实现
     *   *  3.6.1、memcpy、memccpy
         *  3.6.2、memmove
         *  3.6.3、strcpy、strncpy、stpcpy
         *  3.6.4、strdup、strndup
     *  3.7、组合/分解类型 --- 函数功能详细说明 ：将内存空间/字符串进行拼接/追加
     *  3.8、组合/分解类型 --- 函数功能测试与手动实现
     *   *  3.8.1、strcat、strncat
         *  3.8.2、strtok

*  本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。
 *  如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。
 *  由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。

摘要

一般系统中提供一个标准的C库 **string.h** ，用于操作各种操作字符串（ strxxx ）、内存（ memxxx ）的库函数。作为 **C标准库** 的一部分，它们被强制要求可以在任何支持 **C语言** 的平台上运行。 不管是在面试中还是平时的工作中，对 **string.h** 文件中的大部分的函数的都有涉及，并且会经常遇到手撕某个或者某几个库函数的题目，其重要程度可想而知。

**续接上文：**

[C语言 – string.h中函数功能详解与手动实现 - 01（常用函数memset、memcmp、strcmp、strncmp …）][C_ _ string.h_ - 01_memset_memcmp_strcmp_strncmp]

## 3.5、搬迁类型 — 函数功能详细说明 ：将内存空间中内容移动、复制到另一内存空间 ##

void *memcpy(void *dest, const void *src, size_t n);
        功能：由 src 所指内存区域复制 count 个字节到 dest 所指内存区域。
        返回：函数返回指向 dest 的指针。
        说明：1、src 和 dest 所指内存区域不能重叠，如果内存空间重叠哈偶原则上不作规定，由编译器决定
                在本测试环境中，均能够得到正确的结果
             2、需要保证参数的正确性与准确性，内存空间越界同样无定义
             3、如果复制的字符串，如果 n 大于字符串的长度，那么'\0'也会被复制
    void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count);
        功能：由 src 所指内存区域复制不多于 count 个字节到 dest 所指内存区域，如果遇到字符 ch 
        		则停止复制(ch被复制)。
        返回：返回指向字符 ch 后的第一个字符的指针，如果 src 前 n 个字节中不存在 ch 则返回 NULL。
        说明：1、src 和 dest 指向的内存空间不能重叠，如果重叠，结果未定义
             2、需要保证参数的正确性与准确性，内存空间越界同样无定义
             3、在复制过程中，ch 会被复制到 dest 中 
    void *memmove(void *dest, const void *src, size_t n);
        功能：由 src 所指内存区域复制 n 个字节到 dest 所指内存区域。
        返回：指向 dest 的指针
        说明：1、src 和 dest 所指内存区域可以重叠，但复制后 src 内容会被更改。 
             2、如果重叠，复制的过程就像是先将 src 中的字节复制到不与 src 或 dest 重叠的临时数组中一样，
                然后将字节从临时数组复制到dest。
             3、如果没有重叠，则与 memcpy 一致。
             4、需要保证参数的正确性
    char *strcpy(char *dest, const char *src);
        功能：把 src 所指由 '\0' 结束的字符串复制到 dest 所指的缓冲区中。
        返回：指向dest的指针。
        说明：1、src 和 dest 所指内存区域不可以重叠，如果重叠，行为未定义
                在本测试环境中，dst 均可以得到正确的结果，但是是src的内容被改变
             2、dest 必须有足够的空间来容纳 src 的字符串
                如果超过 dest 所指空间，经测试在本文所在的测试环境下，有两种情况：
                1）空间是 malloc 的，那么均可以得出正确的结果（这将会产生严重的系统漏洞）
                2）如果为数组，则会产生 core dumped 而崩溃
             3、复制的内容包括 '\0'，也就是 dest 的空间至少需要src字符串长度 + 1 
    char *strncpy(char *dest, const char *src, size_t n);
        功能：复制 src 指向的字符串 的最多 n 个字节到 dest 指向的缓冲区中 
        返回：指向dest的指针
        说明：1、如果 src 的字符串的长度大于 n（ src 的前 n 个字节不含字符'\0'），则
                dest 指向的字符串不会以 '\0' 结束，并且 dest 中不包含 src 后面的信息
             2、如果 src 的字符串的长度小于或者等于 n，则以 '\0' 填充 dest 直到复制完 n 个字节 
             3、src 和 dest 所指内存区域不可以重叠
             4、dest 必须有足够的空间来容纳 src 的字符串
             5、相比较 stcpy，strncpy 效率低下并且容易出错。如果明确 dest 的大小大于 src 的长度，
             	则可以使用strcpy
             6、将C字符串复制到固定长度的缓冲区，同时确保缓冲区不溢出，并且目标缓冲区中未使用的字节被清零 
    char *stpcpy(char *dest, const char *src);
        功能：把 src 所指由 '\0' 结束的字符串复制到 dest 所指的数组中（包括\0）。
    	返回：指向 dest 结尾处字符 NULL 的指针
        说明：1、src 和 dest 所指内存区域不可以重叠
        	 2、dest 所指的不能是字符串常量
    	     3、dest 必须有足够的空间来容纳src的字符串
    			如果空间溢出，在stpcpy操作期间无异常（见识产生严重错误）
    		 4、在 POSIX.1-2008 以后才成为C标准和gnu标准
    			本次测试环境中 windows 不支持
    char *stpncpy(char *dest, const char *src, size_t n);
    	功能：把 src 所指的字符串最多前 n 个复制到 dest 所指的数组中（包括\0）。
    	返回：指向 dest 结尾处字符 NULL 的指针
        说明：与stpcpy 一致，可以参考 strcpy 和 strncpy 的形式
    char *strdup(const char *s);
    	功能：复制字符串 s
        返回：1、如果成功，则返回指向一个新的被复制的字符串的指针
             2、如果失败（可用内存不足），则返回NULL，并设置 errno
    	说明：1、所需空间由 malloc()分配，且可以由free()释放 
             2、复制内容包含字符串结束符'\0'
             3、返回的指针指向的的空间大小为 s 字符串的长度 + 1（包含'\0'的位置）--> malloc(strlen(s) + 1)
             4、使用完成后，必须要手动free，不然会内容泄露
    char *strndup(const char *s, size_t n);
        功能：复制字符串 s，但是最多复制 n 个
        返回：1、如果成功，则返回指向一个新的被复制的字符串的指针
             2、如果失败（可用内存不足），则返回NULL，并设置errno
    	说明：1、所需空间由 malloc()分配，且可以由free()释放
             2、如果 s 长度大于 n，则只复制 n 个字节，并添加一个终止的空字节（'\0'）
             3、如果 s 长度小于 n，则复制 strlen(s)+1 个字节（包含'\0'），且返回的指针指向的内存空间为 strlen(s)+1 
             3、malloc的开辟的空间大小为 s 字符串的长度 + 1（包含'\0'的位置）
             3、使用完成后，必须要手动free，不然会内容泄露
    char *strdupa(const char *s);
    char *strndupa(const char *s, size_t n);
        功能：复制字符串 s（最多 n 个），功能同 strdup，strndup
        返回：1、如果成功，则返回指向一个新的被复制的字符串的指针
             2、如果失败（可用内存不足），则返回NULL，并设置errno
    	说明：1、使用 alloca 来分配（栈）缓冲区，所有使用受 alloca 的限制
    		 2、不需要手动 free
    		 3、仅在使用GNU GCC套件时可用，是 GNU 的扩展，本次测试环境未支持

## 3.6、搬迁类型 — 函数功能测试与手动实现 ##

### 3.6.1、memcpy、memccpy ###

#include <stdio.h> // for printf
    #include <stdlib.h> // for malloc calloc
    #include <string.h> // for memxxcpy
    
    /*** * memmove 和 memcpy 的区别 * * 1、工作结果： * 如果dest和src没有重叠，那么结果没有区别 * 如果dest和sec的区域重叠，那么memmove保证复制后dest的内容正确，同时src会被修改，但是memcpy没有定义 * 2、效率方便 * 整体来说，memcpy效率偏高。 ***/
    
    void debugMsg_Int(char *msg, void *src, size_t len)
    { 
        int i;
        if (msg == NULL || src == NULL || len < 1)
            return;
        printf("%s", msg);
    
        unsigned int *tmp = (unsigned int *)src;
        for (i = 0; i < len; i++)
            printf("%08X ", tmp[i]);
        putchar(10);
    }
    
    void debugMsg_Byte(char *msg, void *src, size_t len)
    { 
        int i;
        if (msg == NULL || src == NULL || len < 1)
            return;
        printf("%s", msg);
        unsigned char *tmp = (unsigned char *)src;
        for (i = 0; i < len; i++)
            printf("%02X ", tmp[i]);
        putchar(10);
    }
    
    void *my_memcpy(void *dest, void *src, size_t n)
    { 
        char *tmpDest = (char *)dest, *tmpSrc = (char *)src;
    #if __NOOVERLAP
        while (n)
        { 
            *tmpDest++ = *tmpSrc++;
            n--;
        }
    #else
        if (tmpDest > tmpSrc && tmpSrc + n > tmpDest)
        { 
            while (n)
            { 
                n--;
                *(tmpDest + n) = *(tmpSrc + n);
            }
        }
        else
        { 
            while (n)
            { 
                *tmpDest++ = *tmpSrc++;
                n--;
            }
        }
    #endif
        return dest;
    }
    
    void *my_memccpy(void *dest, const void *src, int c, size_t n)
    { 
        // assert(dest != NULL && src != NULL && c >= 0);
        char *tmpdest = (char *)dest;
        char *tmpsrc = (char *)src;
    
        while (*tmpsrc != c && (n--))
        { 
            *tmpdest++ = *tmpsrc++;
        }
        if (n == -1) // 说明应该没有找到字符 c 在 src 中
        { 
            return NULL;
        }
        else
        { 
            *tmpdest++ = *tmpsrc++;
            return tmpdest;
        }
    }
    
    int main(int argc, const char **argv)
    { 
        int *mem1 = (int *)malloc(sizeof(int) * 10);
        memset(mem1, 0, sizeof(int) * 10);
    
        char str[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
                      0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
                      0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
                      0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28};
        // 将str中的数据复制到内存空间mem1中
        char *ret = (char *)memcpy(mem1, str, sizeof(str) / sizeof(char));
    
        printf("In the initial state:\n");
        debugMsg_Int("mem1 Int of 10:\n", mem1, 10);
        debugMsg_Byte("mem1 Char of 40:\n", mem1, sizeof(int) * 10); // 输出mem1中的字节
        debugMsg_Byte("ret Char of 40:\n", ret, sizeof(int) * 10);   // 输出ret中的字节
    
        int *mem2 = mem1 + 5; // 如果要操作大于20个字节(一个int占4个字节)的数据，则mem2 和 mem1 有重叠的部分
        printf("\nThe state before the 'memcpy' operation:\n");
        debugMsg_Byte("mem1 Char of 20 : ", mem1, 20); // 输出mem1中前20个字节，
        debugMsg_Byte("mem2 Char of 20 : ", mem2, 20); // 输出mem2中前20个字节
    
        memcpy(mem2, mem1, 20); // 将mem1中的前20个字节的数据拷贝到mem2内存中
        printf("\nAfter the 'memcpy(20)' operation:\n");
        debugMsg_Byte("mem1 Char of 20 : ", mem1, 20); // 输出mem1中前20个字节，
        debugMsg_Byte("mem2 Char of 20 : ", mem2, 20); // 输出mem2中前20个字节
    
        // 将mem1的内从还原成初始化的状态，方便进行下次测试分析
        memcpy(mem1, str, sizeof(str) / sizeof(char));
        // 将mem1中的前30个字节的数据拷贝到mem2内存中
        // 下面的操作包含两种特殊情况，
        // 1、内存空间重叠的情况
        // 2、内存存在越界的情况
        memcpy(mem2, mem1, 30);
        printf("\nAfter the 'memcpy(30)' operation:\n");
        debugMsg_Byte("mem1 Char of 30 : ", mem1, 30); // 输出mem1中前30个字节，
        debugMsg_Byte("mem2 Char of 30 : ", mem2, 30); // 输出mem2中前30个字节
    
        // 将mem1的内从还原成初始化的状态，方便进行下次测试分析
        memcpy(mem1, str, sizeof(str) / sizeof(char));
        // 将mem1中的前30个字节的数据拷贝到mem2内存中
        // 下面的操作包含两种特殊情况，
        // 1、内存空间重叠的情况
        // 2、内存存在越界的情况
        my_memcpy(mem2, mem1, 30);
        printf("\nAfter the 'memcpy(30)' operation:\n");
        debugMsg_Byte("mem1 Char of 30 : ", mem1, 30); // 输出mem1中前30个字节，
        debugMsg_Byte("mem2 Char of 30 : ", mem2, 30); // 输出mem2中前30个字节
    
        char *src = "TestString";
        char dest[20] = { 0};
        char *ret123 = NULL;
    
        printf("\nBefore memccpy dest = %s, src = %s, len = %ld\n", dest, src, strlen(src));
        ret123 = (char *)memccpy(dest, src, 'a', strlen(src));
        printf("After memccpy'a' dest = %s, src = %s, ret = %s\n", dest, src, ret123);
        printf("dest = %p\nsrc = %p\nret = %p\n", dest, src, ret123);
        printf("After memccpy'a' dest = %s, src = %s, ret = %s\n", dest, src, ret123 == NULL ? "NULL" : ret123 - strlen(dest));
    
        // 将目标内存清空
        memset(dest, 0, sizeof(dest));
        printf("\nBefore my_memccpy dest = %s, src = %s, len = %ld\n", dest, src, strlen(src));
        ret123 = (char *)my_memccpy(dest, src, 'k', strlen(src));
        printf("After my_memccpy'k' dest = %s, src = %s, ret = %s\n", dest, src, ret123);
        printf("dest = %p\nsrc = %p\nret = %p\n", dest, src, ret);
        printf("After my_memccpy'k' dest = %s, src = %s, ret = %s\n", dest, src, ret123 == NULL ? "NULL" : ret123 - strlen(dest));
    
        // 将目标内存清空
        memset(dest, 0, sizeof(dest));
        printf("\nBefore memccpy dest = %s, src = %s, len = %ld\n", dest, src, strlen(src));
        ret123 = (char *)memccpy(dest, src, 'i', strlen(src));
        printf("After memccpy'i' dest = %s, src = %s, ret = %s\n", dest, src, ret123);
        printf("dest = %p\nsrc = %p\nret = %p\n", dest, src, ret);
        printf("After memccpy'i' dest = %s, src = %s, ret = %s\n", dest, src, ret123 == NULL ? "NULL" : ret123 - strlen(dest));
    
        // 测试 memcpy 超过字符串长度的字符串复制功能
        char *test = (char *)malloc(sizeof(char) * 100);
        memcpy(test, src, strlen(src));
        memcpy(test + strlen(src) + 1, "ABCD", strlen("ABCD") + 1);
        debugMsg_Byte("\nAfter memcpy'ABCD' : ", test, strlen(src) + 1 + 5);
    
        // 初始化空间tset
        char *test1 = (char *)malloc(sizeof(char) * 100);
        memset(test1, 'A', 90);
        printf("\nBefore memccpy test1 = %s, test = %s\n", test1, test);
        memccpy(test1, test, '\0', strlen(src) + 1 + strlen("ABCD") + 1);
        printf("After memccpy test1 = %s, test = %s\n", test1, test);
    
        free(mem1);
        free(test);
        free(test1);
    	
    	printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return 0;
    }

测试效果如下图所示。

![2021012009361524.png][]

### 3.6.2、memmove ###

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void *my_memmove(void *dest, const void *src, size_t n)
    { 
        if (dest == NULL || src == NULL || n < 0)
            return NULL;
    
        char *tmpdest = dest;
        const char *tmpsrc = src;
    
        //判断出是覆盖的patten，所以从后往前覆盖
        if (tmpdest > tmpsrc && tmpsrc + n > tmpdest)
        { 
            while (n--)
                *(tmpdest + n) = *(tmpsrc + n);
        } 
        else // 不是覆盖的patten，则正常从前往后覆盖
        { 
            while (n--)
                *tmpdest++ = *tmpsrc++;
        }
    
        return dest;
    }
    
    int main(int argc, const char **argv)
    { 
        // 正常的memmove的使用
        char dest1[] = "dstString";
        const char *src1 = "srcString";
    
        printf("Before memmove dest = %s, src = %s, len = %ld\n", dest1, src1, strlen(src1));
        char *ret1 = (char *)memmove(dest1, src1, strlen(src1));
        printf("After memmove dest = %s\n\ src = %s\n\ ret = %s\n",
               dest1, src1, ret1);
        putchar(10);
    
        char dest2[] = "dstString";
        const char *src2 = "srcString";
        printf("Before my_memmove dest = %s, src = %s, len = %ld\n", dest1, src1, strlen(src1));
        char *ret2 = (char *)my_memmove(dest2, src2, strlen(src2));
        printf("After my_memmove dest = %s\n\ src = %s\n\ ret = %s\n",
               dest2, src2, ret2);
        putchar(10);
    
        // 现在弄一个空间区域重复的测试
        char *area = (char *)malloc(sizeof(char) * 20);
        if (area == NULL) return -1;
    
        // 将测试区域所有字节设置为 A
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0'; // 方便在printf的时候及时停止
        printf("area = %s, len = %ld\n", area, strlen(area));
        /* 第一种情况： area/src dest ├─────┼────────────────┐ │AAAAA│AAAAAAAAAAAAAA\0│ ├─────┼────────────────┘ 0 5 20 area/src dest ├─────┼────────────────┐ │TestS│tringAAAAAAAAA\0│ ├─────┼────────────────┘ area/src dest ├─────┼────────────────┐ │TestS│TestStringAAAA\0│ ├─────┼────────────────┘ ***/
        char *src3 = area;
        char *dst3 = area + 5;
        memcpy(src3, "TestString", strlen("TestString") + 1); // 里面包含了一个'\0', 将其也复制过去
        // memmove 的 测试
        printf("Before memmove dest = %s, src = %s, len = %ld\n", dst3, src3, strlen(src3));
        char *ret3 = (char *)memmove(dst3, src3, strlen(src3));
        printf("After memmove dest = %s \n\ src = %s\n\ ret = %s\n",
               dst3, src3, ret3);
        putchar(10);
    
        // 将测试空间复原
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0'; // 方便在printf的时候及时停止
    
        char *src4 = area;
        char *dst4 = area + 5;
        memcpy(src4, "TestString", strlen("TestString") + 1); // 里面包含了一个'\0', 将其也复制过去
    
        // my_memmove 的 测试
        printf("Before my_memmove dest = %s, src = %s, len = %ld\n", dst4, src4, strlen(src4));
        char *ret4 = (char *)my_memmove(dst4, src4, strlen(src4));
        printf("After my_memmove dest = %s\n\ src = %s\n\ ret = %s\n",
               dst4, src4, ret4);
        putchar(10);
        /* 第二种情况： area/dest src ├─────┼────────────────┐ │BBBBB│BBBBBBBBBBBBBB\0│ ├─────┼────────────────┘ 0 5 area/dest src ├─────┼──────────────────┐ │BBBBB│TestString\0BBBB\0│ ├─────┼──────────────────┘ area/dest src ├─────┼─────────────────┐ │TestS│ringtring\0BBBB\0│ ├─────┼─────────────────┘ ***/
        memset(area, 'B', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0'; // 方便在printf的时候及时停止
        printf("area = %s, len = %ld\n", area, strlen(area));
    
        char *src5 = area + 5;
        char *dst5 = area;
        memcpy(src5, "TestString", strlen("TestString") + 1); // 里面包含了一个'\0', 将其也复制过去
    
        // memmove 的测试
        printf("Before memmove dest = %s, src = %s, len = %ld\n", dst5, src5, strlen(src5));
        char *ret5 = (char *)memmove(dst5, src5, strlen(src5));
        printf("After memmove dest = %s\n\ src = %s\n\ ret = %s\n",
               dst5, src5, ret5);
        putchar(10);
    
        // 将测试空间复原
        memset(area, 'B', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0'; // 方便在printf的时候及时停止
    
        char *src6 = area + 5;
        char *dst6 = area;
        memcpy(src6, "TestString", strlen("TestString") + 1); // 里面包含了一个'\0', 将其也复制过去
    
        // my_memmove 的测试
        printf("Before my_memmove dest = %s, src = %s, len = %ld\n", dst6, src6, strlen(src6));
        char *ret6 = (char *)my_memmove(dst6, src6, strlen(src6));
        printf("After my_memmove dest = %s\n\ src = %s\n\ ret = %s\n",
               dst6, src6, ret6);
    
        free(area);
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return (0);
    }

测试效果如下图所示。

![20210120100237127.png][]

### 3.6.3、strcpy、strncpy、stpcpy ###

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void debugMsg_Byte(char *msg, void *src, size_t len)
    { 
        int i;
        if (msg == NULL || src == NULL || len < 1)
            return;
        printf("%s", msg);
        unsigned char *tmp = (unsigned char *)src;
        for (i = 0; i < len; i++)
            printf("%02X ", tmp[i]);
        putchar(10);
    }
    
    char *my_strcpy(char *dest, const char *src)
    { 
        char *tmpDest = dest, *tmpSrc = (char *)src;
    
        while (*tmpSrc != '\0')
            *tmpDest++ = *(char *)tmpSrc++;
        *tmpDest = *tmpSrc;
    
        return dest;
    }
    
    char *my_strcpy1(char *dest, const char *src)
    { 
        char *tmpDest = dest, *tmpSrc = (char *)src;
    
        while ((*tmpDest++ = *(char *)tmpSrc++))
            ;
        // 等价于 ：
        // while ((*tmpDest++ = *(char *)tmpSrc++) != '\0');
    
        return dest;
    }
    
    char *my_strncpy(char *dest, const char *src, size_t n)
    { 
        size_t i;
    
        for (i = 0; i < n && src[i] != '\0'; i++)
            dest[i] = src[i];
        for (; i < n; i++)
            dest[i] = '\0';
    
        return dest;
    }
    
    #if WIN32
    char *stpcpy(char *dest, const char *src)
    { 
        size_t len = strlen(src);
        return memcpy(dest, src, len + 1) + len;
    }
    
    char *stpncpy(char *dest, const char *src, size_t n)
    { 
        size_t size = strlen(src) < n ? strlen(src) : n;
        memcpy(dest, src, size);
        dest += size;
        if (size == n)
            return dest;
        return memset(dest, '\0', n - size);
    }
    #endif
    
    int main(int argc, const char **argv)
    { 
        /* strcpy()的功能测试 */
        char *area = (char *)malloc(sizeof(char) * 20);
        char *src = "TestString";
    
        // strcpy 的正常使用方式
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        printf("area length = %ld, area = %s\n", strlen(area), area);
        char *dst1 = area;
        printf("Before strcpy dest = %s, src = %s, len = %ld\n", dst1, src, strlen(src));
        char *ret1 = strcpy(dst1, src);
        printf("After strcpy dest = %s, src = %s, ret = %s\n", dst1, src, ret1);
        putchar(10);
    
        // strcpy的内存重叠
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        dst1 = area;
        char *tst1 = area + 7;
        memset(tst1, 'B', sizeof(char) * 20 - 7 - 1); // 保证末尾的 \0
        /* area/dst1 tst1 ├───────┼──────────────┐ │AAAAAAA│BBBBBBBBBBBB\0│ ├───────┼──────────────┘ 0 7 */
        printf("Before strcpy dest = %s, tst1 = %s, len = %ld\n", dst1, tst1, strlen(tst1));
        ret1 = strcpy(dst1, tst1);
        printf("After strcpy dest = %s, tst1 = %s, ret = %s\n", dst1, tst1, ret1);
        putchar(10);
    
    // 如果定义 __OVERFLOW ，那么在编译阶段会提示 ‘overflows’ 信息的警告
    #if __OVERFLOW
        ret1 = strcpy(dst1, "12345678901234567890123456789");
        printf("strcpy malloc dest = %s, ret = %s\n", dst1, ret1);
    
        char test1[20] = { 0};
        ret1 = strcpy(test1, "12345678901234567890123456789");
        printf("strcpy array dest = %s, ret = %s\n", test1, ret1);
    #endif
    
        // 测试手动实现的函数的功能
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        char *dst2 = area;
        printf("Before my_strcpy dest = %s, src = %s, len = %ld\n", dst2, src, strlen(src));
        char *ret2 = my_strcpy(dst2, src);
        printf("After my_strcpy dest = %s, src = %s, ret = %s\n", dst2, src, ret2);
        putchar(10);
    
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        char *dst3 = area;
        printf("Before my_strcpy1 dest = %s, src = %s, len = %ld\n", dst3, src, strlen(src));
        char *ret3 = my_strcpy1(dst2, src);
        printf("After my_strcpy1 dest = %s, src = %s, ret = %s\n", dst3, src, ret3);
        putchar(10);
    
        /* strncpy()的功能测试 */
        // 第一种情况：strlen(src) < n 的情况
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        char *dst4 = area;
        printf("Before strncpy dest = %s, src = %s, len = %ld\n", dst4, src, strlen(src));
        char *ret4 = strncpy(dst4, src, strlen(src) + 3);
        // 方便看效果，采用ascii码值输出
        debugMsg_Byte("After strncpy dest = : ", dst4, sizeof(char) * 20);
        debugMsg_Byte(" src = : ", src, strlen(src));
        debugMsg_Byte(" ret = : ", ret4, sizeof(char) * 20);
        putchar(10);
    
        // 第二种情况：strlen(src) > n 的情况
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        char *dst5 = area;
        printf("Before strncpy dest = %s, src = %s, len = %ld\n", dst5, src, strlen(src));
        char *ret5 = strncpy(dst5, src, strlen(src) - 3);
        // 方便看效果，采用ascii码值输出
        debugMsg_Byte("After strncpy dest = : ", dst5, sizeof(char) * 20);
        debugMsg_Byte(" src = : ", src, strlen(src));
        debugMsg_Byte(" ret = : ", ret5, sizeof(char) * 20);
        putchar(10);
        // 第三种情况：strlen(src) = n 的情况
        // 这种情况其实使用方式就是 strcpy 的方式了，此处不再进行测试
    
    // 如果定义 __OVERFLOW_N ，那么在编译阶段会提示 ‘overflows’ 信息的警告
    #if __OVERRUN_N
        char *dst6 = area;
        char *ret6 = strncpy(dst6, "12345678901234567890123456789", strlen("12345678901234567890123456789"));
        printf("strncpy malloc dest = %s, ret = %s\n", dst6, ret6);
    
        char test2[20] = { 0};
        char *ret7 = strncpy(test2, "12345678901234567890123456789", strlen("12345678901234567890123456789"));
        printf("strncpy array dest = %s, ret = %s\n", test2, ret7);
    #endif
    
        // 第一种情况：strlen(src) < n 的情况
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        char *dst8 = area;
        printf("Before my_strncpy dest = %s, src = %s, len = %ld\n", dst8, src, strlen(src));
        char *ret8 = my_strncpy(dst8, src, strlen(src) + 3);
        // 方便看效果，采用ascii码值输出
        debugMsg_Byte("After my_strncpy dest = : ", dst8, sizeof(char) * 20);
        debugMsg_Byte(" src = : ", src, strlen(src));
        debugMsg_Byte(" ret = : ", ret8, sizeof(char) * 20);
        putchar(10);
    
        // 第二种情况：strlen(src) > n 的情况
        memset(area, 'A', sizeof(char) * 20);
        area[sizeof(char) * 20 - 1] = '\0';
        char *dst9 = area;
        printf("Before my_strncpy dest = %s, src = %s, len = %ld\n", dst9, src, strlen(src));
        char *ret9 = my_strncpy(dst9, src, strlen(src) - 3);
        // 方便看效果，采用ascii码值输出
        debugMsg_Byte("After my_strncpy dest = : ", dst9, sizeof(char) * 20);
        debugMsg_Byte(" src = : ", src, strlen(src));
        debugMsg_Byte(" ret = : ", ret9, sizeof(char) * 20);
        putchar(10);
    
        /* stpcpy()的功能测试 */
        char buffer[20] = { 0};
        char *to = buffer;
        to = stpcpy(to, "Test");
        to = stpcpy(to, "String");
        printf("After stpcpy, buffer = %s\n", buffer);
    
    // 如果定义 __STPOVERFLOW ，编译无异常，但是运行出错‘core dumped’
    #if __STPOVERFLOW
        // 进行缓冲溢出的测试
        to = stpcpy(to, "TestTheOverflows");
        printf("After stpcpy, buffer = %s\n", buffer);
    #endif
    
        char buffer1[20] = { 0};
        char *to1 = buffer1;
    
        // 第一种情况 ：strlen() < n
        to1 = stpncpy(to1, "Test", strlen("Test") + 3);
        to1 = stpncpy(to1, "String", strlen("Test") + 3);
        printf("After stpncpy, buffer = %s\n", buffer1);
    
        memset(buffer1, 0, sizeof(buffer1));
        to1 = buffer1; // 将 to1 指向重新指向 buffer1,因为 to1 会跟随 stpncpy 移动
    
        // 第二种情况 ：strlen() > n
        to1 = stpncpy(to1, "Test", strlen("Test") - 1);
        to1 = stpncpy(to1, "String", strlen("String") - 3);
        printf("After stpncpy, buffer = %s\n", buffer1);
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return 0;
    }

测试效果如下图所示。

![20210120142559418.png][]

### 3.6.4、strdup、strndup ###

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #if WIN32
    // 因为在 windows 系统下并没有这两个函数，借此方式实现自己手动编写实现
    char *strdup(const char *s)
    { 
        size_t len = strlen(s) + 1;
    
        void *new = malloc(len);
    
        if (new == NULL)
            return NULL;
    
        return (char *)memcpy(new, s, len);
    }
    
    char *strndup(const char *s, size_t n)
    { 
        size_t len = strlen(s) > n ? n : strlen(s);
        char *new = (char *)malloc(len + 1);
    
        if (new == NULL)
            return NULL;
    
        new[len] = '\0';
        return (char *)memcpy(new, s, len);
    }
    
    #endif
    
    int main(int argc, const char **argv)
    { 
        const char *srcStr = "HelloWorld!";
        char *dest = NULL;
    
        /* strdup 函数功能测试 */
        dest = strdup(srcStr);
        if (dest != NULL)
            printf("srcStr = %s, src = %p\ndest = %s, dest = %p\n", srcStr, srcStr, dest, dest);
        else
            printf("dest == NULL\n");
    
        free(dest);
        dest = NULL;
        putchar(10);
    
        /* strndup 函数功能测试 */
        // 第一种情况：strlen(src) > n
        dest = strndup(srcStr, strlen(srcStr) - 3);
        if (dest != NULL)
            printf("srcStr = %s, src = %p\ndest = %s, dest = %p\n", srcStr, srcStr, dest, dest);
        else
            printf("dest == NULL\n");
        free(dest);
        dest = NULL;
        putchar(10);
    
        // 第二种情况：strlen(src) < n
        dest = strndup(srcStr, strlen(srcStr) + 3);
        if (dest != NULL)
            printf("srcStr = %s, src = %p\ndest = %s, dest = %p\n", srcStr, srcStr, dest, dest);
        else
            printf("dest == NULL\n");
        free(dest);
        dest = NULL;
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return 0;
    }

测试效果如下图所示。

![20210120143431605.png][]

## 3.7、组合/分解类型 — 函数功能详细说明 ：将内存空间/字符串进行拼接/追加 ##

char *strcat(char *dest, const char *src);
        功能：把 src 所指字符串附加到 dest 结尾处(覆盖 dest 结尾处的'\0')并添加'\0' 
    	返回：指向 dest 的指针
        说明：1、src 和 dest 所指内存区域不可以重叠
    		 2、dest 必须有足够的空间来容纳 src 的字符串
    			如果 dest 不够大，则程序行为是不可预测的
    		 3、必须要保证参数的正确性，dest 所指字符串在有效范围内必须要以'\0'结尾
    		 4、dest 指向内存区域可以为空，此时类似于strcpy
    char *strncat(char *dest, const char *src, size_t n);
        功能：把 src 所指字符串的最多前 n 个字符附加到 dest 结尾处(覆盖 dest 结尾处的'\0')并添加'\0'
    	返回：指向 dest 的指针
    	说明：1、src 和 dest 所指内存区域不可以重叠
    		 2、dest 必须有足够的空间来容纳 src 的字符串，dest 的大小必须至少为 strlen(dest)+ n + 1
    		 3、如果 src 包含至少 n 个字节，则 src 不需要以 '\0' 结尾
    		 4、如果 n > src字符串的长度，最多复制字符串 src 长度 + 1 个字符（包括'\0'）
    		 5、如果 n < src字符串的长度，复制 n 个字符，并在结尾处添加'\0'
    		 6、dest 指向内存区域可以为空，此时类似于strncpy
    		 
    char *strtok(char *str, const char *delim);
    	功能：将字符串 str 分解成一个由零个或多个非空标记组成的子字符串序列
    	返回：返回指向下一个子字符串的指针，如果没有更多标记，则返回 NULL
    	说明：1、首次调用时，参数 str 必须指向要分解的字符串，随后调用要把 str 设成 NULL
    		 2、可以在分解同一字符串的连续调用中在 delim 中指定不同的字符串
    		 3、在分解过程中，返回的子字符串会丢失 delim 所指的子字符串（如果包含的话）
    		 4、空字符串或只包含分隔符的字符串将导致在第一次调用时返回 NULL
    		 5、会修改第一个参数 str，变成别分割后的第一个子字符串（不包含分解字符串）
    		 6、不能用于常量字符串，因为常量字符串不能被修改
    		 7、解析时使用静态缓冲区，因此它不是线程安全的
    char *strtok_r(char *str, const char *delim, char **saveptr);
    	功能：strtok_r（）函数是可重入的strtok（）版本，
    			saveptr是一个供内部使用的指针，用于保存上次分割剩下的字串
    	返回：返回指向下一个子字符串的指针，如果没有更多标记，则返回 NULL
    	说明：1、内部使用 saveptr 来维护解析同一字符串的连续调用之间的上下文
    		 2、第一次调用时，str 应该指向要分解的字符串，并且 saveptr 的值被忽略
    		 3、在随后的调用中，str 必须为 NULL，saveptr 应该与上次调用后保持不变
    		 4、可以使用指定不同 saveptr 参数的 strtok_r() 同时解析不同的字符串
    		 5、非C标准，可支持 POSIX.1-2001, POSIX.1-2008

## 3.8、组合/分解类型 — 函数功能测试与手动实现 ##

### 3.8.1、strcat、strncat ###

测试效果如下图所示。

![20210120150556693.png][]

### 3.8.2、strtok ###

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void debugMsg_Byte(char *msg, void *src, size_t len, int flag)
    { 
        int i;
        if (msg == NULL || src == NULL || len < 1)
            return;
        printf("%s", msg);
        unsigned char *tmp = (unsigned char *)src;
        for (i = 0; i < len; i++) printf("%02X ", tmp[i]);
        putchar(10);
    
        if (flag)
        { 
            printf("%s", msg);
            for (i = 0; i < len; i++)
                printf("%2c ", tmp[i] != '\0' ? tmp[i] : '0');
            putchar(10);
        }
    }
    
    int main(int argc, const char **argv)
    { 
        char str1[] = "1234;abcd;string;fuck";
        char del1[] = ";";
        printf("Before strtok, str = %s, del = %s\n", str1, del1);
        char *rslt1 = strtok(str1, del1);
        while (rslt1 != NULL)
        { 
            printf("rslt = %s\n", rslt1);
            rslt1 = strtok(NULL, del1);
        }
        printf("Before strtok, str = %s, rslt = %s\n", str1, rslt1);
        putchar(10);
    
        char str2[] = "1234;abcd;string;fuck";
        char del2[] = "-";
        printf("Before strtok, str = %s, del = %s\n", str2, del2);
        char *rslt2 = strtok(str2, del2);
        while (rslt2 != NULL)
        { 
            printf("rslt = %s\n", rslt2);
            rslt2 = strtok(NULL, del2);
        }
        printf("Before strtok, str = %s, rslt = %s\n", str2, rslt2);
        putchar(10);
    
        char str3[] = "1234;abcd;string;fuck";
        char del3[] = ";";
        printf("Before strtok, str = %s, del = %s\n", str3, del3);
        char *rslt3 = strtok(str3, del3);
        while (rslt3 != NULL)
        { 
            printf("rslt = %s\n", rslt3);
            rslt3 = strtok(NULL, "c");
        }
        printf("Before strtok, str = %s, rslt = %s\n", str3, rslt3);
        putchar(10);
    
        char str4[] = "1234;5678;hello world";
        char del4[] = ";";
        int len = strlen(str4);
        debugMsg_Byte("rslt : ", str4, len, 1);
    
        printf("Before strtok, str = %s, del = %s\n", str4, del3);
        char *rslt4 = strtok(str4, del4);
        while (rslt4 != NULL)
        { 
            // printf("rslt = %s\n", rslt3);
            debugMsg_Byte("rslt : ", rslt4, len, 1);
            rslt4 = strtok(NULL, ";");
        }
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
    	return 0;
    }

测试效果如下图所示。

![20210120151725510.png][]

如果还有兴趣或者需要了解其他的函数，可以继续检阅下文：

[C语言 – string.h中函数功能详解与手动实现 - 03（常用函数memcpy、memmove、strcpy、strdup、strcat、strtok…）][C_ _ string.h_ - 03_memcpy_memmove_strcpy_strdup_strcat_strtok]

好啦，废话不多说，总结写作不易，如果你喜欢这篇文章或者对你有用，请动动你发财的小手手帮忙**点个赞**，当然**关注一波**那就更好了，好啦，就到这儿了，么么哒(\* ￣3)(ε￣ \*)。

![20201117155233402.gif][] ![20210110161843908.gif][]

上一篇：[C语言 – string.h中函数功能详解与手动实现 - 01（常用函数memset、memcmp、strcmp、strncmp …）][C_ _ string.h_ - 01_memset_memcmp_strcmp_strncmp]  
下一篇：[C语言 – string.h 字符串操作函数功能的手动实现（常用函数memmove、memcpy、memcmp、strcpy、strlen、strcat …）][C_ _ string.h_ - 03_memcpy_memmove_strcpy_strdup_strcat_strtok]

[C_ _ string.h_ - 01_memset_memcmp_strcmp_strncmp]: https://blog.csdn.net/zhemingbuhao/article/details/112061750
[2021012009361524.png]: /images/20221119/aa00ccb133254fcd8e979c546f75ccb5.png
[20210120100237127.png]: https://img-blog.csdnimg.cn/20210120100237127.png
[20210120142559418.png]: https://img-blog.csdnimg.cn/20210120142559418.png
[20210120143431605.png]: https://img-blog.csdnimg.cn/20210120143431605.png
[20210120150556693.png]: https://img-blog.csdnimg.cn/20210120150556693.png
[20210120151725510.png]: https://img-blog.csdnimg.cn/20210120151725510.png
[C_ _ string.h_ - 03_memcpy_memmove_strcpy_strdup_strcat_strtok]: https://blog.csdn.net/zhemingbuhao/article/details/112431745
[20201117155233402.gif]: https://img-blog.csdnimg.cn/20201117155233402.gif
[20210110161843908.gif]: https://img-blog.csdnimg.cn/20210110161843908.gif