字符串函数

744
68 阅读12分钟

重点

重点介绍处理字符和字符串的库函数的使用和注意事项

  • 求字符串长度
  1. strlen
  • 长度不受限制的字符串函数
  1. strcpy
  2. strcat
  3. strcmp
  • 长度受限制的字符串函数
  1. strncpy
  2. strncat
  3. strncmp
  • 字符串查找
  1. strstr
  2. strtok
  • 错误信息报告
  1. strerror
  1. memcpy
  2. memmove
  3. memset
  4. memcmp
  5. memset

1.函数介绍

1.1 strlen

求字符串长度，返回类型size_t

 size_t strlen ( const char * str );
  • 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。
  • 参数指向的字符串必须要以 '\0' 结束。
  • 注意函数的返回值为size_t，是无符号的(unsigned int)
  • 学会strlen函数的模拟实现

示例1：

 #include <stdio.h>
 int main()
 {
     
     char arr[]={"abcdef"};
     int len=strlen(arr);
     printf("%d\n",len);//6
     
     
     //若没有'\0'，len将会是随机值
     char arr[]={'h','h','h','h'};
     [][][][][h][h][h][h][][][][]...[\0]
     int len=strlen(arr);//随机值
     printf("%d\n",len);
     turn 0;
 }

示例：

 #include <stdio.h>
 int main()
 {
     if (strlen1(""bbb"") - strlen2("abcdef") > 0)//错误，返回值为无符号整型，相减是一个很大的数
     if (strlen1(""bbb"") < strlen2("abcdef") > 0)//正确写法   
     {
         printf("str2>str1\n");
     }
     else
     {
         printf("srt1>str2\n");
     }
     return 0;
 }

结果：srt1>str2

模拟实现strlen

  • 计数器方法
  • 指针-指针方法
  • 递归方法
 #include <stdio.h>
 #include<assert.h>
 size_t my_strlen(const char* ch)//const修饰所指向的内容不可被修改
 {
     assert(ch);
     int count = 0;
     while (*ch != '\0')
     {
         count++;
         ch++;
     }
     return count;
 }
 int main()
 {
     char ch[] = "abcdef";
     int len=my_strlen(ch);
     printf("%d", len);
     return 0;
 }

长度不受限制函数

1.2 strcpy

拷贝，返回类型char*

 char* strcpy(char * destination, const char * source );
  • Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point).
  • 源字符串必须以 '\0' 结束。
  • 会将源字符串中的 '\0' 拷贝到目标空间。拷贝到‘\0’就结束了
  • 目标空间必须足够大，以确保能存放源字符串。
  • 目标空间必须可变。
  • 学会模拟实现。

例如：

 #include<stdio.h>
 int main()
 {
     char name[20]={0};
     strcpy(name,"zhangsan");
     printf("%s\n",name);
     return 0;
 }
 ​
 //打印结果：zhangsan
 ​
 //情况1：直接赋值  err
 #include<stdio.h>
 int main()
 {
     char name[20]={0};
     name="zhangsan";//err,name数组名是地址，地址是一个常量值，不能被赋值
     printf("%s\n",name);
     return 0;
 }
 ​
 ​
 //情况2：提前遇到'\0'
 #include<stdio.h>
 int main()
 {
     char name[20]={0};
     strcpy(name,"zhang\0san");
     printf("%s\n",name);
     return 0;
 }
 ​
 //打印结果：zhang  将\0也拷贝了
 ​
 //情况3：拷贝的东西里没有'\0'
 #include<stdio.h>
 int main()
 {
     char name[20] = { 0 };
     char arr[] = { 'b','i','t' };//会出错，无'\0'不知道什么时候停止
     strcpy(name, arr);
     printf("%s\n", name);
     return 0;
 }
 //拷贝时要保证有'\0'
 ​
 //情况4：目标空间不够大
 #include<stdio.h>
 int main()
 {
     char name[3] = { 0 };
     const char arr[] = "abcdef";
     strcpy(name, arr);
     printf("%s\n", name);
     return 0;
 }
 //程序崩溃，放不下，形成了越界访问
 ​
 //情况5：目标空间必须可变
 #include<stdio.h>
 int main()
 {
     char* p = "abcdef";//常量字符串不可改
     char arr[] = "hhh";
     strcpy(p, arr);//报错：目标区不可修改
     printf("%s\n", p);
     return 0;
 }

strcpy模拟实现：

 //一：
 #include<stdio.h>
 char* my_strcpy(char* arr2, char* arr1,int sz)
 {
     int i = 0; 
     for (i = 0; i < sz-1; i++)
     {
         arr2[i] = arr1[i];
     }
     return arr2;
 }
 int main()
 {
     char arr1[] = "abcdef";
     char arr2[20] = { 0 };
     int sz = sizeof(arr1) / sizeof(arr1[0]);
     my_strcpy(arr2, arr1,sz);
 ​
     printf("%s\n", arr2);//abcdef
     return 0;
 }
 //二：
 #include<stdio.h>
 #include<asssert.h>
 void my_strcpy(char* arr2, char* arr1)
 {
     assert(arr2);
     assert(arr1);
     while (*arr1)
     {
         *arr2++ = *arr1++;
     }
     *arr2 = *arr1;//\0
 }
 int main()
 {
     char arr1[] = "abcdef";
     char arr2[20] = { 0 };
     int sz = sizeof(arr1) / sizeof(arr1[0]);
     my_strcpy(arr2, arr1);
 ​
     printf("%s\n", arr2);//abcdef
     return 0;
 }
 ​
 //三：
 #include<stdio.h>
 #include<asssert.h>
 char* my_strcpy(char* arr2, char* arr1)
 {
     assert(arr2&&arr1);
     char* ret = arr2;
     while (*arr1)
     {
         *arr2++ = *arr1++;
     }
     *arr2 = *arr1;//\0
     return ret;
 }
 int main()
 {
     char arr1[] = "abcdef";
     char arr2[20] = { 0 };
     int sz = sizeof(arr1) / sizeof(arr1[0]);
     my_strcpy(arr2, arr1);
 ​
     printf("%s\n", arr2);//abcdef
     return 0;
 }
 ​
 //四：简化
 #include<stdio.h>
 #include<asssert.h>
 char* my_strcpy(char* arr2, char* arr1)
 {
     assert(arr2&&arr1);
 ​
     char* ret = arr2;
     while (*arr2++ = *arr1++)//既进行了赋值，又进行了循环条件的判断，到'\0'就停了
     {
         ;
     }
     return ret;
 }
 int main()
 {
     char arr1[] = "abcdef";
     char arr2[20] = { 0 };
     int sz = sizeof(arr1) / sizeof(arr1[0]);
     my_strcpy(arr2, arr1);
     printf("%s\n", arr2);//abcdef
     return 0;
 }
 ​

1.3 strcat

字符串追加，与strcpy类比，返回类型char*

 char * strcat ( char * destination, const char * source );
  • 源字符串必须以 '\0' 结束。
  • 目标空间必须有足够的大，能容纳下源字符串的内容。
  • 目标空间必须可修改。
  • 字符串自己给自己追加，如何？ ——不可自己给自己追加
 #include<stdio.h>
 int main()
 {
     char arr1[20] = "hello ";
     strcat(arr1, "world");
     printf("%s\n", arr1);
     return 0;
 }

会在追加末尾补上\0

strcat模拟实现：

1.先找到目标空间的末尾‘\0’

2.拷贝

 #include<stdio.h>
 char* my_strcat(char* dest, const char* src)
 {
     while (*dest != '\0')
     {
         dest++;
     }
     while (*dest++ = *src++)
     {
         ;
     }
     return 0;
 }
 int main()
 {
     char arr1[20] = "hello ";
     my_strcat(arr1, "world");
     printf("%s\n", arr1);
     return 0;
 }

字符串自己给自己追加——err

 #include<stdio.h>
 char* my_strcat(char* dest, const char* src)
 {
     while (*dest != '\0')
     {
         dest++;
     }
     while (*dest++ = *src++)
     {
         ;
     }
     return 0;
 }
 int main()
 {
     char arr1[20] = "hello ";
     my_strcat(arr1, arr1);
     printf("%s\n", arr1);
     return 0;
 }

自己给自己追加时，会把自己本身破坏，没有\0了，会陷入死循环，程序崩溃。

1.4 strcmp

比较大小，返回类型是整型

 int strcmp ( const char * str1, const char * str2 );

  • This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.

  • 标准规定：

    • 第一个字符串大于第二个字符串，则返回大于0的数字

    • 第一个字符串等于第二个字符串，则返回0

    • 第一个字符串小于第二个字符串，则返回小于0的数字

      那么如何判断两个字符串？

 int main()
 {
     char arr1[20] = "zhangsahaohan";
     char arr2[20] = "linjunjie";
     //比较一下两个字符串是否相等
     //这样判断是否正确？---err
     if (arr1 == arr2)//arr1，arr2是数组名，是首元素地址，比较结果必然不相等
                      //这里比较的是地址而不是内容
     {
         printf("=\n");
     }
     else
         printf("!=\n");
     return 0;
 }

正确写法：

 #include<stdio.h>
 #include<string.h>
 ​
 int main()
 {
     char arr1[20] = "zhangsahaohan";
     char arr2[20] = "linjunjie";
     //比较一下两个字符串是否相等
     int s = strcmp(arr1, arr2);
     if (s == 0)
         printf("=\n");
     else if (s > 0)
         printf("arr1>arr2");
     else
         printf("arr1<arr2");
     return 0;
 }
 ​
 //输出结果：arr1>arr2

strcmp模拟实现：

 //每个元素比较大小
 #include<stdio.h>
 #include<string.h>
 #include<assert.h>
 int my_strcmp(const char*str1,const char*str2)//只比较，不修改
 {
     assert(str1&&str2);
     while (*str1==*str2)
     {
         if (*str1 == '\0')
             return 0;
         str1++;
         str2++;
     }
     if (*str1 > *str2)
         return 1;
     else
         return -1;
 }
 int main()
 {
     char arr1[20] = "hhhhhhz";
     char arr2[20] = "hhhhhhh";
     //比较一下两个字符串是否相等
     int s = my_strcmp(arr1, arr2);
     if (s == 0)
         printf("=\n");
     else if (s > 0)
         printf("arr1>arr2");
     else
         printf("arr1<arr2");
     return 0;
 }
 ​
 //结果：arr1>arr2
 ​
 ​
 //简化
 #include<stdio.h>
 #include<string.h>
 #include<assert.h>
 int my_strcmp(const char*str1,const char*str2)//只比较，不修改
 {
     assert(str1&&str2);
     while (*str1==*str2)
     {
         if (*str1 == '\0')
             return 0;
         str1++;
         str2++;
     }
     return (*str1 - *str2);
     
 }
 int main()
 {
     char arr1[20] = "hhhhhz";
     char arr2[20] = "hhhhhhh";
     //比较一下两个字符串是否相等
     int s = my_strcmp(arr1, arr2);
     if (s == 0)
         printf("=\n");
     else if (s > 0)
         printf("arr1>arr2");
     else
         printf("arr1<arr2");
     return 0;
 }

长度受限制的函数（相对安全）

1.5 strncpy

 int strcmp ( const char * str1, const char * str2 );
  • Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
  • 拷贝num个字符从源字符串到目标空间。
  • 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
  • num是拷贝的长度（单位字节）
 #include<stdio.h>
 int main()
 {
     char name[20] = { 0 };
     strncpy(name, "zhangsan",5);
     printf("%s\n", name);
     return 0;
 }
 ​
 //输出：zhang

1.6 strncat

 char * strncat ( char * destination, const char * source, size_t num );
  • Appends the first num characters of source to destination, plus a terminating null-character.
  • If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.
  • num是追加长度（单位字节）
 #include<stdio.h>
 int main()
 {
     char arr1[20] = "hello ";
     strncat(arr1, "world !",5);
     printf("%s\n", arr1);
     return 0;
 }

strncat追加会在追加的末尾补上 \0 ,如图：

屏幕截图 2024-11-25 150759.png

1.7 strncmp

 int strncmp ( const char * str1, const char * str2, size_t num );
  • 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
  • num是比较的长度（单位字节）
 #include<stdio.h>
 #include<string.h>
 ​
 int main()
 {
     char arr1[20] = "abcde";
     char arr2[20] = "abc";
     //比较一下两个字符串是否相等
     int s = strncmp(arr1, arr2,3);
     if (s == 0)
         printf("=\n");
     else if (s > 0)
         printf("arr1>arr2");
     else
         printf("arr1<arr2");
     return 0;
 }
 ​
 //打印结果：=
 ​
 #include<stdio.h>
 #include<string.h>
 ​
 int main()
 {
     char arr1[20] = "abcde";
     char arr2[20] = "abc";
     //比较一下两个字符串是否相等
     int s = strncmp(arr1, arr2,4);
     if (s == 0)
         printf("=\n");
     else if (s > 0)
         printf("arr1>arr2");
     else
         printf("arr1<arr2");
     return 0;
 }
 ​
 //打印结果：arr1>arr2

字符串查找

1.8 strstr

寻找str1中有没有str2这个字符串

返回类型char*，找到了返回地址，没找到返回空指针NULL

 const char * strstr ( const char * str1, const char * str2 );  
       char * strstr (       char * str1, const char * str2 );
  • Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.
 int main()
 {
     char email[] = "111222333@qq.com";
     char substr[] = "23";
     char* ret=strstr( email, substr);
     if (ret == NULL) {
         printf("不存在\n");
     }
     else
         printf("%s\n", ret);
 ​
 }
 ​
 //打印结果：2333@qq.com
 ​
 int main()
 {
     char email[] = "111222333@qq.com";
     char substr[] = "2c";
     char* ret=strstr( email, substr);
     if (ret == NULL) {
         printf("不存在\n");
     }
     else
         printf("%s\n", ret);
 ​
 }
 ​
 打印如果：不存在

strstr模拟实现

 #include<stdio.h>
 #include<assert.h>
 char* my_strstr(const char* str1, const char* str2)
 {
     assert(str1, str2);
     const char* s1 = str1;
     const char* s2 = str2;
     const char* p = str1;
     while (*p)
     {
         s1 = p;
         s2 = str2;
         while (*s1!='\0'&&*s2!='\0'&& * s1 == *s2)
         {
             s1++;
             s2++;
         }
         if (*s2 == '\0')
         {
             return (char*)p;
         }
         p++;
     }
     return NULL;
 }
 int main()
 {
     char email[] = "111222333@qq.com";
     char substr[] = "23";
     char* ret=my_strstr( email, substr);
     if (ret == NULL) {
         printf("不存在\n");
     }
     else
         printf("%s\n", ret);
     
     return 0；
 }

1.9 strtok

切割字符串

 char * strtok ( char * str, const char * delimiters );
  • sep参数是个字符串，定义了用作分隔符的字符集合
  • 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。
  • strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。）
  • strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
  • strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。
  • 如果字符串中不存在更多的标记，则返回 NULL 指针。
 #include<stdio.h>
 #include<assert.h>
 ​
 int main()
 {
     char* sep = "@.";
     char email[] = "123456789@qq.com";
     
     char cp[30] = { 0 };//使用strtok会改变原字符串
     strcpy(cp, email);
 ​
     char* ret = strtok(cp, sep);
     printf("%s\n", ret);
     
     ret = strtok(NULL, sep);
     printf("%s\n", ret);
     
     ret = strtok(NULL, sep);
     printf("%s\n", ret);
 ​
 ​
     return 0;
 ​
 }
 ​
 //结果：
 //123456789
 //qq
 //com

如果两个分隔符在一起结果是什么？

 #include<stdio.h>
 #include<assert.h>
 ​
 int main()
 {
     char* sep = "@.";
     char email[] = "123456789@@qq.com";
     
     char cp[30] = { 0 };
     strcpy(cp, email);
 ​
     char* ret = strtok(cp, sep);
     printf("%s\n", ret);
 ​
     ret = strtok(NULL, sep);
     printf("%s\n", ret);
 ​
     ret = strtok(NULL, sep);
     printf("%s\n", ret);
 ​
     ret = strtok(NULL, sep);
     printf("%s\n", ret);
 ​
     return 0;
 ​
 }
 ​
 //结果：
 //123456789
 //qq
 //com
 //(null)找不到了
 //两个分隔符就直接跳过去了，只算了一次分隔符

所以代码可以加一个判断，如下：

 #include<stdio.h>
 #include<assert.h>
 ​
 int main()
 {
     char* sep = "@.";
     char email[] = "123456789@@qq.com";
     char cp[30] = { 0 };
     strcpy(cp, email);
 ​
     char* ret = strtok(cp, sep);
     if (ret != NULL)
         printf("%s\n", ret);
 ​
     ret = strtok(NULL, sep);
     if (ret != NULL)
         printf("%s\n", ret);
 ​
     ret = strtok(NULL, sep);
     if (ret != NULL)
         printf("%s\n", ret);
 ​
     ret = strtok(NULL, sep);
     if (ret != NULL)
         printf("%s\n", ret);
     return 0;
 ​
 }

但这种写法太过于冗长，我们改进一下

 #include<stdio.h>
 #include<string.h>
 int main()
 {
     char* sep = "@.";
     char email[] = "123456789@@qq.com";
     char cp[30] = { 0 };
     strcpy(cp, email);
 ​
     char* ret = NULL;
     for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
     {
         printf("%s\n", ret);
     }
     return 0;
 ​
 }

错误信息报告

1.10 strror

错误报告函数，返回类型char*

 char * strerror ( int errnum );

返回错误码所对应的错误信息

例如：

 #include<stdio.h>
 #include<string.h>
 ​
 int main()
 {
     printf("%s\n", strerror(0));
     printf("%s\n", strerror(1));
     printf("%s\n", strerror(2));
     printf("%s\n", strerror(3));
     printf("%s\n", strerror(4));
     printf("%s\n", strerror(5));
     printf("%s\n", strerror(6));
     printf("%s\n", strerror(7));
 ​
     return 0;
 }

返回信息如图：

屏幕截图 2024-11-28 195250.png

 //如果要打开一个文件
 #include<stdio.h>
 #include<string.h>
 #include<errno.h>
 ​
 int main()
 {
 ​
     //errno--C语言设置的一个全局的错误码存放的变量
 ​
     FILE* pf = fopen("test.txt", "r");//找的文件只能放在相应的代码路径
     //想找其他地方的要写成绝对路径
     if (pf == NULL)
     {
         printf("%s", strerror(errno));//将错误码转换成错误信息
         return 1;
         //当main函数返回值是非0时，表示异常退出程序
     }
 ​
     return 0;
 }

该文件不存在，则结果为：

屏幕截图 2024-11-28 195949.png

字符操作

1.字符分类

头文件：#include<ctype.h>

转存失败，建议直接上传图片文件

例如：

 #include<stdio.h>
 #include<ctype.h>
 ​
 int main()
 {
     int a = isspace('w');
         printf("%d", a);
 ​
     return 0;
 }
 ​
 ​

微信图片_20241128210739.jpg

2.字符转换

 int tolower(int c);//大写转小写
 int toupper(int c);//小写转大写

如果输入的不是字母，什么都不变，输出结果与输入结果一样。

 #include<stdio.h>
 #include<ctype.h>
 ​
 int main()
 {
     printf("%c", tolower('C'));
     return 0;
 ​
 }
 ​
 //输出：c
avatar
文章
阅读
粉丝