【C语言】字符函数和字符串函数（1）

#国庆发生的那些事儿#

大家好，我是苏貝，本篇博客带大家了解字符函数和字符串函数，如果你觉得我写的还不错的话，可以给我一个赞吗，感谢❤️

目录

• 1.本章重点
• 2. strlen
• • 2.1函数介绍
  • 2.2 模拟实现
• 3. strcpy
• • 3.1 函数介绍
  • 3.2 模拟实现
• 4.strcat
• • 4.1 函数介绍
  • 4.2 模拟实现
• 5. strcmp
• • 5.1 函数介绍
  • 5.2 模拟实现
• 6.strncpy
• • 6.1 函数介绍
  • 6.2 模拟实现
• 7.strncat
• • 7.1 函数介绍
  • 7.2 模拟实现
• 8.strncmp
• • 8.1 函数介绍
  • 8.2 模拟实现
• 9.strstr
• • 9.1 函数介绍
  • 9.2 模拟实现
• 10.strtok
• 11.strerror
• • 11.1 函数介绍
  • 11.2 perror

1.本章重点

• 求字符串长度
  strlen
• 长度不受限制的字符串函数
  strcpy
  strcat
  strcmp
• 长度受限制的字符串函数介绍
  strncpy
  strncat
  strncmp
• 字符串查找
  strstr
  strtok
• 错误信息报告
  strerror

以上函数的头文件都为

2. strlen

2.1函数介绍

size_t strlen ( const char * str );

注意：
1.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
2.参数指向的字符串必须要以 ‘\0’ 结束，否则函数返回值为随机值
3.注意函数的返回值为size_t，是无符号的（ 易错 ）
点击该链接继续了解strlen

问：下面代码输出的结果是什么？

int main(){const char* str1 = "abcdef";const char* str2 = "bbb";if (strlen(str2) - strlen(str1) > 0){printf("str2>str1\n");}else{printf("srt1>str2\n");}return 0;}

答案：str2>str1
这和你想的是否一样？其实这蕴含的知识点在注意的第三条，函数的返回值为size_t，是无符号的，所以strlen(str2) 和 strlen(str1)的返回值都是无符号的，无符号数-无符号数=无符号数>=0，又strlen(str2) =3不等于 strlen(str1)=6，所以结果>0,因此输出的是str2>str1

2.2 模拟实现

strlen的模拟实现在之前就有写过，如果感兴趣的话，可点击下方链接直接跳转
自定义实现strlen函数的3种方法

3. strcpy

3.1 函数介绍

char* strcpy(char * destination, const char * source )

strcpy函数的作业是拷贝字符串，即将源字符串拷贝到目标空间中，拷贝时会将源字符串中的 ‘\0’ 一起拷贝。所以目标空间必须可以改变，且其大小>=源字符串（包括’\0’）。函数的参数有2个，第一个是目标空间的起始地址，第二个是源字符串的起始地址，类型都为char *，又因为strcpy函数不会改变源字符串的内容，所以char * source左边用const修饰。函数的返回值是目标空间的起始地址，所以为char *

示例1：
源字符串必须要有’\0’,否则会一直访问arr2后面的元素直至找到’\0’，可能会越界，造成程序运行异常，如下：

int main(){char arr1[20] = "xxxxxxxxxx";char arr2[] = { 'a','b','c' };strcpy(arr1, arr2);printf("%s", arr1);return 0;}

示例2：
目标空间必须可变，否则会造成程序运行异常，”abcdefg”是常量字符串，不可更改，p存储的是字符串的首元素地址即a的地址

int main(){char* p = "abcdefg";char arr2[] = "hello";strcpy(p, arr2);printf("%s", p);return 0;}

示例3：
会将源字符串中的 ‘\0’ 拷贝到目标空间。

int main(){char arr1[20] = "xxxxxxxxx";char arr2[] = "hello";strcpy(arr1, arr2);printf("%s", arr1);return 0;}

总结：
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。

3.2 模拟实现

my_strcpy函数参数依旧是2个，返回值仍然是目标空间的初识地址，所以char* my_strcpy(char * str1, const char * str2 )。下面开始拷贝，用while循环，当 * str2为’\0’时退出循环，否则将str2指针指向的值赋给str1指向的值，str1++，str2++。当退出循环时，* str2指向的是’\0’，再将’\0’赋给 * str1。

char* my_strcpy(char* str1, const char* str2){char* ret = str1;while (*str2){*str1 = *str2;str1++;str2++;}*str1 = '\0';return ret;}

我们发现，上面代码完全可以简化成下述代码：while循环中，str1和str2的自增都是后置++，即先使用再自增，将str2指针指向的值赋给str1指向的值，再自增。等到 * str2==‘\0’时，也会将’\0’赋值给*str1，两指针再自增，退出循环

char* my_strcpy(char* str1, const char* str2){char* ret = str1;//断言，如果str1或str2中有空指针，会在运行时报错并会显示错误在第几行//头文件为assert(str1 && str2);while (*str1++ = *str2++);return ret;}int main(){char arr1[20] = "xxxxxxxxxx";char arr2[] = "hello";my_strcpy(arr1, arr2);printf("%s", arr1);return 0;}

4.strcat

4.1 函数介绍

char * strcat ( char * destination, const char * source );

追加函数，即将源字符串追加到目标字符串后。比如目标字符串为“hello”，源字符串为“world”，使用strcat函数后，目标字符串变为“helloworld”。函数有2个参数，第一个是目标字符串的起始地址，第二个是源字符串的起始地址，类型都为char *，又因为strcat函数不会改变源字符串的内容，所以char * source左边用const修饰。函数的返回值是目标空间的起始地址，所以为char *。源字符串的第一个字符将会覆盖目标字符串末尾的’\0’。

和strcpy函数相似，因为都需要访问源字符串，所以源字符串必须以’\0’结束，以免越界。目标空间也必须足够大，能容纳下源字符串的内容。目标空间必须可修改。

示例1：

int main(){char arr1[20] = "hello";char arr2[] = "world";strcat(arr1, arr2);printf("%s", arr1);return 0;}

示例2：
自己追加自己，虽然这可行，但最好还是不要这样写

int main(){char arr1[20] = "hhh";strcat(arr1, arr1);printf("%s", arr1);return 0;}

总结：
1.源字符串必须以 ‘\0’ 结束，在拷贝时将’\0’也拷贝过去
2.目标空间必须足够大，能容纳下源字符串的内容。
3.目标空间必须可修改。
4.目标空间中必须有’\0’，保证能找到目标空间的末尾
5.字符串可以自己追加自己

4.2 模拟实现

在模拟实现之前，我们想到strcat函数是先找到目标空间的末尾即’\0’位置处，再将源字符串的字符逐个追加到目标空间中，包括源字符串的’\0’，追加的第一个字符会覆盖目标空间原本的’\0’。所以我们模拟实现的思路与它一致，先找到目标空间的末尾，只需用while循环，当 * str1==’\0’时退出循环，就找到了目标空间的末尾。第二步，追加，与strcpy相似，上面有详细介绍，这里就不再赘述了

char* my_strcat(char* str1, const char* str2){char* ret = str1;assert(str1 && str2);//1.找到目标空间的'\0'while (*str1)str1++;//2.追加while (*str1++ = *str2++);return ret;}int main(){char arr1[20] = "hello";char arr2[] = "world";my_strcat(arr1, arr2);printf("%s", arr1);return 0;}

写完上面代码后，我们不禁想起来strcat函数还能自己追加自己，那我们写的这串代码可以吗？答案是不可以。刚开始时，str1和str2都指向首元素h

在找到目标空间的’\0’后，str1指向’\0’

开始追加，将 * str2赋值给 * str1，所以str1指向的内容变为h

继续追加，当str2指向下图所在位置时，该位置的元素已经从’\0’变为h，再将h赋值给 * str1，所以整个过程中 * str1都不会被赋值为’\0’，所以会一直循环下去，程序会崩溃

5. strcmp

5.1 函数介绍

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

strcmp是string compare的缩写，即字符串比较，不过不是比较长度，而是比较对应位置上字符的大小(ASCII码值)。strcmp函数的参数是两字符串的首元素地址。若 * str1> * str2，返回一个正数；若相等，返回0；若 * str1< * str2，返回一个负数。比如用strcmp函数比较字符串“abcdefg”和“abqa”，第一二个位置上字符的大小相等，比较第3个字符的大小，ASCII码值中c<q，返回一个负数，不用再比较“fefg”和“a”的大小。因为不会改变arr1和arr2的内容，所以用const修饰char * str1.2

int main(){char arr1[] = "abc";char arr2[] = "abaa";char arr3[] = "abc";char arr4[] = "abq";int ret1 = strcmp(arr1, arr2);int ret2 = strcmp(arr1, arr3);int ret3 = strcmp(arr1, arr4);printf("%d %d %d", ret1, ret2, ret3);return 0;}

5.2 模拟实现

strcmp函数的原理很简单，就是从两个字符串第一位开始比，若相同则比下一位，不同就返回值。来模拟实现，当 * str1和 * str2相等时，用while循环，相等则str1和str2都自增。如果进入循环时有一个的值为’\0’，那么另一个的值也为’\0’，说明两个字符串完全相等，返回0；若因为两个值不同退出循环，比较两值大小

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;elsereturn -1;}

上面代码也可简化为：两值相减，若左>右，则返回正数；反正返回一个负数

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;}

6.strncpy

上面我们了解了strcpy,strcat,strcmp三个函数，它们是长度不受限制的字符串函数。下面我们再来了解一下长度受限制的3个字符串函数strncpy,strncat,strncmp

6.1 函数介绍

char * strncpy ( char * destination, const char * source, size_t num );
strncpy和strcpy函数及其相似，只不过前者多了一个参数size_t num，表示只从源字符串中拷贝前面num个字符到目标空间中

那么拷贝的时候是否会拷贝‘\0’呢？不会。如下图，拷贝的时候没有拷贝‘\0

int main(){char arr1[20] = "xxxxxxxxxxxxx";char arr2[] = "hello";strncpy(arr1, arr2, 3);printf("%s", arr1);}

那如果num>源字符串的长度怎么办呢？拷贝完源字符串之后，在目标的后边追加0，直到num个

int main(){char arr1[20] = "xxxxxxxxxxxxx";char arr2[] = "hello";strncpy(arr1, arr2, 8);printf("%s", arr1);}

6.2 模拟实现

char* my_strncpy(char* str1, const char* str2, size_t num){char* ret = str1;assert(str1 && str2);int i = 0;for (i = 0; i < num; i++){*str1++ = *str2++;}return ret;}

7.strncat

7.1 函数介绍

char * strncat ( char * destination, const char * source, size_t num )；
它与strcat相比，也只是多了一个参数 size_t num，表示只从源字符串中追加前面num个字符和’\0’到目标空间中

当num

int main(){char arr1[20] = "abc\0xxxxxxxx";char arr2[] = "hello";strncat(arr1, arr2, 3);printf("%s", arr1);return 0;}

当num>arr2的大小呢？多余的不再起作用

7.2 模拟实现

char* my_strncat(char* str1, const char* str2, size_t num){char* ret = str1;assert(str1 && str2);//1.找到目标空间的末尾即'\0'位置while (*str1)str1++;//2.追加int i = 0;for (i = 0; i < num; i++){*str1++ = *str2++;}*str1 = '\0';return ret;}

8.strncmp

8.1 函数介绍

int strncmp ( const char * str1, const char * str2, size_t num );
它与strcmp相比，也只是多了一个参数 size_t num，表示只比较两字符串前num个字符的大小

int main(){char arr1[] = "abcdefg";char arr2[] = "abcdqqq";char arr3[] = "abbb";int ret1 = strncmp(arr1, arr2, 5);int ret2 = strncmp(arr1, arr2, 3);int ret3 = strncmp(arr1, arr3, 3);printf("%d %d %d", ret1, ret2, ret3);return 0;}

8.2 模拟实现

int my_strncmp(char* str1, char* str2, size_t num){assert(str1 && str2);int i = 0;int flag = 0;for (i = 0; i < num; i++){if (*str1++ == *str2++){flag++;continue;}elsebreak;}if (flag == num)return 0;elsereturn *str1 - *str2;}

9.strstr

9.1 函数介绍

const char * strstr ( const char *str1, const char * str2);
若str2是str1的子串，返回str1中str2第一次出现的地址，如果str2不是str1的子串，就返回NULL

int main(){char arr1[] = "abbbcd";char arr2[] = "bbc";char arr3[] = "babc";const char* p1 = strstr(arr1, arr2);const char* p2 = strstr(arr1, arr3);if (p1 == NULL)printf("找不到\n");elseprintf("%s\n", p1);if (p2 == NULL)printf("找不到\n");elseprintf("%s\n", p2);return 0;}

9.2 模拟实现

模拟实现的函数的形参为char* str1,t char* str2，因为指向的内容不变，所以用const修饰。返回值是指针，类型为char * 。如果我们想让str1,str2指向的位置不变，那我们定义指针变量cp用来记录开始匹配的位置，指针变量s1，s2遍历str1，str2指向的字符串。让cp=str1。先考虑特殊情况，当str指向的内容为0时，返回str1指向的字符串地址。

使用while循环，当 * str1== 0时退出循环，让s1指向cp指向的位置,s2指向str2指向的位置。此时5个指针变量指向对象的图如下：

*s1！= * s2，cp++，s1== cp，s2==str2。

此时 * s1== * s2，s1++，s2++， 又* s1== * s2，s1++，s2++， * s1！= * s2，cp++，s1== cp，s2==str2。

此时 * s1== * s2，s1++，s2++， 又* s1== * s2，s1++，s2++，又 * s1== * s2，s1++，s2++，此时 * s2==0，表示arr2是arr1的子串，返回cp指针

变成代码：

const char* my_strstr(const char* str1, const char* str2){assert(str1 && str2);//str1,str2让其指向的位置不变const char* cp = str1;//记录开始匹配的位置const char* s1;//遍历str1指向的字符串const char* s2;//遍历str2指向的字符串if (*str2 == '\0')return str1;while (*cp){s1 = cp;s2 = str2;while (*s1 && *s2 && *s1 == *s2){s1++;s2++;}if (*s2 == '\0')return cp;cp++;}return NULL;}

这是一种暴力求解的方式，不够高效，可以了解一下KMP算法

10.strtok

char * strtok ( char * str, const char * sep );
strtok是个字符串查找函数，它的功能是查询一个字符串中的被我们自己选定的分隔符（如@ . ）。

要点：
1.sep参数是个字符串，定义了用作分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记开头的指针。比如：要查找的字符串为“abc@aaa”，分隔符为“@”，调用strtok函数后，找到字符”@“并将其用’\0’覆盖，再返回a的地址。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
4.strtok函数的第一个参数不为 NULL时 ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5.strtok函数的第一个参数为 NULL时 ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
6.如果字符串中不存在更多的标记，则返回 NULL 指针

示例1：

int main(){char arr[] = "666666@qq.com";char str[20] = { 0 };strcpy(str, arr);char* p = "@.";char* s = strtok(str, p);//1printf("%s\n", s);s = strtok(NULL, p);//2printf("%s\n", s); s = strtok(NULL, p);//3printf("%s\n", s);return 0;}

讲解：
首先我们创建一个新的可修改的字符数组str，并将arr数组的内容拷贝到数组str中。因为strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。题目中将’@.‘作为分隔符，第一次调用strtok函数时，是将数组str的首元素地址作为第一个实参，意思是从该地址开始往后找，知道找到第一个’@‘或者’.‘，然后找到了字符6后面的字符’@‘，并将其用’\0’覆盖，返回开头的即第一个字符6的地址。打印时遇到‘\0’停止，所以只打印前面的666666；同时因为strtok函数的第一个参数不为 NULL ，strtok函数将保存第一个标记在字符串中的位置。
再一次调用strtok函数，NULL作为第一个实参，函数将在从一个字符串中被保存的位置即原先是字符’@‘的位置开始，查找下一个标记，找到了字符q后面的字符’.‘，并将其用’\0’覆盖，返回开头的即第一个字符q的地址。打印时遇到 ‘\0’ 停止，所以只打印前面的qq；函数将保存这一个标记在字符串中的位置。
又一次调用strtok函数，NULL作为第一个实参，函数将在从一个字符串中被保存的位置即原先是字符’.‘的位置开始，查找下一个标记，结果没有下一个标记，返回开始的地址即字符c的地址，打印时遇到 ‘\0’ 停止，所以只打印前面的com；

示例2：
上面的示例中规定死了只能调用3次strtok函数，那么如果我想打印字符串”abdc@ssss.sss@999“中标记为”@.“时所有的在标记之前的字符该怎么办呢？其实很简单，用for循环即可

int main(){char arr[] = "666666@qq.com";char str[20] = { 0 };strcpy(str, arr);char* p = "@.";for (char* s = strtok(str, p); s != NULL; s = strtok(NULL, p)){printf("%s\n", s);}return 0;}

11.strerror

11.1 函数介绍

char * strerror ( int errnum );
strerror函数是将错误码翻译成错误信息，返回错误信息的字符串的初始地址。其实，不管是在设计库函数还是在正规的软件设计过程中，都会设计错误码。比如我们在上网时有时会看到404，这就是一个错误码，表示你访问的页面不存在。当我们在C语言中使用库函数，如果发生错误，就会将错误码放在全局变量errono中。错误码可能是0，1，2……

示例1：
让我们来了解一下0-10的错误码分别代表什么意思

int main(){int i = 0;for (i = 0; i <= 10; i++){//因为strerror函数返回的是错误信息的字符串的起始地址，所有用%s打印printf("%d:%s\n", i, strerror(i));}return 0;}

示例2：
当我们想用fopen函数打开一个文件夹中的一个文件，但该文件夹中没有该文件，那么指针变量pf为空指针。我们上面有讲到，在C语言中使用库函数时如果发生错误，就会将错误码放在全局变量errono中，将errno作为strerror函数的实参，返回值以%s打印可得到错误信息

int main(){FILE* pf = fopen("add.txt", "r");if (pf == NULL){printf("打开文件失败，原因：%s\n", strerror(errno));}elseprintf("打开文件成功\n");return 0;}

11.2 perror

是否只有借助strerror才能知道错误信息呢？其实不然，还有一个函数也可以，那就是perror函数，它的功能是直接打印错误码所对应的错误信息，你可以理解为perror==printf+strerror

perror在打印时的规则：
perror函数后面可以任意写文字、字符……，（如下面代码的”打开文件失败“）这些被称为自定义信息，perror会在打印完自定义信息后加冒号和一个空格，再打印错误信息（如：自定义信息： xxxxxxxxx）

int main(){FILE* pf = fopen("add.txt", "r");if (pf == NULL){perror("打开文件失败");}elseprintf("打开文件成功\n");return 0;}

好了，那么本篇博客就到此结束了，如果你觉得本篇博客对你有些帮助，可以给个大大的赞吗，感谢看到这里，我们下篇博客见❤️