string.h中常用字符串操作函数说明（strstr，strtok，strrchr，strcat，strcmp，strcpy，strerror，strspn，strchr等）

清疚 2022-12-08 12:56 134阅读 0赞

### string.h ###

*  概念
 *  函数详解
 *   *  memchr
     *  memcmp
     *  memcpy
     *  memmove
     *  memset
     *  strcat
     *  strchr
     *  strcmp
     *  strcoll
     *  strcpy
     *  strcspn
     *  strerror
     *  strlen
     *  strncat
     *  strncmp
     *  strncpy
     *  strpbrk
     *  strrchr
     *  strspn
     *  strstr
     *  strtok
     *  strxfrm

# 概念 #

C语言标准库中一个常用的头文件，在使用到字符数组时需要使用。string .h 头文件定义了一个变量类型、一个宏和各种操作字符数组的函数。

使用时都需要加上头文件

string.h

# 函数详解 #

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>memchr</td> 
   <td>在内存块中定位字符的位置还有相似函数memrchr和rawmemchr</td> 
  </tr> 
  <tr> 
   <td>memcmp</td> 
   <td>把两个内存块的内容进行比较。</td> 
  </tr> 
  <tr> 
   <td>memcpy</td> 
   <td>复制内存块的内容</td> 
  </tr> 
  <tr> 
   <td>memmove</td> 
   <td>移动内存块中的内容</td> 
  </tr> 
  <tr> 
   <td>memset</td> 
   <td>以字节方式填充内存块</td> 
  </tr> 
  <tr> 
   <td>strcat</td> 
   <td>把一个字符串后追加到另一个字符串后</td> 
  </tr> 
  <tr> 
   <td>strchr</td> 
   <td>在字符串中查找一个字符的第一个位置指针</td> 
  </tr> 
  <tr> 
   <td>strcmp</td> 
   <td>比较两个字符串（ASCII）</td> 
  </tr> 
  <tr> 
   <td>strcoll</td> 
   <td>比较两个字符串（根据指定的 LC_COLLATE）</td> 
  </tr> 
  <tr> 
   <td>strcpy</td> 
   <td>复制字符串</td> 
  </tr> 
  <tr> 
   <td>strcspn</td> 
   <td>在一个字符串中查找另一个字符串中的第一个出现的字符的位置</td> 
  </tr> 
  <tr> 
   <td>strerror</td> 
   <td>解释错误代码</td> 
  </tr> 
  <tr> 
   <td>strlen</td> 
   <td>返回字符串长度</td> 
  </tr> 
  <tr> 
   <td>strncat</td> 
   <td>把一个字符串的 n 个字符后追加到另一个字符串后</td> 
  </tr> 
  <tr> 
   <td>strncmp</td> 
   <td>比较两个字符串的前 n 个字符（ASCII）</td> 
  </tr> 
  <tr> 
   <td>strncpy</td> 
   <td>复制字符串中的前 n 个字符</td> 
  </tr> 
  <tr> 
   <td>strpbrk</td> 
   <td>查找字符串中第一个出现的属于另一个字符串的任意字符的指针</td> 
  </tr> 
  <tr> 
   <td>strrchr</td> 
   <td>查找字符串中一个字符的出现的最后位置</td> 
  </tr> 
  <tr> 
   <td>strspn</td> 
   <td>计算字符串的从开头起符合另一个字符串的连续字符个数</td> 
  </tr> 
  <tr> 
   <td>strstr</td> 
   <td>在一个字符串中查找另一个字符串</td> 
  </tr> 
  <tr> 
   <td>strtok</td> 
   <td>根据指定字符集分割一个字符串</td> 
  </tr> 
  <tr> 
   <td>strxfrm</td> 
   <td>根据当前环境转化字符串，将转化后的前 n 个字符复制给另一个字符串</td> 
  </tr> 
 </tbody> 
</table>

## memchr ##

*  函数原型：

void *memchr(const void *s, int c, size_t n);

*  功能：在参数 s 所指向的内存块的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置，并返回相应的指针。
 *  返回值：找到返回相应的指针，否则返回 NULL。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char str[1000], ch, *pch;
    
    int main(){ 
        gets(str);
        ch = getchar();
        pch = (char*) memchr(str, ch, strlen(str));       // memchr 的使用
        if ( pch != NULL){ 
            printf ("%c found at %d.\n", ch, pch - str);
        }else{ 
            printf ("%c not found.\n", ch);
        }
        return 0;
    }

*  运行结果：  
    ![在这里插入图片描述][20200919120207533.png_pic_center]

## memcmp ##

*  函数原型：

int memcmp(const void *s1, const void *s2, size_t n);

*  功能：memcmp()函数比较内存区域s1和s2的前n个字节(每个都被解释为无符号字符)。
 *  返回值：返回一个指向dest的指针。

*  demo：

#include <stdio.h>
    #include <string.h>
    
    char s1[20], s2[20];
    
    int main(){ 
    
    	while(1)
    	{ 
    		gets(s1);
    		gets(s2);
    		int n = memcmp(s1, s2, sizeof(s1));
    		if ( n > 0 ){ 
    			printf ("'%s' is greater.n is %d\n", s1,n);
    		}else if( n == 0 ){ 
    			printf ("'%s' is the same as '%s'. n is %d\n", s1, s2,n);
    		}else{ 
    			printf ("'%s' is greater.n is %d\n", s2,n);
    		}
    		memset(s1,0,sizeof(s1));
    		memset(s2,0,sizeof(s2));
    	}
    	return 0;
    }

*  运行结果  
    ![在这里插入图片描述][20200919122930945.png_pic_center]

## memcpy ##

*  函数原型：

void *memcpy(void *dest, const void *src, size_t n);

*  函数功能：从内存区src复制n个字节到内存区dest。内存区不能重叠。只会覆盖。
 *  返回值：返回一个指向dest的指针。
 *  demo：

#include <string.h>
    #include <stdio.h>
    
    char s1[] = "abcdefg", s2[100]={ '0'};
    
    int main()
    { 
        memcpy(s2, s1, strlen(s1) + 1);
        printf (" s2 is '%s'.\n", s2);
        return 0;
    }

*  运行结果  
    ![在这里插入图片描述][20200919124003151.png_pic_center]

## memmove ##

*  函数原型：

void *memmove(void *dest, const void *src, size_t n);

*  函数功能：memmove()函数将n个字节从内存区域src拷贝到内存区域dest。这些内存区域可能重叠:复制发生在  
    虽然src中的字节首先被复制到一个不重叠src或dest的临时数组中，然后到dest的临时数组。
 *  返回值：返回一个指向dest的指针。
 *  demo

//去掉了字符串前面的 4 个空格。
    #include <stdio.h>
    #include <string.h>
    
    char s[] = " too space";
    
    int main(){ 
        memcpy(s, s+4, strlen(s+4)+1);
        printf ("s is '%s'.",s);
        return 0;
    }

*  运行结果  
    ![在这里插入图片描述][20200919125218353.png_pic_center]

## memset ##

*  函数原型

void *memset(void *s, int c, size_t n);

*  函数功能：用常量字节c填充s指向的内存区域的前n个字节。
 *  返回值：返回一个指向内存区域s的指针。
 *  demo

#include <stdio.h>
    #include <string.h>
    
    char str[] = "hello world!";
    
    int main(){ 
        memset(str, '-', strlen(str));
        puts(str);
    
        return 0;
    }

*  运行效果  
    ![在这里插入图片描述][20200919125829202.png_pic_center]

## strcat ##

*  函数原型：

char * strcat ( char * des, const char * src );

*  函数功能：将 src 中的内容追加到 des中。
 *  返回值：返回 des指针。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char s1[] = "hello ", s2[] = "world!";
    
    int main(){ 
        strcat(s1,s2);
        puts(s1);
        return 0;
    }

*  运行结果  
    ![在这里插入图片描述][20200919130253138.png_pic_center]

## strchr ##

*  函数原型：

char *strchr(const char *s, int c);

*  函数功能：返回 s中的 c出现的第一个位置的指针。
 *  返回值：如果找到，返回 s中的 c出现的第一个位置的指针；否则返回 NULL。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char str[] = "hello world!", ch = 'o';
    
    int main(){ 
        char *pch = strchr(str, ch);
        if ( pch != NULL){ 
            printf (" '%c' is found at %d.\n", ch, pch - str);
        }else{ 
            printf ("'%c' is not found.\n", ch);
        }
        return 0;
    }

*  运行效果  
    ![在这里插入图片描述][20200919131910658.png_pic_center]

## strcmp ##

*  函数原型：

int strcmp(const char *s1, const char *s2);

*  功能：比较字符串 str1 和 str2 的字典序大小（ASCII）。
 *  返回值：

*  demo：

#include <stdio.h>
    #include <string.h>
    
    char s1[] = "abcdefg", s2[] = "abcdfgh";
    
    int main(){ 
        int n = strcmp(s1, s2);
        if ( n > 0 ){ 
            printf ("\"%s\" is greater.", s1);
        }else if( n == 0 ){ 
            printf ("\"%s\" is the same as \"%s\".", s1, s2);
        }else{ 
            printf ("\"%s\" is greater.", s2);
        }
        return 0;
    }

*  运行效果

![在这里插入图片描述][20200919132700680.png_pic_center]

## strcoll ##

*  函数原型：

int strcoll(const char *s1, const char *s2);

*  功能：默认情况下(LC\_COLLATE 为 “POSIX” 或 “C” )和 strcmp 一样根据 ASCII 比较字符串大小。对于设置了 LC\_COLLATE 语言环境的情况下，则根据 LC\_COLLATE 设置的语言排序方式进行比较。例如：汉字，根据拼音进行比较
 *  返回值：

*  demo：

#include <stdio.h>
    #include <string.h>
    
    char s1[] = "abcdefg", s2[] = "abcdfgh";
    
    int main(){ 
        int n = strcoll(s1, s2);
        if ( n > 0 ){ 
            printf ("\"%s\" is greater.\n", s1);
        }else if( n == 0 ){ 
            printf ("\"%s\" is the same as \"%s\".\n", s1, s2);
        }else{ 
            printf ("\"%s\" is greater.n\n", s2);
        }
        return 0;
    }

*  运行结果  
    ![在这里插入图片描述][2020091913313026.png_pic_center]

## strcpy ##

*  函数原型：

char *strcpy(char *dest, const char *src);

*  功能：将 src的内容复制给 des，需要保证 des足够容纳 src的空间
 *  返回值： 返回 des。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char s1[] = "abcdefg", s2[100];
    
    int main(){ 
        strcpy(s2, s1);
        printf ("s2 is '%s'.", s2);
        return 0;
    }

*  运行效果  
    ![在这里插入图片描述][20200919133541152.png_pic_center]

## strcspn ##

*  函数原型：

size_t strspn(const char *s, const char *accept);

*  功能：返回 s 中出现的第一个属于 accept 的字符的位置。
 *  返回值： 如果找到返回字符位置，否则返回字符串长度。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    int main(){ 
        int pos = strcspn("qwert1234des","0123456789");
        printf("%d", pos);
        return 0;
    }

## strerror ##

*  函数原型：

char * strerror ( int errnum );

*  函数功能：给出错误代码 errnum 的描述内容。
 *  返回值：返回描述错误内容的字符串指针。
 *  demo：

#include <stdio.h>
    #include <string.h>
    #include <errno.h>
    
    int main(){ 
        FILE *f = fopen("unexist.file", "r");
        if( f == NULL ){ 
            printf ("Error: %s\n",strerror(errno));
        }
        return 0;
    }

## strlen ##

*  函数原型：

size_t strlen ( const char * str );

*  函数功能：返回字符串 str 的长度。
 *  返回值：返回字符串 str 的长度。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    int main(){ 
        char a[] = "hello world!";
        printf("%d", strlen(a));
        return 0;
    }

## strncat ##

*  函数原型：

char * strncat ( char * destination, const char * source, size_t num );

*  函数功能：将 source 中的前 num 个字符串追加到 destination 后。
 *  返回值：返回追加后的 destination 指针。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char s1[] = "hello ", s2[] = "world! -----";
    
    int main(){ 
        strncat(s1, s2, 6);
        puts(s1);
        return 0;
    }

## strncmp ##

*  函数原型：

int strncmp ( const char * str1, const char * str2, size_t num );

*  函数功能：比较 str1 中的前 num 个字符和 str2 中 的前 num 个字符的大小。
 *  返回值：

*  demo

#include <stdio.h>
    #include <string.h>
    
    char s1[] = "abcdfgh", s2[] = "abcdefg";
    
    int main(){ 
        int n = strncmp(s1, s2, 4);
        if ( n > 0 ){ 
            printf ("\"%s\" is greater in the first 4.", s1);
        }else if( n == 0 ){ 
            printf ("\"%s\" is the same as \"%s\" in the first 4.", s1, s2);
        }else{ 
            printf ("\"%s\" is greater in the first 4.", s2);
        }
        return 0;
    }

## strncpy ##

*  函数原型：

char * strncpy ( char * destination, const char * source, size_t num );

*  函数功能：将 source 中的前 num 个字符复制给 destination。如果 source 的长度大于 num，不会自动追加 \\0。若小于，则会填充\\0，直到长度为 num。
 *  返回值：返回 destination 的指针。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    int main(){ 
        char a[1000], b[1000] = "hello world!";
        strncpy(a, b, 5);       //不会自动补 NULL
        a[5] = '\0';
        puts(a);
        return 0;
    }

## strpbrk ##

*  函数原型：

char * strpbrk ( char * str1, const char * str2 );

*  函数功能：查找字符串 str1 中第一个出现的属于字符串 str2 中的任意字符的指针。
 *  返回值：返回字符串 str1 中第一个出现的属于字符串 str2 中的任意字符的指针。若没找到，返回 NULL。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    int main(){ 
        char a[] = "This is a test.", b[] = "aeiou";
        char *pch  = strpbrk(a, b);
        printf("%d", pch - a);
        return 0;
    }

## strrchr ##

*  函数原型：

char * strrchr ( char * str, int character );

*  函数功能：在字符串中 str 查找最后一个 character 的指针位置。
 *  返回值：如果找到，在字符串中 str 查找最后一个 character 的指针位置。否则返回 NULL。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char str[] = "hello world!", ch = 'o';
    
    int main(){ 
        char *pch = strrchr(str, ch);
        if ( pch != NULL ){ 
            printf ("'%c' is found at %d.\n", ch, pch - str);
        }else{ 
            printf ("'%c' is not found.\n", ch);
        }
        return 0;
    }

## strspn ##

*  函数原型：

size_t strspn ( const char * str1, const char * str2 );

*  函数功能： 计算 str1 字符串从开头开始的连续字符，且这些字符都完全是 str2 所指字符串中的字符。
 *  返回值：返回字符的个数。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    int main(){ 
        char a[] = "aaaaauuuuuxxxsada", b[] = "aeiou";
        int n = strspn(a, b);
        printf("%d", n);    //输出为10，满足条件的字符串为aaaaauuuuu。
        return 0;
    }

## strstr ##

*  函数原型：

const char * strstr ( const char * str1, const char * str2 )
    char * strstr ( char * str1, const char * str2 )

*  函数功能：查找字符串 str1 中首次出现字符串 str2 的位置。
 *  返回值：返回 str1 中首次出现 str2 的位置的指针，如果 str1 中不存在 str2 则返回 NULL。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    int main(){ 
        char a[] = "hello world!", b[] = "world";
        char *pch = strstr(a, b);
        printf("%d", pch - a);
        return 0;
    }

## strtok ##

*  函数原型：

char * strtok ( char * str, const char * delimiters );

*  函数功能：根据 delimiters 指定的内容进行分割。第一次需传入待分割的字符串 str 指针，之后的调用传入 NULL 即可。
 *  返回值：返回指向分割后相应的片段的指针。
 *  demo：

#include <stdio.h>
    #include <string.h>
    
    char str[] ="- This is a sample string.";
    
    int main (){ 
        char *pch = strtok(str, " .-,");
        while( pch != NULL){ 
            printf("%s\n", pch);
            pch = strtok(NULL, " .-,");
        }
        return 0;
    }

## strxfrm ##

*  函数原型：

size_t strxfrm ( char * destination, const char * source, size_t num );

*  函数功能说明：根据当前环境（由LC\_COLLATE所指定）转化 source 字符串，并将前 num 个字符复制给 destination。
 *  返回值：返回转换后的字符串的长度。

[20200919120207533.png_pic_center]: /images/20221123/505b813606f34706bb64062bf95ce8c3.png
[20200919122930945.png_pic_center]: /images/20221123/1adb4011bdc044c590032a1caa8c9c50.png
[20200919124003151.png_pic_center]: /images/20221123/6dc94cebd60148f5a4edcace43f3f688.png
[20200919125218353.png_pic_center]: /images/20221123/78953ae662274ff9b4a962f4b0895996.png
[20200919125829202.png_pic_center]: /images/20221123/70d67c41417a480e9968ef1a944a9727.png
[20200919130253138.png_pic_center]: /images/20221123/adedd5ea29d3426894b8563b85f8c6bc.png
[20200919131910658.png_pic_center]: /images/20221123/73cd1531e40d4f19922a593f8e4ed848.png
[20200919132700680.png_pic_center]: /images/20221123/3f3eb3796cd14314b2c4d9576d8e7633.png
[2020091913313026.png_pic_center]: /images/20221123/8d1b21e07d4f484bb3e9628a459f4656.png
[20200919133541152.png_pic_center]: /images/20221123/182c584cd444455cbbdb774ace6922b5.png