C语言-字符处理函数

野性酷女 2022-01-27 07:35 511阅读 0赞

**1.gets()**

> **格式**：char \* gets(char \*s)；
> 
> **功能**：从标准输入读入字符，并保存到指定的内存空间，直到出现换行或读到文件结尾为止
> 
> **参数**：s 字符串首地址
> 
> **返回值**：成功-读入的字符串
> 
>               失败-NULL
> 
> **gets(str)和scanf（"%s",str）的区别**：
> 
> **注**： 由于gets()和scanf()无法知道字符串s大小，必须遇到换行符或读到文件结尾才接收输入，因此容易导致字符数组越界（缓冲区越界）的情况
> 
>  *  gets(str)允许输入的字符串含有空格
>  *  scanf("%s",str)不允许含有空格

#include <stdio.h>
    int main()
    {
        char arr[100],arr1[100];
        gets(arr);
        scanf("%s",arr1);
        printf("gets输出:%s\n",arr);    //gets允许含有空格
        printf("scanf输出:%s\n",arr1);  //scanf不允许含有空格，遇到空格停止接收输入
        return 0;
    }

![20190525213550831.png][]

**gets()函数的返回值是一个char\*，可以有如下操作**

#include <stdio.h>
    int main()
    {
        char arr[100];
        char *p = gets(arr);   //p指针指向arr数组的首地址，相当于将arr数组的首地址赋值给p
        printf("%s",p);
        return 0;
    }

![20190525214625871.png][]

**2.puts()**

> **格式**：int puts(const char \*);
> 
> **功能**：标准设备输出s字符串，在输出完成后自动输出一个'\\n'
> 
> **参数**：s 字符串首地址
> 
> **返回值**：成功    非负数
> 
>                失败    -1

#include <stdio.h>
    int main()
    {
        char arr[100];
        int n;
        gets(arr);
        n = puts(arr);
        printf("printf输出:%s,puts的返回值:%d",arr,n);
        return 0;
    }

![20190525214215611.png][]

**3.fgets()**

> **格式**：char  \*fgets(char \*s,int size,FILE\*stream);
> 
> **功能**：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行符，读到文件结尾，或是已读了size-1个字符为止，最后会自动加上字符'\\0'作为字符串结束标志
> 
> **参数**：s 字符串
> 
>           size  指定最大读取字符串的长度（size-1）
> 
>           stream  文件指针，如果读键盘输入的字符串，固定写为stdin
> 
> **返回值**：成功  读到的字符串
> 
>               读到文件尾或出错  NULL

**fges()会将回车也当做一个字符输入**

#include <stdio.h>
    int main()
    {
       char arr[100];
       fgets(arr,100,stdin);  //参数:字符指针，大小，输入流
       printf("%s",arr);
       return 0;
    }

![20190526204542883.png][]

如果输入的大小**小于**原始指针对应区域的大小，会在**字符串输入完成后自动加上\\n\\0**

#include <stdio.h>
    int main()
    {
       char arr[10];
       fgets(arr,10,stdin);  //参数:字符指针，大小，输入流
       printf("%s",arr);
       return 0;
    }

![20190526204656570.png][]

如果输入的大小等于原始指针对应区域的大小，会自动加上\\0，而不会加上\\n

![20190526205119403.png][]

**4.fputs()**

> **格式**：int fputs（const chat \*str,FILE \*stream）;
> 
> **功能**：将str所指定的字符串写入到stream所指定的文件，字符串结束符\\0不写入文件中
> 
> **参数**：str  字符串
> 
>            stream   文件指针，如果把字符串输出到屏幕，固定写为stdout
> 
> **返回值**：成功 0
> 
>               失败  -1
> 
> **注：fputs是puts的文件操作版本，但fputs不会自动输出一个\\n**

#include <stdio.h>
    int main()
    {
       char arr[10];
       gets(arr);
       printf("fputs输出结果:(不会自动换行)\n");
       fputs(arr,stdout);
       printf("puts输出结果:(会自动换行)\n");
       puts(arr);
       return 0;
    }

![20190526210714121.png][]

**5.strlen()**

> **格式**：size\_t strlen(const char \*str);
> 
> **功能**：计算指定字符串的长度，不包含字符串结束标志'\\0'
> 
> **参数**：s  字符串首地址
> 
> **返回值**：字符串s的长度，size\_t为unsigned int类型
> 
> **注：strlen是函数，使用时需导入string库，strlen只能计算字符串长度，不能计算字符数组长度**

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "hello";
       int n = strlen(arr);
       printf("字符串的有效长度:%d\n",n);
       printf("字符串的实际长度:%d\n",sizeof(arr)/sizeof(char)); //实际长度加上了字符串结束标志
       return 0;
    }

![20190526212624170.png][]

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "he\0llo";
       int n = strlen(arr);
       printf("字符串的有效长度:%d\n",n);
       printf("字符串的实际长度:%d\n",sizeof(arr)/sizeof(char));
       return 0;
    }

![20190526212837146.png][]

**6.strcpy()**

> **格式**：char \*strcpy（char \*dest,const char \*src）;
> 
> **功能**：把src所指向的字符串复制到dest所指向的空间，'\\0'也会复制过去
> 
> **参数**：dest   目的字符串首地址
> 
>            src     源字符首地址
> 
> **返回值**：成功   返回dest字符串的首地址
> 
>               失败    NULL
> 
> **注**：如果dest的内存空间不够大，可能会造成缓冲溢出的错误情况，使用strcpy函数也要导入string库

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "hello world!";
       char arr1[100];
       strcpy(arr1,arr);
       printf("%s",arr1);
       return 0;
    }

![20190526220207731.png][]

**7.strncpy()**

> **格式**：char \*strncpy(char \*dest,const char \*src,size\_t n);
> 
> **功能**：把src指向字符串的前n个字符复制dest所指向的空间，是否拷贝结束符'\\0'看指定的长度是否包含
> 
> **参数**：dest  目的字符串首地址
> 
>            src    源字符串首地址
> 
>            size\_t  指定需要拷贝的字符串个数
> 
> **返回值**: 成功   返回dest字符串的首地址
> 
>              失败   NULL
> 
> **注：需导入string库，有限拷贝不会将'\\0'拷贝到目标字符串，需要手动加入**

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "hello world";
       char arr1[100];
       strncpy(arr1,arr,5);
       printf("%s\n",arr1);
    }

![20190527093600696.png][]

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "hello world";
       char arr1[100];
       strncpy(arr1,arr,5);
       arr1[5] = '\0';  //或0
       printf("%s\n",arr1);
    }

![2019052709374825.png][]

**8.strcat()**

> **格式**：char \*strcat(char \*dest,const char \*src);
> 
> **功能**：将src字符串连接到dest的尾部，'\\0'也会追加上去
> 
> **参数**：dest   目标字符串首地址
> 
>            src     源字符串首地址
> 
> **返回值**：成功   返回dest字符串的首地址
> 
>               失败   NULL
> 
> **注**：需导入string库

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "hello world";
       char arr1[] = "你好世界！";
       strcat(arr1,arr);
       printf("%s\n",arr1);
    }

![20190527094243368.png][]

**9.strncat()**

> **格式**：char \*strncat（char \*dest,const char \*src,size\_t n）;
> 
> **功能**：将src前n个字符追加到dest的尾部，'\\0'也会追加过去
> 
> **参数**：dest  目的字符串首地址
> 
>            src    源字符串首地址
> 
>            size\_t  指定需要追加的字符串个数
> 
> **返回值**：成功   返回dest字符串的首地址
> 
>               失败   NULL
> 
> **注**：需导入string库

#include <stdio.h>
    #include <string.h>
    int main()
    {
       char arr[] = "hello world";
       char arr1[] = "你好世界！";
       strncat(arr1,arr,5);
       printf("%s\n",arr1);
    }

![2019052709485339.png][]

10.strcmp()

> **格式**：int strcmp(const char \*s1,const char \*s2);
> 
> **功能**：比较s1,s2的大小，比较的是ASCII码大小
> 
> **参数**：s1   字符串1首地址
> 
>            s2   字符串2首地址
> 
> **返回值**：相等    0
> 
>                大于   >0   
> 
>                小于   <0
> 
> **注**：需导入string库，不同操作系统返回值不同，有的是1 0 -1，有的返回的是ASCII码的差值

#include <stdio.h>
    #include <string.h>
    int main()
    {
        char arr1[] = "12345";
        char arr2[] = "1234567";
        char arr3[] = "12345";
        int n1 = strcmp(arr1,arr2);  //arr2ASCII和的大小大于arr1，所以返回值为负数
        int n2 = strcmp(arr1,arr3);  //arr1和arr3相等，返回值为0
        printf("n1 = %d\n",n1);
        printf("n2 = %d\n",n2);
        return 0;
    }

![20190527165727494.png][]

strcmp比较的是\\0前面的有效字符

#include <stdio.h>
    #include <string.h>
    int main()
    {
        char arr1[] = "12345\0addadadasd";
        char arr2[] = "1234\0567";
        char arr3[] = "12345\0dadadadw";
        int n1 = strcmp(arr1,arr2);  //arr2的有效字符是"1234"，所以arr1大于arr2，返回值为正数
        int n2 = strcmp(arr1,arr3);  //arr1和arr3的有效字符都为"12345"，所以返回值为0
        printf("n1 = %d\n",n1);
        printf("n2 = %d\n",n2);
        return 0;
    }

![20190527165937525.png][]

**11.strncmp()**

> **格式**：int strcmp(const char \*s1,const char \*s2,size\_t n);
> 
> **功能**：比较s1，s2前n个字符的大小
> 
> **参数**：s1   字符串1首地址
> 
>            s2   字符串2首地址
> 
>            size\_t  指定需要追加的字符串个数
> 
> **返回值**：相等    0
> 
>                大于   >0   
> 
>                小于   <0
> 
> **注**：需导入string库

#include <stdio.h>
    #include <string.h>
    int main()
    {
        char arr1[] = "hello world";
        char arr2[] = "hello";
        char arr3[] = "helloworld";
        int n1 = strncmp(arr1,arr2,5);  //arr2ASCII前5个字符相等，返回值为0
        int n2 = strncmp(arr1,arr3,6);  //arr1和arr3相差'w',返回值是负的w的ASCII码值
        printf("n1 = %d\n",n1);
        printf("n2 = %d\n",n2);
        return 0;
    }

![20190527170959538.png][]

字母w的ASCII码值为87

![20190527171017122.png][]

**12.sprintf()**

> **格式**：int sprintf(char \*str,const char \*format,...);
> 
> **功能**：根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符'\\0'
> 
> **参数**：str   字符串首地址
> 
>            format  字符串格式，用法和printf一样
> 
> **返回值**：成功   实际格式化的字符个数
> 
>               失败   -1

#include <stdio.h>
    int main()
    {
       int n = 123;
       char arr[] = "hello";
       char dest[100];
       sprintf(dest,"%s %d",arr,n);  //将int型的数据和字符串组合成新的字符串并保存在指定的空间
       printf("%s\n",dest);
       return 0 ;
    }

![20190527172336489.png][]

**13.sscanf()**

> **格式**：int sscanf(const char \*str,const char \*format,...);
> 
> **功能**：从str指定的字符串读取数据，并根据参数format字符串来转换格式化数据
> 
> **参数**：str   字符串首地址
> 
>            format  字符串格式，用法和scanf一样
> 
> **返回值**：成功  参数数目，成功转换的值得个数
> 
>                失败  -1

#include <stdio.h>
    int main()
    {
       int n = 0;
       char arr[100];
       char dest[] = "hello 123";
       sscanf(dest,"%s %d",arr,&n);   //从dest中分别读取字符串和int型数据，int前要加取地址符&，后面用法与scanf一致
       printf("arr:%s\n",arr);
       printf("n:%d\n",n);
       return 0 ;
    }

![20190527173157505.png][]

#include <stdio.h>
    int main()
    {
      int a,b;
      char arr[] = "1+2=";
      int n1 = sscanf(arr,"%d+%d=",&a,&b);
      printf("a=%d,b=%d,a+b=%d\n",a,b,a+b);
      int n2 = sprintf(arr,"%d+%d=%d",a,b,a+b);
      printf("arr:%s\n",arr);
      printf("%d\n",n1);  //成功转换的值得个数，本题为2  b，c
      printf("%d\n",n2);  //实际转换的字符个数，五个字符
      return 0;
    }

![20190527183130312.png][]

**14.strchr()**

> **格式**：char \*strchr(const char \*s,int c);
> 
> **功能**：在字符串s查找字符c出现的位置
> 
> **参数**：s  字符串首地址
> 
>            c  匹配字母（字符）
> 
> **返回值**：成功   返回第一次出现的c地址
> 
>               失败   NULL
> 
> **注**：需导入string库

#include <stdio.h>
    #include <string.h>
    int main()
    {
      char arr[] = "hello";
      char *p = strchr(arr,'l'); //指针p指向查找字符所在的地址
      printf("%s",p);  
      return 0;
    }

![20190527184451855.png][]

#include <stdio.h>
    #include <string.h>
    int main()
    {
      char arr[] = "he哈llo";
      char *p = strchr(arr,'哈'); //指针p指向查找字符所在的地址，因为中文字符是两个字节，所以显示不了完整的中文
      printf("%s",p);
      return 0;
    }

![20190527190753781.png][]

**15.strstr()**

> **格式**：char \*strstr(const char \*haystack,const char \*needle);
> 
> **功能**：在字符串haystack中查找needle出现的位置
> 
> **参数**：haystack   源字符串首地址
> 
>            needle      匹配字符串首地址
> 
> **返回值**：成功   返回第一次出现的needle地址
> 
>               失败   NULL
> 
> **注**：需导入string库

#include <stdio.h>
    #include <string.h>
    int main()
    {
      char arr[] = "he哈llo";
      char *p = strstr(arr,"哈"); //指针p指向查找字符所在的地址
      printf("%s",p);
      return 0;
    }

![20190527190420898.png][]

**16.strtok()**

> **格式**：char \*strtok(char \*str,const char \*delim);
> 
> **功能**：来将字符串分割成一个个片段，当strtok()在字符串中发现参数delim中包含的分割字符时，则会将该字符改为'\\0',当连续出现多个时只替换第一个为'\\0'
> 
> **参数**：str  指向欲分割的字符串
> 
>            delim  为分割字符串中包含的所有字符
> 
> **返回值**：成功  分割后字符串首地址
> 
>               失败   NULL
> 
> **注**：
> 
>  *  需导入string库
>  *  在第一次调用时，strtok必须给予参数s字符串
>  *  往后的调用则将参数s设为NULL,每次调用成功则返回指向被分割出片段的指针
>  *  切割完会破坏原始字符串的样式

#include <stdio.h>
    #include <string.h>
    int main()
    {
      char arr[] = "www.baidu.com";
      char *p = strtok(arr,"."); //第一次切割www\0baidu.com
      printf("%s\n",arr);        //www
      while(p!=NULL){
        printf("%s\t",p);        //
        p = strtok(NULL,".");    //第二次切割www\0baidu\0com 第三次arr中无法切割，p=NULL，循环结束
      }
      printf("\n%s",arr);        //www
      return 0;
    }

![20190527195057989.png][]

17.atoi()

> **格式**：int atoi(const char \*nptr);
> 
> **功能**：atoi()会扫描nptr字符串，跳过前面的空格字符，直到遇到字符或正负号才开始做转换，而遇到非数字或字符串结束符'\\0'才结束转换，并将结果返回返回值
> 
> **参数**：nptr  待转换的字符串
> 
> **返回值**：成功转换后整数
> 
> **注**：需导入stdlib库
> 
> 类似的函数有：
> 
> 1.  atof():把一个小数形式的字符串转换为一个浮点数
> 2.  atol():把一个字符串转换为long类型

#include <stdio.h>
    #include <stdlib.h>
    int main()
    {
      char arr[] = "100he";
      char arr1[] = "he100"; //遇到非数字字符结束转换，所以结果为0
      int n = atoi(arr);
      int n1 = atoi(arr1);
      printf("%d\t%d",n,n1);
      return 0;
    }

![20190527200022337.png][]

[20190525213550831.png]: /images/20220127/5bafd84720694cccb5459717ad7a0195.png
[20190525214625871.png]: /images/20220127/b4fed9ed73d8457b979e3b6eb2fc9cfb.png
[20190525214215611.png]: /images/20220127/5095eed4bbed4f0b9d754ea5213cccbe.png
[20190526204542883.png]: /images/20220127/a65a329567f648eda3f83f831b570216.png
[20190526204656570.png]: /images/20220127/8d1d9436fcde495391c415271d465f64.png
[20190526205119403.png]: /images/20220127/691b08a0213a4951ab277b2e23dd2299.png
[20190526210714121.png]: /images/20220127/b1900050f5a74828a7906e0bb7f061c4.png
[20190526212624170.png]: /images/20220127/ffed54d28a2b4052b66564bb92e8c864.png
[20190526212837146.png]: /images/20220127/aa188760d83e4fec98dfc31122c8ab8b.png
[20190526220207731.png]: /images/20220127/2ba181dfec87432488b950bb7e0cc022.png
[20190527093600696.png]: /images/20220127/fdc3e33dfc954377b5382024d806ee2c.png
[2019052709374825.png]: /images/20220127/7f9bd6ec61ee4d819412760d70c3d81b.png
[20190527094243368.png]: /images/20220127/5e79b281bb3440ebb8df7908ac8d4188.png
[2019052709485339.png]: /images/20220127/eb4325bc140e4aeb949dfb34e108ff84.png
[20190527165727494.png]: /images/20220127/e9dc2e1ed9f446d3a8a7098c06fa216e.png
[20190527165937525.png]: /images/20220127/0e1c426c84df4c85b8bb86ad99653440.png
[20190527170959538.png]: /images/20220127/7b53c062cf2543fb8fae4d084b231b09.png
[20190527171017122.png]: /images/20220127/d0a165a8159f4cddb1792d049257488d.png
[20190527172336489.png]: /images/20220127/2305ad08a9664a6c87088c5de0521836.png
[20190527173157505.png]: /images/20220127/41ada86c7b92400b96a24d1c5d1bd7c2.png
[20190527183130312.png]: /images/20220127/e1ae327188aa402e98a3a7decf2525e9.png
[20190527184451855.png]: /images/20220127/e8da9fe3b2ff496da8daa7f44e0f4413.png
[20190527190753781.png]: /images/20220127/f12db953b8f3472a98890b4038227e66.png
[20190527190420898.png]: /images/20220127/774bf5d965ee456dadc239a78744be88.png
[20190527195057989.png]: /images/20220127/da5d1e5447b3419fa22ec8799b568a45.png
[20190527200022337.png]: /images/20220127/25198639f8074c1ea142c3a479994281.png