1. 字符分类函数
2. 字符转换函数
3. strlen的使用和模拟实现
4. strcpy的使用和模拟实现
5. strcat的使用和模拟实现
6. strcmp的使用和模拟实现
7. strncpy函数的使用
8. strncat函数的使用
9. strncmp函数的使用
10. strstr的使用和模拟实现
11. strtok函数的使用
12. strerror函数的使用
1. 字符分类函数
C语言中有⼀系列的函数是专门做字符分类的，也就是⼀个字符是属于什么类型的字符的。
这些函数的使用都需要包含⼀个头文件是 ctype.h
！！！这些函数的参数是 int 类型，必须传入 unsigned char 类型的值，否则行为未定义
！！！如果满足功能要求 就会返回一个非0值 如果不满足就会返回0
例如：下面的用isdigit函数判断是否为十进制数
！！！传入的值必须为数字常量
isdigit会判断其是否为十进制数，如果是，就会返回非0的整数，反之就会出现下面的情况
因此我们也可以用islower跟isupper来判断字母大小写
//练习 将字符串中的小写字母转成大写，其他字符不变
#include<stdio.h>
#include<ctype.h>
int main()
{
int i = 0;
char arr[] = "I am a Student!";
while (arr[i] != '\\0')
{
if (islower(arr[i]))//islower判断字符是否为小写字母
{
arr[i] -= 32;//转换成大写
}
printf("%c", arr[i]);
i++;
}
return 0;
}
这里我们利用islower来判断是否为小写，然后通过大小写ASCLL值之差为32来实现大小写的转换
运行结果为： I AM A STUDENT!
2. 字符转换函数（ctype.h头文件）
C语言提供了2个字符转换函数：
int tolower ( int c );
//将参数传进去的⼤写字⺟转⼩写
//如果参数是小写，原路返回
int toupper ( int c );
//将参数传进去的⼩写字⺟转⼤写
//如果参数是大写，原路返回
上面的代码，我们将小写转大写，是-32完成的效果，有了转换函数，就可以直接使用 tolower 函
数。
#include <stdio.h>
#include <ctype.h>
int main()
{
int i = 0;
char str[] = "Test String.\\n";
char c;
while (str[i]) // 遍历字符串，直到遇到 '\\0'
{
c = str[i];
if (islower(c)) // 判断是否为小写字母
c = toupper(c); // 转为大写
putchar(c); // 输出字符
i++;
}
return 0;
}
运行结果
TEST STRING.
代码优化
这段代码也可以去掉 islower 判断，直接写 c = toupper(c);，因为 toupper 对非小写字母的字符会原样返回
while (str[i])
{
putchar(toupper(str[i]));
i++;
}
3. strlen
#include <string.h>
size_t strlen ( const char * str );
头文件：<string.h>功能：统计字符串中 '\\0' 之前的字符个数（不包含 '\\0' 本身）。
参数：str 是指向要统计的字符串的指针。
返回值：size_t 类型（无符号整数），表示字符串长度。
3.1 代码演示
#include <stdio.h>
#include <string.h>
int main()
{
const char* str = "abcdef";
printf("%zd\\n", strlen(str)); // 输出：6
return 0;
}
使用注意事项：
字符串以 '\\0' 作为结束标志，strlen函数返回的是在字符串中 '\\0' 前面出现的字符个数（不包
含 '\\0' )。
参数指向的字符串必须要以 '\\0' 结束。
注意函数的返回值为 size_t ，是无符号的（ 易错 ）
strlen的使用需要包含头文件 <string.h>
3.2 strlen返回值
#include <stdio.h>
#include <string.h>
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更长，因为无符号数相减的结果永远是非负数，不会得到负数。
如果要修改正确的话，要强制类型转换，如下：
if( (int)strlen("bbb") – (int)strlen("abcdef") > 0 )
3.3 strlen的手动模拟实现
方式1（计数器法）：
//计数器⽅式
int my_strlen(const char * str)
{
int count = 0;
assert(str);
while(*str)
{
count++;
str++;
}
return count;
}
方式二（递归）：
int my_strlen(const char *str)
{
assert(str != NULL);
if (*str == '\\0')
return 0;
else
return 1 + my_strlen(str + 1);
}
方式三（指针-指针）：
int my_strlen(const char *str)
{
assert(str != NULL);
const char *p = str;
while (*p != '\\0')
{
p++;
}
return p – str;
}
原理：两个指向同一数组的指针相减，结果是它们之间的元素个数。
4. strcpy
#include <string.h>
char* strcpy(char * destination, const char * source );
功能：字符串拷贝，拷贝到源头字符串中的 \\0 为止
参数： destination ：指针，指向目的地空间 source ：指针，指向源头数据
返回值： strcpy 函数返回的目标空间的起始地址
4.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[10] = {0};
char arr2[] = "hello";
strcpy(arr1, arr2);
printf("%s\\n", arr1); // 输出：hello
return 0;
}
使用注意事项：
源字符串必须以 '\\0' 结尾：如果 source 没有结束符，strcpy 会一直拷贝，导致越界访问。
会拷贝 '\\0'：目标数组的末尾也会被自动加上 '\\0'，保证拷贝后是合法字符串。
目标空间必须足够大：destination 的大小必须能容纳 source 的所有字符（包括 '\\0'），否则会缓冲区溢出。
目标空间必须可修改：不能传入字符串常量（如 char* p = "abc"; strcpy(p, "def"); 会崩溃）
4.2strcpy的手动模拟实现
//模拟实现strcpy
#include<assert.h>
char* my_strlen(char* dest, char* src)
{
char* ret = dest;
assert(dest && src);
while (*src != '\\0')
{
*dest = *src;
dest++;
src++;
}
*dest = *src;//\\0也要传入
return ret;
}
int main()
{
char arr1[] = "abcdef";
char arr2[20] = "——–";
char*pr = my_strlen(arr2, arr1);
printf("%s\\n", pr);
printf("%s\\n", arr2);
}
优化代码如下：
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
// 保存目标地址起始位置，因为后面dest会移动
char* ret = dest;
// 空指针检查
assert(dest != NULL);
assert(src != NULL);
// 核心拷贝逻辑
// *dest++ = *src++ 会先赋值，再自增
// 赋值结果就是被拷贝的字符，当拷贝到'\\0'时，表达式结果为0，循环结束
while ((*dest++ = *src++))
{
// 循环体为空，所有操作都在条件里完成
}
return ret;
}
int main()
{
char arr1[10] = {0};
char arr2[] = "hello";
my_strcpy(arr1, arr2);
printf("%s\\n", arr1); // 输出：hello
return 0;
5.strcat
#innclude <string.h>
char * strcat ( char * destination, const char * source );
功能：字符串追加，把 source 指向的源字符串中的所有字符都追加到 destination 指向的空间中。
参数： destination ：指针，指向目的地空间 source ：指针，指向源头数据
返回值： strcat 函数返回的目标空间的起始地址
5.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s\\n", arr1); // 输出：hello world
return 0;
}
分析：
strcat 先找到 arr1 字符串末尾的 '\\0'。
从 '\\0' 的位置开始，把 arr2 的字符逐个复制过去，直到遇到 arr2 的 '\\0'。
最终 arr1 里的内容变成 "hello world\\0"。
使用注意事项：
源字符串必须以 '\\0' 结尾：否则 strcat 不知道复制到哪里停止，会一直向后访问内存，导致越界访问（野指针问题）。
目标字符串也必须包含 '\\0'：strcat 是从目标字符串的 '\\0' 位置开始追加的，如果目标字符串没有 '\\0'，就无法确定追加的起始位置。
目标空间必须足够大：目标数组的容量必须能装下原字符串 + 追加的字符串 + 最后的 '\\0'，否则会发生缓冲区溢出，导致程序崩溃或内存错误。
目标空间必须可修改：不能给 strcat 传入字符串常量（比如 char *arr = "hello";），因为常量字符串存储在只读内存区，无法修改。
5.2strcat的手动模拟实现
#include <stdio.h>
#include <assert.h>
char* my_strcat(char *dest, const char* src)
{
// 保存目标字符串的起始地址，最后要返回它
char *ret = dest;
// 断言：防止传入空指针，提高代码健壮性
assert(dest != NULL);
assert(src != NULL);
// 1. 让 dest 移动到目标字符串的末尾 '\\0' 处
while(*dest)
{
dest++;
}
// 2. 从 '\\0' 位置开始，复制 src 的字符到 dest，直到遇到 src 的 '\\0'
while((*dest++ = *src++))
{
;
}
// 返回目标字符串的起始地址
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
my_strcat(arr1, arr2);
printf("%s\\n", arr1);
return 0;
6.strcpt
#include <string.h>
int strcmp ( const char * str1, const char * str2 );
功能：用来比较 str1 和 str2 指向的字符串，从两个字符串的第⼀个字符开始比较，如果两个字符的ASCII码值相等，就比较下⼀个字符。直到遇到不相等的两个字符，或者字符串结束。
参数： str1 ：指针，指向要比较的第⼀个字符串 str2 ：指针，指向要比较的第⼆个字符串
返回值标准规定：
第⼀个字符串大于第二个字符串，则返回大于0的数字
第⼀个字符串等于第二个字符串，则返回0
第⼀个字符串小于第二个字符串，则返回小于0的数字
6.1代码演示：
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abq";
int ret = strcmp(arr1, arr2);
printf("%d\\n", ret);
if(ret > 0)
printf("arr1 > arr2\\n");
else if(ret == 0)
printf("arr1 == arr2\\n");
else
printf("arr1 < arr2\\n");
return 0;
}
分析：
逐字符比较 arr1 和 arr2：
第 1 个字符 'a' == 'a'，继续比较下一个；
第 2 个字符 'b' == 'b'，继续比较下一个；
第 3 个字符 'c' 和 'q'：'c' 的 ASCII 码值（99）小于 'q'（113），比较停止。
函数返回一个小于 0 的值，所以最终会输出 arr1<arr2。
6.2strcmp的手动模拟实现：
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char *str1, const char *str2)
{
assert(str1 != NULL); // 断言防止空指针
assert(str2 != NULL);
// 当两个字符相等且都不是 '\\0' 时，继续比较下一个
while(*str1 == *str2)
{
if(*str1 == '\\0') // 两个字符串同时到末尾，说明完全相等
return 0;
str1++;
str2++;
}
// 遇到不相等的字符，返回两者的 ASCII 差值
return *str1 – *str2;
}
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abq";
int ret = my_strcmp(arr1, arr2);
printf("%d\\n", ret);
return 0;
}
使用注意事项：
比较的是 ASCII 码值，不是字符串长度很多新手会误以为长字符串一定更大，比如 "abcd" 和 "ab" 比较，实际上第 3 个字符 'c' > '\\0'，所以 "abcd" 更大，和长度无关。
字符串必须以 '\\0' 结尾，如果字符串没有结束符，strcmp 会一直向后访问内存，导致越界访问，结果不可预测。
！！！必须用 strcmp 比较字符串，不能用 ==\\n
// 错误写法
if(arr1 == arr2) { … }
这里的 == 比较的是两个数组的地址，而不是字符串内容，永远不会相等。
7.strncpy
#include <string.h>
char * strncpy ( char * destination, const char * source, size_t num );
功能：字符串拷贝；将 source 指向的字符串拷贝到 destination 指向的空间中，最多拷贝num个字符。
参数：
destination ：指针，指向目的地空间
source ：指针，指向源头数据
num ：从source指向的字符串中最多拷贝的字符个数
返回值： strncpy 函数返回的目标空间的起始地址
7.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[20] = {0}; // 初始化为全 0
char arr2[] = "abcdefghi";
char* str = strncpy(arr1, arr2, 5);
printf("%s\\n", arr1); // 输出：abcde
printf("%s\\n", str); // 输出：abcde
return 0;
}
分析：
从 arr2 中拷贝前 5 个字符 'a' 'b' 'c' 'd' 'e' 到 arr1 中。
注意：strncpy 不会自动在末尾添加 '\\0'！因为 arr1 初始化时是全 0，所以第 6 个位置本来就是 '\\0'，所以能正常打印。！！！如果 arr1 没有初始化，这里可能会出现乱码。
7.2 比较strcpy和strncpy函数
strcpy 函数拷贝到 \\0 为止，如果目标空间不够的话，容易出现越界行为。
strncpy 函数指定了拷贝的长度，源字符串不⼀定要有 \\0 ，同时在设计参数的时候，就会多⼀层
结论：如果关心目标空间的大小是否够用， strncpy 相对 strcpy 函数更加安全。
7.3.strncpy手动模拟实现
#include <stdio.h>
#include <assert.h>
char* my_strncpy(char *dest, const char *src, size_t num)
{
assert(dest != NULL);
assert(src != NULL);
char *ret = dest;
// 先拷贝最多 num 个字符
while(num– && (*src != '\\0'))
{
*dest++ = *src++;
}
// 如果 src 提前结束，剩下的用 '\\0' 填充
while(num–)
{
*dest++ = '\\0';
}
return ret;
}
8.strnact
#include <stdio.h>
char * strncat ( char * destination, const char * source, size_t num );
功能：字符串追加；将 source 指向的字符串的内容，追加到 destination 指向的空间，最多追 加 num 个字符。
参数：
destination ：指针，指向了目标空间
source ：指针，指向了源头数据
num ：最多追加的字符的个数
返回值：返回的是目标空间的起始地址
8.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
char* str = strncat(arr1, arr2, 5);
printf("%s\\n", arr1); // 输出：hello world
printf("%s\\n", str); // 输出：hello world
return 0;
}
分析：
strncat 先找到 arr1 末尾的 '\\0'。
从 '\\0' 位置开始，从 arr2 中追加最多 num 个字符（这里是 5 个字符 'w' 'o' 'r' 'l' 'd'）。
关键细节：追加完成后，strncat 会自动在末尾补上 '\\0'，所以不需要手动处理结束符。
8.2strcat和strncat对比
参数不同， strncat 多了⼀个参数
strcat 函数在追加的时候要将源字符串的所有内容，包含 \\0 都追加过去，但是 strncat 函
数指定了追加的长度。
strncat 函数中源字符串中不⼀定要有 \\0 了。
strncat 更加灵活，也更加安全。
注意事项：
目标空间必须足够大虽然 strncat 限制了追加的字符数，但目标数组的大小必须能装下原字符串 + num 个追加字符 + 最后的 '\\0'，否则依然会溢出。
num 的取值技巧通常 num 设为目标数组剩余的空间大小减 1，这样可以确保追加后还有位置放 '\\0'，避免越界。
strncat 一定会补 '\\0'不管追加了多少个字符，strncat 都会在追加完成后自动加上 '\\0'，这一点和 strncpy 不同。
8.3strncat的手动模拟实现
#include <stdio.h>
#include <assert.h>
char* my_strncat(char *dest, const char *src, size_t num)
{
assert(dest != NULL);
assert(src != NULL);
char *ret = dest;
// 1. 先找到 dest 末尾的 '\\0'
while(*dest)
{
dest++;
}
// 2. 追加最多 num 个字符
while(num– && (*src != '\\0'))
{
*dest++ = *src++;
}
// 3. 自动补上结束符
*dest = '\\0';
return ret;
}
9.strcmp
#include <string.h>
int strncmp ( const char * str1, const char * str2, size_t num );
功能：字符串比较；比较 str1 和 str2 指向的两个字符串的内容，最多比较 num 字符。
参数：
str1 ：指针，指向⼀个比较的字符串
str2 ：指针，指向另外⼀个比较的字符串
num ：最多比较的字符个数
返回值标准规定：
第⼀个字符串大于第⼆个字符串，则返回大于0的数字
第⼀个字符串等于第⼆个字符串，则返回0
第⼀个字符串小于第⼆个字符串，则返回小于0的数字
9.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcqw";
int ret1 = strncmp(arr1, arr2, 3);
printf("%d\\n", ret1); // 输出：0
int ret2 = strncmp(arr1, arr2, 4);
printf("%d\\n", ret2); // 输出：负数（因为 'd' < 'q'）
return 0;
}
分析：
当 num=3 时，只比较前 3 个字符 'a' 'b' 'c'，两者完全相同，返回 0。
当 num=4 时，比较第 4 个字符 'd' 和 'q'，'d' 的 ASCII 码值小于 'q'，返回负数。
9.2strcmp和strncmp比较
参数不同
strncmp可以比较任意长度了
strncmp函数更加灵活，更加安全
9.3strncmp手动模拟实现
#include <stdio.h>
#include <assert.h>
// 模拟实现 strncmp
int my_strncmp(const char* str1, const char* str2, size_t n)
{
// 断言：保证指针不为空
assert(str1 != NULL);
assert(str2 != NULL);
// 最多比较 n 个字符
while (n–)
{
// 字符不相等 → 返回差值
if (*str1 != *str2)
{
return *str1 – *str2;
}
// 字符相等，但已经到末尾 \\0 → 两个字符串完全相等
else if (*str1 == '\\0')
{
return 0;
}
// 继续比较下一个字符
str1++;
str2++;
}
// 比完 n 个字符都一样 → 相等
return 0;
}
// 测试
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abq";
// 比较前 3 个字符
int ret1 = my_strncmp(arr1, arr2, 3);
printf("%d\\n", ret1); // <0，因为 'c' < 'q'
// 比较前 2 个字符
int ret2 = my_strncmp(arr1, arr2, 2);
printf("%d\\n", ret2); // 0，ab == ab
return 0;
}
10.strstr
#include <stdio.h>
char * strstr ( const char * str1, const char * str2);
功能：
strstr 函数，查找 str2 指向的字符串在 str1 指向的字符串中第⼀次出现的位置。
简而言之在⼀个字符串中查找子字符串。
strstr 的使用得包含头文件<string.h>
参数：
str1 ：指针，指向了被查找的字符串
str2 ：指针，指向了要查找的字符串
返回值： 如果str1指向的字符串中存在str2指向的字符串，那么返回第⼀次出现位置的指针
10.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "This is a simple string";
char *pch;
pch = strstr(str, "simple");
if (pch != NULL)
printf("%s\\n", pch); // 输出：simple string
else
printf("查找的字符串不存在\\n");
return 0;
}
分析：
在 str 中查找 "simple" 子串，找到它在第 10 个字符的位置。
strstr 返回 "simple" 首字符的地址，所以 pch 指向 "simple string"。
用 printf 打印 pch 时，会从 "simple" 开始一直打印到字符串末尾。
10.2strstr的手动模拟实现
#include <stdio.h>
#include <assert.h>
char *my_strstr(const char *str1, const char *str2)
{
// 1. 处理空指针和特殊情况：str2 是空字符串时，直接返回 str1
assert(str1 != NULL);
assert(str2 != NULL);
if (*str2 == '\\0')
return (char *)str1;
// 2. 遍历主字符串的每个位置，尝试匹配子串
const char *cp = str1; // cp 记录当前尝试匹配的起始位置
while (*cp != '\\0')
{
const char *s1 = cp;
const char *s2 = str2;
// 3. 从当前位置开始，逐个字符匹配子串
while (*s1 != '\\0' && *s2 != '\\0' && *s1 == *s2)
{
s1++;
s2++;
}
// 4. 如果 s2 走到了末尾，说明子串匹配成功
if (*s2 == '\\0')
{
return (char *)cp; // 返回匹配成功的起始地址
}
// 5. 匹配失败，主字符串的起始位置后移一位
cp++;
}
// 6. 遍历完主字符串都没找到，返回 NULL
return NULL;
}
分析：
特殊情况处理：如果 str2 是空字符串，直接返回 str1。
双重循环匹配：外层循环：遍历主字符串的每个位置，作为匹配的起点 cp。内层循环：从 cp 开始，逐个字符和子串 str2 比较。
匹配成功判断：如果内层循环结束时 *s2 == '\\0'，说明子串的所有字符都匹配上了，返回 cp。
匹配失败处理：如果当前位置匹配失败，主字符串的起点 cp 后移一位，继续下一轮匹配。
注意事项：
子字符串必须以 '\\0' 结尾 否则 strstr 会一直向后访问内存，导致越界访问，结果不可预测。返回的是地址，不是索引比如上面的例子中，pch 不是 "simple" 在 str 中的下标，而是指向它的指针。你可以用 pch – str 来计算它的下标。
只返回第一次出现的位置如果主字符串中存在多个相同的子串，strstr 只会返回第一个的地址。
11.strtok函数的使用
#include <string.h>
char *strtok(char *str, const char *delim);
功能:分割字符串：根据 delim 参数中指定的分隔符，将输入字符串 str 拆分成多个子字符串。
修改原始字符串： strtok 会直接在原始字符串中插入 '\\0' 终止符，替换分隔符的位置，因
此原始字符串会被修改。
参数:
str ：首次调用时传入待分割的字符串；后续调用传入 NULL ，表示继续分割同⼀个字符串。
delim ：包含所有可能分隔符的字符串（每个字符均视为独立的分隔符）。
返回值 成功时返回指向当前子字符串的指针。
没有更多子字符串时返回 NULL 。
使用步骤
首次调用：传⼊待分割字符串和分隔符。
后续调用：传⼊ NULL 和相同的分隔符，继续分割。
结束条件：当返回 NULL 时，表示分割完成。
11.1代码演示
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "192.168.6.111";
const char* sep = ".";
char* str = NULL;
// 为了不破坏原字符串，先拷贝一份到 buf
char buf[30] = {0};
strcpy(buf, arr);
// 循环分割
for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
{
printf("%s\\n", str);
}
return 0;
}
第一次调用 strtok(buf, sep)：找到第一个 .，把它改成 '\\0'，返回 "192" 的地址。
第二次调用 strtok(NULL, sep)：从上次结束的位置继续找下一个 .，改成 '\\0'，返回 "168" 的地址。
重复这个过程，直到找不到分隔符，返回 NULL，循环结束。
运行结果：
192
168
6
111
注意事项：
会修改原字符串分隔符会被替换成 '\\0'，原字符串会被破坏。如果需要保留原数据，一定要先拷贝一份再分割，像例子里的 buf 一样。
不能分割字符串常量比如 char* arr = "192.168.6.111"; 这种常量字符串，存储在只读内存区，strtok 要修改它会直接导致程序崩溃。
连续分隔符会被当成一个比如 "a..b" 用 . 分割，只会返回 "a" 和"b"，中间的连续分隔符会被跳过，不会返回空字符串。
12.strerror
#include <string.h>
char* strerror ( int errnum );
功能：
strerror 函数可以通过参数部分的 errnum 表示错误码，得到对应的错误信息，并且返回这
个错误信息字符串首字符的地址。
strerror 函数只针对标准库中的函数发生错误后设置的错误码的转换。
strerror 的使用需要包含头文件<string.h>
参数：errnum 是错误码，通常直接传 errno（一个全局变量，记录标准库函数调用后的错误码）。
返回值：返回错误信息字符串的首地址。
12.1代码演示
示例：打印所有错误码信息
#include <errno.h>
#include <string.h>
#include <stdio.h>
int main()
{
int i = 0;
for (i = 0; i <= 10; i++) {
printf("%d: %s\\n", i, strerror(i));
}
return 0;
}
在Windows11 + VS2022环境下输出的结果如下：
0: No error
1: Operation not permitted
2: No such file or directory
3: No such process
4: Interrupted function call
5: Input/output error
6: No such device or address
7: Arg list too long
8: Exec format error
9: Bad file descriptor
10: No child processes
示例 2：实际场景（文件打开失败）
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE *pFile = NULL;
pFile = fopen("unexist.ent", "r");
if (pFile == NULL)
{
printf("错误信息是: %s\\n", strerror(errno));
return 1;
}
return 0;
}
输出结果：
错误信息是：No such file or directory
分析：
fopen 尝试打开一个不存在的文件，调用失败，就会返回一个空指针，并且会设置错误码。errno 被自动设置为 2（对应 “文件不存在” 的错误码）。
strerror(errno) 把错误码 2 转换成字符串 "No such file or directory"。
最终输出：错误信息是: No such file or directory。
13perror
void perror(const char *str);
参数：str 是你自定义的提示信息，函数会先打印这个字符串，再打印一个冒号和空格，最后打印错误信息。
返回值：无值，直接输出到屏幕。
13.1代码演示
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE *pFile = NULL;
pFile = fopen("unexist.ent", "r");
if (pFile == NULL)
{
perror("错误信息是");
return 1;
}
return 0;
}
输出结果：
No such file or directory
13.2strerror和perror对比
perror：直接自动打印自定义提示 + 系统错误信息到标准输出，无需手动拼接，调用简单。
strerror：仅返回错误信息字符串，不做打印，可自由拼接、控制输出位置。
两者都根据errno获取错误描述，perror 更便捷，strerror 灵活性更高。
注意事项：
errno 是全局变量，会被后续函数调用覆盖比如 fopen 失败后，errno 被设为 2，但如果你接下来调用了 printf 出错，errno 会被改成新的错误码。所以要立即读取并保存 errno 的值。strerror 返回的字符串是只读的，不能修改它指向的是库函数内部的静态缓冲区，多次调用可能会被覆盖。
perror 只能输出到标准输出，如果你想把错误信息写入文件，就只能用 strerror。
