C语言 -- string.h中函数功能详解与手动实现 - 01（常用函数memset、memcmp、strcmp、strncmp ...）

女爷i 2023-01-01 08:50 240阅读 0赞

### 内容预览 ###

*  一、测试环境说明
 *   *  1.1、Windows测试环境
     *  1.2、Linux测试环境
 *  二、简单的不太严谨的函数分类
 *  三、函数功能说明与手动实现
 *   *  3.1、填充/设置类型 --- 函数功能详细说明
     *  3.2、填充/设置类型 --- 函数功能测试与手动实现
     *   *  3.2.1、memset
         *  3.2.2、bzero
         *  3.2.3、strset、strnset
     *  3.3、比较类型 --- 函数功能详细说明
     *  3.4、比较类型 --- 函数功能测试与手动实现
     *   *  3.4.1、memcmp、memicmp
         *  3.4.2、strcmp、strncmp、strcmpi、stricmp

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

摘要

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

# 一、测试环境说明 #

本文中测试代码使用的环境分别为：

## 1.1、Windows测试环境 ##

Windows 10专业版 64Bit Powershell 
    
    gcc --version 
    gcc.exe (GCC) 3.4.5 (mingw-vista special r3)
    Copyright (C) 2004 Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

在 **Windows**，使用 **MinGW** 环境下 **string.h** 存在于路径 `~\MinGW\include` 文件夹下面。其他环境类似。

## 1.2、Linux测试环境 ##

Ubuntu 16.04 LTS GNU bash，版本 4.3.48(1)-release
    $ gcc --version 
    gcc (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609
    Copyright (C) 2015 Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

在 **Linux** 环境下，**string.h** 存在于路径 `/usr/include/` 文件夹下面。

上面的所有的功能函数都基于 **glibc-2.27** 版本，想要查看源码或者其他版本的也可以了自行下载和查看：

1、官网（虽说习惯上去官网，但下载速度真的慢）： [http://ftp.gnu.org/gnu/glibc/][http_ftp.gnu.org_gnu_glibc]

2、清华大学开源软件镜像站点： [https://ftpmirror.gnu.org/libc/ ][https_ftpmirror.gnu.org_libc_]

3、中国科技大学开源软件镜像站点： [https://mirrors.ustc.edu.cn/gnu/libc/][https_mirrors.ustc.edu.cn_gnu_libc]

# 二、简单的不太严谨的函数分类 #

那么下面罗列是出现比较频繁的操作函数，首先先来一个简单的、不算太准确的函数归类吧（下面部分函数不是 **POSIX** 的标准，所以在 **Linux** 环境上可能不支持，同时也有部分函数是 **GNU** 的扩展，在 **MinGW** 下也可能不支持，所有的测试均已 **Linux** 环境为主进行测试）。

*  1、填充/设置类型 — 将内存空间设置为指定的字符（串）

void *memset(void *s, int c, size_t n); 
    	void bzero(void *s, size_t n); 
    	char *strset(char *s, char c); 
    	char *strnset(char *s, char c, size_t n);

*  2、比较类型 — 将两个内存空间/字符串进行比较

int memcmp(const void *s1, const void *s2, size_t n); 
    	int memicmp(void *buf1, void *buf2, unsigned int count); 
    	int strcmp(const char *s1, const char *s2); 
    	int stricmp(char *s1,char * s2); 
    	int strncmp(const char *s1, const char *s2, size_t n); 
    	int strnicmp(char *s1, char * s2, size_t n);

*  3、搬迁类型 — 将内存空间中内容移动、复制到另一内存空间

void *memcpy(void *dest, const void *src, size_t n); 
    	void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count);  
    	void *memmove(void *dest, const void *src, size_t n); 
    	char *strcpy(char *dest, const char *src);  
    	char *strncpy(char *dest, const char *src, size_t n); 
    	char *stpcpy(char *dest, const char *src); 
    	char *strdup(const char *s); 
    	char *strndup(const char *s, size_t n); 
    	char *strdupa(const char *s);
    	char *strndupa(const char *s, size_t n);

*  4、组合/分解类型 — 将内存空间/字符串进行拼接/追加

char *strcat(char *dest, const char *src); 
    	char *strncat(char *dest, const char *src, size_t n); 
    	char *strtok(char *str, const char *delim); 
    	char *strtok_r(char *str, const char *delim, char **saveptr);

*  5、查询类型 — 在内存空间/字符串查找特定字符（串）

void *memchr(const void *s, int c, size_t n); 
    	void *memrchr(const void *s, int c, size_t n); 
    	void *rawmemchr(const void *s, int c); 
    	char *strchr(const char *s, int c); 
    	char *strrchr(const char *s, int c);	 
    	char *strstr(const char *haystack, const char *needle); 
    	char *strcasestr(const char *haystack, const char *needle); 
    	char *strpbrk(const char *s, const char *accept); 
    	size_t strspn(const char *s, const char *accept); 
    	size_t strcspn(const char *s, const char *reject);

*  6、属性类型 — 计算字符串包含的字符个数/长度

size_t strlen(const char *s); 
    	size_t strnlen(const char *s, size_t maxlen);

*  7、转换类型 — 将字符串包含字符进行大小写转换/翻转

char *strupr(char *s);    
    	char *strlwr(char *s);  
    	char *strrev(char *str);

# 三、函数功能说明与手动实现 #

## 3.1、填充/设置类型 — 函数功能详细说明 ##

void *memset(void *s, int c, size_t n);
        功能：把 s 所指内存区域的前 n 个字节设置成字符 c
        返回：指向 s 的指针
    	说明：1、为原始初始化，一般做清零使用
    		 2、直接操作内存对象，效率比较快
    		 3、操作过程按照字节进行，对于一般赋值操作需要额外注意
    void bzero(void *s, size_t n);
        功能：将 s 指向的内存空间的前 n 个字节清零
    	返回：无返回值
        说明：1、不是ANSI C标准函数，可用memset代替
    		 2、s 指向字符串的时候在清零时包括'\0'
    char *strset(char *s, char c);
        功能：把 s 指向的字符串中的所有字节都设置成字符 c
    	返回：指向 s 的指针
        说明：1、是直接修改 s，所以 s 不能为字符串常量
    		 2、判断 '\0' 为结束，所以需要保证字符串以 '\0' 结束
    		 3、不是 C 标准函数，可以完美使用 memset 代替
    char *strnset(char *s, char c, size_t n);
    	功能：把 s 指向的字符串中的前 n 个字节都设置成字符 c
    	返回：指向 s 的指针
        说明：1、是直接修改 s，所以 s 不能为字符串常量
    		 2、如果 s 指向字符串的长度大于 n，超出部分不再操作
    		 3、如果 s 指向字符串的长度小于 n，遇到 '\0' 即结束
    		 4、不是 C 标准函数，可以完美使用 memset 代替

## 3.2、填充/设置类型 — 函数功能测试与手动实现 ##

### 3.2.1、memset ###

#include <stdio.h> // for printf
    #include <stdlib.h> // for malloc
    #include <string.h> // for memset
    
    #define MEMSIZE 5
    
    // 手动实现memset函数功能
    void *my_memset(void *s, int c, size_t n)
    { 
        char *tmp = (char *)s;
    
        while (n)
            *tmp++ = (char)c, n--;
    
        return s;
    }
    
    int main(int argc, const char **argv)
    { 
        int i;
        int *mem1 = (int *)malloc(sizeof(int) * MEMSIZE);
        printf("The initial state of 'mem' is :\n");
        for (i = 0; i < MEMSIZE; i++) printf("%08X ", mem1[i]);
        // 将内存空间设置为 100，看看效果
        int *ret1 = (int *)memset(mem1, 0x64, sizeof(int) * MEMSIZE);
        printf("\nAfter 'memset(0x64)', the state of 'mem' is :\n");
        for (i = 0; i < MEMSIZE; i++) printf("%08X ", mem1[i]);
        // 输出内存空间、返回指针的指针的值，并判断是否相等
        printf("\nLine = %d, mem = %p, ret = %p, mem %s ret\n", __LINE__, mem1, ret1, mem1 == ret1 ? "=" : "!=");
    
        int *mem2 = (int *)malloc(sizeof(int) * MEMSIZE);
        // 测试自己实现的函数的功能
        int *ret2 = (int *)my_memset(mem2, 0x11223344, sizeof(int) * MEMSIZE);
        printf("\nAfter 'my_memset(0x11223344)', the state of 'mem' is :\n");
        for (i = 0; i < MEMSIZE; i++) printf("%08X ", mem2[i]);
        // 输出内存空间、返回指针的指针的值，并判断是否相等
        printf("\nLine = %d, mem = %p, ret = %p, mem %s ret\n", __LINE__, mem2, ret2, mem2 == ret2 ? "=" : "!=");
    
        // 将内存空间设置为 0，看看效果
        ret1 = (int *)memset(mem1, 0, sizeof(int) * MEMSIZE);
        printf("\nAfter 'memset(0)', the state of 'mem' is :\n");
        for (i = 0; i < MEMSIZE; i++) printf("%08X ", mem1[i]);
        // 输出内存空间、返回指针的指针的值，并判断是否相等
        printf("\nLine = %d, mem = %p, ret = %p, mem %s ret\n", __LINE__, mem1, ret1, mem1 == ret1 ? "=" : "!=");
    
        // 测试手动实现函数的功能，将内存空间设置为 0，看看效果
        ret2 = (int *)my_memset(mem2, 0, sizeof(int) * MEMSIZE);
        printf("\nAfter 'my_memset(0)', the state of 'mem' is :\n");
        for (i = 0; i < MEMSIZE; i++) printf("%08X ", mem2[i]);
        // 输出内存空间、返回指针的指针的值，并判断是否相等
        printf("\nLine = %d, mem = %p, ret = %p, mem %s ret\n", __LINE__, mem2, ret2, mem2 == ret2 ? "=" : "!=");
    
    #if __STR_NULL
        // 参数测试
        char *test = NULL;
        char *ret = (char *)memset(test, 0, sizeof(char) * MEMSIZE);
        printf("\nLine = %d, test = %p, ret = %p\n", __LINE__, test, ret);
    #endif
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return 0;
    }

测试效果如下图所示。

![20210112155355122.png][]

### 3.2.2、bzero ###

懒得写程序啦，一个简单的非标准函数。恍恍惚惚2333333…

### 3.2.3、strset、strnset ###

#include <stdio.h> // for printf
    #include <stdlib.h> // for malloc
    #include <string.h> // for strset
    
    #define MEMSIZE 10
    void debugMsg(char *src, size_t len)
    { 
        int i;
        if (src == NULL || len < 1) return;
    
        unsigned char *tmp = (unsigned char *)src;
        for (i = 0; i < len; i++) printf("%X ", tmp[i]);
        putchar(10);
        for (i = 0; i < len; i++) printf("%2c ", tmp[i]);
        putchar(10);
    }
    
    #if !WIN32
    char *strset(char *s, char c)
    { 
        char *tmp = s;
    
        while (*tmp != '\0')
            *tmp = c, tmp++;
    
        return s;
    }
    
    char *strnset(char *s, char c, size_t n)
    { 
        char *tmp = s;
    
        while (*tmp != '\0' && n)
            *tmp = c, n--, tmp++;
    
        return s;
    }
    #endif
    
    int main(int argc, const char **argv)
    { 
        // 首先申请一块空间用于测试
        char *s = (char *)malloc(sizeof(char) * MEMSIZE);
        printf("Line = %d, The initial state of 's' is :\n", __LINE__);
        debugMsg(s, MEMSIZE);
    
        // 将字符串空间全部设置为字符 1，也就是ASCII中的数字 0x31
        char *ret = (char *)strset(s, '1');
        printf("After 'strset('1')', the state of 's' is :\n");
        debugMsg(s, MEMSIZE);
        printf("Line = %d, ret = %p, s = %p\n", __LINE__, ret, s);
    
        // 测试字符数组的效果
        char buf[] = "abcdefTest";
        // 将字符数组的前5个字符设置为字符1的效果
        printf("\nAfter 'strset('1')', the state of 'buf' is :\n");
        ret = (char *)strnset(buf, '1', MEMSIZE - 5);
        debugMsg(buf, strlen(buf));
        printf("\nLine = %d, ret = %p, buf = %p\n", __LINE__, ret, buf);
    
        // 将字符数组的所有字符设置为字符2的效果
        ret = (char *)strset(buf, '2');
        printf("\nAfter 'strset('2')', the state of 'buf' is :\n");
        debugMsg(buf, strlen(buf));
        printf("\nLine = %d, ret = %p, buf = %p\n", __LINE__, ret, buf);
    
    #if __STR_NULL
        // 测试在传入参数为NULL的情况
        char *test = NULL;
        ret = (char *)strset(test, '1');
        printf("\nLine = %d, ret = %p, test = %p\n", __LINE__, ret, test);
    #endif
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
        return 0;
    }

测试效果如下图所示。

![20210112160508954.png][]

**测试效果图片说明**：

在上图中的测试效果可以看出来，第二个红箭头所指的内容为 **“0”** 而并非要设置的目标值 **“1”** ，这是因为在 Linux 环境下将申请的空间已经设置为全 **0** ， 而函数 **strset** 函数是判断字符串结束符 **’\\0’** 来终止的，所以判断开始即遇到 **’\\0’** ，所以后面的也就不再进行了。

在windows下测试实际效果与上图显示有区别。可自行测试。

## 3.3、比较类型 — 函数功能详细说明 ##

int memcmp(const void *s1, const void *s2, size_t n);
        功能：比较内存区域 s1 和 s2 的前 n 个字节。
        返回：
            当 buf1 < buf2 时，返回值 < 0
            当 buf1 = buf2 时，或者在 n 等于0 的情况下时，返回值 = 0 
            当 buf1 > buf2 时，返回值 > 0
        说明：1、需要保证参数的有效性与正确性
             2、按照字节进行比较，确切说应该是比较至多前n个字节的ASCII码值，返回结果
             3、如果第 k(k < n) 个字节两者不相同，则终止比较，返回结果
             4、比较的过程不会受到有特殊意义的字符或标识的影响（比如'\0'）
    int memicmp(void *buf1, void *buf2, unsigned int count);
        功能：比较内存区域 buf1 和 buf2 的前 count 个字节，但不区分字母的大小写。
        返回：
            当 buf1 < buf2 时，返回值 < 0
            当 buf1 = buf2 时，返回值 = 0
            当 buf1 > buf2 时，返回值 > 0
        说明：1、同 memcmp 的唯一区别是：memicmp不区分大小写字母。
             2、本测试环境的Linux下不支持此函数
           
    int strcmp(const char *s1, const char *s2);
        功能：比较字符串 s1 和 s2。
        返回：
            当 s1 < s2 时，返回值 < 0
            当 s1 = s2 时，返回值 = 0
            当 s1 > s2 时，返回值 > 0
        说明：1、将字符串按照从左到右的顺序逐字符进行比较，直到出现不同字符或者出现'\0'（包括'\0'）
             2、ANSI标准中返回值只区分正数负数，本测试环境的Linux下返回为首次出现不同字符的ASCII的差值
             3、保证参数的合法性
    int stricmp(char *s1,char * s2);
        功能：比较字符串 s1 和 s2，但不区分字母的大小写。
        返回：
            当 s1 < s2 时，返回值 < 0
            当 s1 = s2 时，返回值 = 0
            当 s1 > s2 时，返回值 > 0
        说明：1、stricmp 与 strcmp 功能一致，只是 stricmp 不区分字符的大小写
             2、strcmpi 是 stricmp 的宏定义，实际未提供此函数。
             2、本测试环境的Linux下不支持此函数
    int strncmp(const char *s1, const char *s2, size_t n);
        功能：比较字符串 s1 和 s2 的至多前 n 个字符。
        返回：
            当 s1 < s2 时，返回值 < 0
            当 s1 = s2 时，返回值 = 0
            当 s1 > s2 时，返回值 > 0
        说明：1、保证参数的合法性
             2、从做到右逐字符进行比较，至多比较前 n 个字节，当 n 等于其中一个字符串的长度的时候，
             	实际效果与 strcmp 一致
             3、当 k (k < n)的时候出现 ASCII 不相同的字符或者出现'\0'（包括），则结束比较并返回
    int strnicmp(char *s1, char * s2, size_t n);
        功能：比较字符串 s1 和 s2 的至多前 n 个字符，但不区分大小写。
        返回：
            当 s1 < s2 时，返回值 < 0
            当 s1 = s2 时，返回值 = 0
            当 s1 > s2 时，返回值 > 0
        说明：1、与 strncmp功能一致，只是不区别字符的大小写
             2、strncmpi 是 strnicmp 的宏定义，实际未提供此函数。
             3、本测试环境的Linux下不支持此函数

## 3.4、比较类型 — 函数功能测试与手动实现 ##

### 3.4.1、memcmp、memicmp ###

#include <stdio.h> // for printf
    #include <stdlib.h> // for malloc calloc
    #include <string.h> // for memxxcmp
    
    int my_memcmp(const void *s1, const void *s2, size_t count)
    { 
        if (0 == count) return 0;
    
        while (count && *(unsigned char *)s1 == *(unsigned char *)s2)
        { 
            count--;
            s1 = (unsigned char *)s1 + 1;
            s2 = (unsigned char *)s2 + 1;
        }
        return (*((unsigned char *)s1) - *((unsigned char *)s2));
    }
    
    #if !WIN32
    // 其实就是在memcmp的基础上增加一个字符大小写转换的过程，转换可以宏定义实现，也可以只用c库函数
    #if __CTYPE
    #include <ctype.h>
    int memicmp(void *s1, void *s2, unsigned int count)
    { 
        if (0 == count) return 0;
    
        while (count)
        { 
            unsigned char tmps1 = toupper(*(unsigned char *)s1);
            unsigned char tmps2 = toupper(*(unsigned char *)s2);
            if (tmps1 != tmps2) break;
    
            --count;
            s1 = (unsigned char *)s1 + 1;
            s2 = (unsigned char *)s2 + 1;
        }
        return (*((unsigned char *)s1) - *((unsigned char *)s2));
    }
    #else
    // 不用C库函数，自行实现
    #define TOUPPER(s) ((s) >= 'a' && (s) <= 'z') ? (s - 'a' + 'A') : (s)
    #define TOLOWER(s) ((s) >= 'A' && (s) <= 'Z') ? (s - 'A' + 'a') : (s)
    
    int memicmp(void *s1, void *s2, unsigned int count)
    { 
        if (0 == count) return 0;
    
        while (count)
        { 
            unsigned char tmps1 = TOUPPER(*(unsigned char *)s1);
            unsigned char tmps2 = TOUPPER(*(unsigned char *)s2);
            if (tmps1 != tmps2) break;
    
            --count;
            s1 = (unsigned char *)s1 + 1;
            s2 = (unsigned char *)s2 + 1;
        }
    
        return (*((unsigned char *)s1) - *((unsigned char *)s2));
    }
    #endif // end of #if __CTYPE
    #endif // end of #if WIN32
    
    int main(int argc, const char **argv)
    { 
        // 方便进行赋值测试，暂且定义下列内容
        char *initSrc1 = "TestString";
        char *initSrc2 = "Teststring";
        char *initSrc3 = "test";
    
        printf("About 'memcmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               initSrc1, initSrc2, memcmp(initSrc1, initSrc2, strlen(initSrc1)),
               initSrc1, initSrc1, memcmp(initSrc1, initSrc1, strlen(initSrc1)),
               initSrc2, initSrc1, memcmp(initSrc2, initSrc1, strlen(initSrc1)),
               initSrc1, initSrc3, memcmp(initSrc1, initSrc3, strlen(initSrc1)));
    
        printf("About 'my_memcmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               initSrc1, initSrc2, my_memcmp(initSrc1, initSrc2, strlen(initSrc1)),
               initSrc1, initSrc1, my_memcmp(initSrc1, initSrc1, strlen(initSrc1)),
               initSrc2, initSrc1, my_memcmp(initSrc2, initSrc1, strlen(initSrc1)),
               initSrc1, initSrc3, my_memcmp(initSrc1, initSrc3, strlen(initSrc1)));
    
        printf("About 'memicmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               initSrc1, initSrc2, memicmp(initSrc1, initSrc2, strlen(initSrc1)),
               initSrc1, initSrc1, memicmp(initSrc1, initSrc1, strlen(initSrc1)),
               initSrc2, initSrc1, memicmp(initSrc2, initSrc1, strlen(initSrc1)),
               initSrc1, initSrc3, memicmp(initSrc1, initSrc3, strlen(initSrc1)));
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return 0;
    }

测试效果如下图所示。

![20210112174715455.png][]

### 3.4.2、strcmp、strncmp、strcmpi、stricmp ###

#include <stdio.h> // for printf
    #include <stdlib.h> // for malloc calloc
    #include <string.h> // for memxxcmp
    
    #if !WIN32
    // 其实就是增加一个字符大小写转换的过程，转换可以宏定义实现，也可以只用c库函数
    #if __CTYPE
    #include <ctype.h>
    int stricmp(const char *s1, const char *s2)
    { 
        int ca, cb;
        do
        { 
            ca = (unsigned char)*s1++;
            cb = (unsigned char)*s2++;
            ca = toupper(ca);
            cb = toupper(cb);
        } while (ca == cb && ca != '\0');
    
        return ca - cb;
    }
    
    int strnicmp(char *s1, char *s2, size_t n)
    { 
        while (--n && *s1 && *s2 && toupper(*s1) == toupper(*s2))
            s1++, s2++;
    
        return toupper(*s1) != toupper(*s2) ? *s1 - *s2 : 0;
    }
    
    #else
    // 不用C库函数，自行实现
    #define TOUPPER(s) (((s) >= 'a' && (s) <= 'z') ? (s - 'a' + 'A') : (s))
    #define TOLOWER(s) (((s) >= 'A' && (s) <= 'Z') ? (s - 'A' + 'a') : (s))
    
    int stricmp(const char *s1, const char *s2)
    { 
        int ca, cb;
        do
        { 
            ca = (unsigned char)*s1++;
            cb = (unsigned char)*s2++;
            ca = TOUPPER(ca);
            cb = TOUPPER(cb);
        } while (ca == cb && ca != '\0');
    
        return ca - cb;
    }
    
    int strnicmp(char *s1, char *s2, size_t n)
    { 
        while (--n && *s1 && *s2 && TOUPPER(*s1) == TOUPPER(*s2))
            s1++, s2++;
    
        return TOUPPER(*s1) != TOUPPER(*s2) ? *s1 - *s2 : 0;
    }
    #endif // end of #if __CTYPE
    #endif // end of #if WIN32
    
    int my_strcmp(const char *s1, const char *s2)
    { 
        while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0')
            s1++, s2++;
    
        return *s1 - *s2;
    }
    
    int my_strncmp(char *s1, char *s2, size_t n)
    { 
        while (--n && *s1 && *s2 && *s1 == *s2)
            s1++, s2++;
    
        return *s1 - *s2;
    }
    
    int main(int argc, const char **argv)
    { 
        char *s1 = "abcd1234";
        char *s2 = "abcD1234";
        char *s3 = "abcd12";
    
        printf("About 'strcmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               s1, s2, strcmp(s1, s2),
               s1, s1, strcmp(s1, s1),
               s2, s1, strcmp(s2, s1),
               s1, s3, strcmp(s1, s3));
    
        printf("About 'my_strcmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               s1, s2, my_strcmp(s1, s2),
               s1, s1, my_strcmp(s1, s1),
               s2, s1, my_strcmp(s2, s1),
               s1, s3, my_strcmp(s1, s3));
    
        printf("About 'stricmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               s1, s2, stricmp(s1, s2),
               s1, s1, stricmp(s1, s1),
               s2, s1, stricmp(s2, s1),
               s1, s3, stricmp(s1, s3));
    
        putchar(10);
    
        printf("About 'strncmp':\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n %s VS %s = %d\n",
               s1, s2, strncmp(s1, s2, strlen(s1)),
               s1, s1, strncmp(s1, s1, strlen(s1)),
               s2, s1, strncmp(s2, s1, strlen(s1)),
               s1, s3, strncmp(s1, s3, strlen(s1)));
    
        printf("About 'strncmp':\n %s VS %s (%d) = %d\n %s VS %s (%d) = %d\n %s VS %s (%d) = %d\n",
               s1, s2, 5, strncmp(s1, s2, 5),
               s1, s2, 4, strncmp(s1, s2, 4),
               s1, s2, 3, strncmp(s1, s2, 3));
    
        printf("About 'my_strncmp':\n %s VS %s (%d) = %d\n %s VS %s (%d) = %d\n %s VS %s (%d) = %d\n",
               s1, s2, 5, my_strncmp(s1, s2, 5),
               s1, s2, 4, my_strncmp(s1, s2, 4),
               s1, s2, 3, my_strncmp(s1, s2, 3));
    
        printf("About 'strnicmp':\n %s VS %s (%d) = %d\n %s VS %s (%d) = %d\n %s VS %s (%d) = %d\n %s VS %s (%ld) = %d\n",
               s1, s2, 5, strnicmp(s1, s2, 5),
               s1, s2, 4, strnicmp(s1, s2, 4),
               s1, s2, 3, strnicmp(s1, s2, 3),
               s1, s3, strlen(s1), strnicmp(s1, s3, strlen(s1)));
    
        printf("\n\e[1;32msystem exited with return code %d\e[0m\n\n", 0);
    
        return 0;
    }

测试效果如下图所示。

![20210120092229617.png][]

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

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

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

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

上一篇：[本文][Link 1]  
下一篇：[C语言 – string.h中函数功能详解与手动实现 - 02（常用函数memcpy、memmove、strcpy、strdup、strcat、strtok…）][C_ _ string.h_ - 02_memcpy_memmove_strcpy_strdup_strcat_strtok]

[http_ftp.gnu.org_gnu_glibc]: http://ftp.gnu.org/gnu/glibc/
[https_ftpmirror.gnu.org_libc_]: https://ftpmirror.gnu.org/libc/
[https_mirrors.ustc.edu.cn_gnu_libc]: https://mirrors.ustc.edu.cn/gnu/libc/
[20210112155355122.png]: /images/20221120/37511ba4950c44e4aa3b309942c58f6f.png
[20210112160508954.png]: /images/20221120/2ddb70330e844b39a3b08e36d6bb67e5.png
[20210112174715455.png]: /images/20221120/c3200f60892341d2aa82e1b0851e41a2.png
[20210120092229617.png]: /images/20221120/3ceb3b0db953467bbada7e627341b310.png
[C_ _ string.h_ - 02_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]: /images/20221120/18aa9f63ed144982a624a12dfc907530.png
[Link 1]: https://blog.csdn.net/zhemingbuhao/article/details/112061750