简介
-
标准头文件
Linux POSIX 详解
<stdio.h> 是 C 标准库的头文件之一，在 Linux POSIX 系统中提供了对标准输入和输出的支持。
主要功能和常见函数：
- 标准输入输出函数：
printf()：用于将格式化数据打印到标准输出（终端）。scanf()：用于从标准输入（键盘）读取格式化的数据。fprintf()：将格式化数据打印到指定文件流中。fscanf()：从指定文件流中读取格式化的数据。getchar()：从标准输入中读取一个字符。putchar()：将一个字符输出到标准输出。
- 文件操作函数：
fopen()：打开文件并返回文件指针。fclose()：关闭文件。fgets()：从文件中读取一行数据。fputs()：将字符串写入文件。fgetc()和fputc()：用于读取和写入单个字符到文件。feof()和ferror()：检查文件结束和错误标志。
- 文件定位函数：
fseek()和ftell()：用于在文件中定位和获取当前位置。
- 格式化输出函数：
sprintf()：将格式化的数据写入字符串中。snprintf()：类似于sprintf()，但提供了字符数限制，避免缓冲区溢出。
- 标准流：
stdin：标准输入流，通常代表键盘输入。stdout：标准输出流，通常代表终端输出。stderr：标准错误流，通常用于输出错误消息。
- 宏定义：
EOF：表示文件结束。NULL：表示空指针。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "w");
if (file != NULL) {
fprintf(file, "这是一个示例文件\n");
fclose(file);
} else {
printf("无法打开文件\n");
}
printf("读取文件内容：\n");
FILE *fileRead = fopen("example.txt", "r");
if (fileRead != NULL) {
char buffer[100];
while (fgets(buffer, sizeof(buffer), fileRead) != NULL) {
printf("%s", buffer);
}
fclose(fileRead);
} else {
printf("无法打开文件\n");
}
return 0;
}
这个示例演示了如何使用 <stdio.h> 中的函数进行文件的写入和读取操作。其中，fopen() 用于打开文件，fprintf() 用于将内容写入文件，fgets() 用于从文件中读取内容并打印到控制台上。
Linux POSIX printf() 详解
<stdio.h> 是 C 语言中的一个头文件，用于提供标准输入输出功能。其中的 printf() 函数是用于格式化输出的一个重要函数。
printf() 函数
printf() 用于将格式化的数据输出到标准输出（通常是控制台），其功能是“打印格式化的内容”，可以按指定格式在屏幕上显示信息。
语法：
1
int printf(const char *format, ...);
format：一个字符串，用于指定输出的格式，可以包含普通字符（按原样输出）和格式说明符。...：额外的参数（可选），对应于format字符串中的格式说明符。
格式说明符：
format 字符串中的格式说明符以百分号 % 开始，后跟一个表示要打印数据类型的字符。
常见的格式说明符包括：
%d：整数%f：浮点数%c：字符%s：字符串%p：指针地址%x、%X：十六进制整数%o：八进制整数%u：无符号整数
示例用法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main() {
int num = 10;
float pi = 3.14159;
char ch = 'A';
char str[] = "Hello, World!";
printf("整数：%d\n", num);
printf("浮点数：%f\n", pi);
printf("字符：%c\n", ch);
printf("字符串：%s\n", str);
return 0;
}
解释：
%d、%f、%c、%s是用于打印不同数据类型变量的格式说明符。- 每个
printf()调用中，格式说明符会被对应的变量值替换，作为额外的参数提供给printf()函数。
返回值：
printf()返回打印的字符数（不包括用于结束字符串输出的空字节）。如果发生错误，它将返回负值。
注意：
printf()函数在格式化输出方面非常强大和灵活，允许精确控制数据的显示方式。- 如果格式说明符使用不正确，可能会导致未定义的行为或错误，如打印错误的值或使程序崩溃。
Linux POSIX scanf() 详解
<stdio.h> 是 C 语言中的一个头文件，提供了输入输出操作的函数和宏。scanf() 是其中用于输入的函数之一。
scanf() 函数
scanf() 函数用于从标准输入（通常是键盘）获取输入，并根据指定的格式将数据存储到指定的变量中。
语法：
1
int scanf(const char *format, ...);
format：包含格式说明符的字符串，用于指定输入的格式。...：用于接收输入数据的变量列表，按照format字符串中的格式进行匹配。
格式说明符：
格式说明符在 format 字符串中，用于指定输入的数据类型。
常见的格式说明符与 printf() 相似，包括：
%d：整数%f：浮点数%c：字符%s：字符串%p：指针地址%x、%X：十六进制整数%o：八进制整数%u：无符号整数
示例用法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
int main() {
int num;
float pi;
char ch;
char str[50];
printf("请输入一个整数：");
scanf("%d", &num);
printf("请输入一个浮点数：");
scanf("%f", &pi);
printf("请输入一个字符：");
scanf(" %c", &ch); // 注意空格，避免读取上一个输入后的回车符
printf("请输入一个字符串：");
scanf("%s", str);
printf("您输入的整数是：%d\n", num);
printf("您输入的浮点数是：%f\n", pi);
printf("您输入的字符是：%c\n", ch);
printf("您输入的字符串是：%s\n", str);
return 0;
}
解释：
scanf()函数按照指定的格式说明符从标准输入中读取输入，并将输入的数据存储到相应的变量中。- 格式说明符
%d、%f、%c、%s分别用于读取不同类型的数据。 &运算符用于传递变量的地址，使得scanf()函数可以将输入的值存储到相应变量的内存位置中。
返回值：
scanf()返回成功读取的参数数目。如果发生读取失败或到达文件结束，则返回值可能会少于指定的参数数目。
注意：
- 使用
scanf()时要确保提供正确的格式说明符，否则可能导致输入解析错误或意外行为。 - 对于字符串
%s，它会在空白字符（如空格、制表符、换行符等）处停止读取，可以使用其他函数（如fgets()）更安全地读取一行字符串。
使用 scanf() 需要谨慎，确保输入与格式匹配，以避免潜在的问题。
Linux POSIX fprintf() 详解
<stdio.h> 中的 fprintf() 函数与 printf() 函数类似，但不是将输出发送到标准输出（通常是屏幕），而是将格式化的输出发送到指定的文件流中。这允许将格式化的数据写入文件而不是控制台。
fprintf() 函数
语法：
1
int fprintf(FILE *stream, const char *format, ...);
stream：指向文件的指针，表示要写入的文件流。format：一个字符串，用于指定输出的格式，可以包含普通字符和格式说明符。...：额外的参数（可选），对应于format字符串中的格式说明符。
格式说明符和用法与 printf() 相同。
示例用法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
int main() {
FILE *filePointer;
char data[] = "Hello, File I/O!";
filePointer = fopen("output.txt", "w"); // 打开文件以写入模式
if (filePointer == NULL) {
printf("无法打开文件\n");
return -1;
}
fprintf(filePointer, "这是 fprintf() 写入的内容：\n");
fprintf(filePointer, "字符串：%s\n", data);
fprintf(filePointer, "整数：%d\n", 12345);
fprintf(filePointer, "浮点数：%f\n", 3.14159);
fclose(filePointer); // 关闭文件流
printf("数据已写入文件\n");
return 0;
}
解释：
fprintf()将格式化的输出写入指定的文件流（在此示例中是名为 “output.txt” 的文件）。- 使用
fopen()函数打开文件，指定 “w”（写入）模式。 - 检查文件指针是否为
NULL，以确保文件成功打开。 - 然后，
fprintf()将数据写入文件，格式与printf()相同。 - 使用
fclose()关闭文件流。
返回值：
fprintf()返回写入文件的字符数。如果发生错误，则返回负值。
注意：
- 使用
fprintf()时要确保提供正确的文件指针以及正确的格式说明符，否则可能导致写入文件错误或意外结果。 - 在完成对文件的操作后，务必关闭文件流以释放资源。
fprintf() 提供了一种将格式化数据写入文件的方法，可以根据需要指定不同的文件流，并将数据写入文件而不是标准输出。
Linux POSIX fscanf() 详解
<stdio.h> 中的 fscanf() 函数与 scanf() 函数类似，但它从指定的文件流中读取格式化的输入，而不是从标准输入（键盘）中读取输入。
fscanf() 函数
语法：
1
int fscanf(FILE *stream, const char *format, ...);
stream：指向文件的指针，表示要从中读取数据的文件流。format：包含格式说明符的字符串，用于指定输入的格式。...：用于接收读取数据的变量列表，按照format字符串中的格式进行匹配。
格式说明符和用法与 scanf() 相同。
示例用法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
int main() {
FILE *filePointer;
int num;
float pi;
char ch;
char str[50];
filePointer = fopen("input.txt", "r"); // 以读取模式打开文件
if (filePointer == NULL) {
printf("无法打开文件\n");
return -1;
}
fscanf(filePointer, "%d", &num);
fscanf(filePointer, "%f", &pi);
fscanf(filePointer, " %c", &ch); // 注意空格，避免读取上一个输入后的回车符
fscanf(filePointer, "%s", str);
printf("从文件中读取的整数是：%d\n", num);
printf("从文件中读取的浮点数是：%f\n", pi);
printf("从文件中读取的字符是：%c\n", ch);
printf("从文件中读取的字符串是：%s\n", str);
fclose(filePointer); // 关闭文件流
return 0;
}
解释：
fscanf()函数按照指定的格式说明符从指定文件流中读取输入，并将数据存储到相应的变量中。- 使用
fopen()函数以 “r”（读取）模式打开文件流。 - 检查文件指针是否为
NULL，以确保文件成功打开。 - 然后，
fscanf()从文件中读取数据，格式与scanf()相同。 - 最后，使用
fclose()关闭文件流。
返回值：
fscanf()返回成功读取的参数数目。如果发生读取失败或到达文件结束，则返回值可能会少于指定的参数数目。
注意：
- 使用
fscanf()时要确保提供正确的文件指针以及正确的格式说明符，否则可能导致读取文件错误或意外结果。 - 在完成对文件的操作后，务必关闭文件流以释放资源。
fscanf() 提供了一种从文件流中读取格式化数据的方法，可以根据需要从不同的文件流读取数据而不是标准输入。
Linux POSIX getchar() 详解
getchar() 是 <stdio.h> 头文件中的函数，用于从标准输入（通常是键盘）获取一个字符。
getchar() 函数
语法：
1
int getchar(void);
- 无参数：
getchar()不接受任何参数。 - 返回值：返回一个整数值，表示获取的字符的 ASCII 值（或者在遇到文件结束或错误时返回特殊值
EOF）。
示例用法：
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main() {
int ch;
printf("请输入一个字符：\n");
ch = getchar();
printf("您输入的字符是：%c\n", ch);
return 0;
}
解释：
getchar()函数用于从标准输入中获取一个字符，并将其作为整数返回。getchar()在用户输入一个字符后，程序会等待用户按下回车键以表示输入完成，然后才会返回该字符的 ASCII 值。
返回值：
- 如果成功获取字符，则返回该字符的 ASCII 值（0 到 255 之间的整数）。
- 如果在获取字符时出现错误或者达到文件结束（End of File，EOF），则返回特殊值
EOF（一般为-1）。
注意：
getchar()函数每次只能获取一个字符，即使用户输入多个字符也只返回第一个字符的 ASCII 值。- 在需要连续获取多个字符的情况下，通常需要循环调用
getchar()。
getchar() 是一个简单且常用的函数，适用于获取单个字符的输入。如果需要读取整行文本或者处理大量输入，可能需要考虑其他输入函数或循环来获取和处理数据。
Linux POSIX putchar() 详解
putchar() 是 C 标准库 <stdio.h> 中的函数，用于将一个字符输出到标准输出设备（通常是屏幕）。
putchar() 函数
语法：
1
int putchar(int character);
character：要输出的字符，以整数形式传递（ASCII 值）。- 返回值：如果成功输出字符，则返回输出的字符（
character参数的值）。如果发生错误，返回特殊值EOF。
示例用法：
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main() {
char ch = 'A';
printf("输出一个字符：\n");
putchar(ch);
return 0;
}
解释：
putchar()函数用于将指定的字符输出到标准输出设备（通常是屏幕）上。- 在示例中，
putchar(ch)将字符'A'（ASCII 值为 65）输出到屏幕上。
返回值：
- 如果成功输出字符，则返回输出的字符的 ASCII 值（即
character参数的值）。 - 如果发生错误，返回特殊值
EOF（一般为-1）。
注意：
putchar()函数每次只能输出一个字符。- 如果需要输出多个字符，通常需要循环调用
putchar()或者结合使用其他输出函数进行输出。
putchar() 是一个简单且常用的函数，用于将单个字符输出到标准输出设备。如果需要输出整个字符串或进行大量输出，可能需要考虑其他输出函数或循环来实现。
Linux POSIX fopen() 详解
在 POSIX 标准中，<stdio.h> 头文件提供了处理文件输入输出的函数和宏定义。其中之一是 fopen() 函数，用于打开文件并返回一个文件指针，可以在文件中执行读取或写入操作。
以下是关于 fopen() 函数的详细解释：
函数原型
1
FILE *fopen(const char *filename, const char *mode);
参数
filename：要打开的文件的路径和名称。mode：文件打开模式，定义了文件如何被打开。模式字符串包括："r"：只读模式，文件必须存在，从文件的开头开始。"w"：写入模式，如果文件不存在则创建，如果文件已存在则截断为零长度，从文件的开头开始。"a"：追加模式，如果文件不存在则创建，从文件末尾开始写入。"r+"：读写模式，文件必须存在，从文件的开头开始。"w+"：读写模式，如果文件不存在则创建，如果文件已存在则截断为零长度，从文件的开头开始。"a+"：读写模式，如果文件不存在则创建，从文件末尾开始写入。
返回值
fopen()函数返回一个指向FILE结构的指针，如果文件打开成功，则返回指向文件的指针。如果打开失败，则返回NULL。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r"); // 以只读模式打开文件
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 对文件执行读取或其他操作
fclose(file); // 关闭文件
}
return 0;
}
注意事项
- 在使用
fopen()函数后，始终应该检查返回的文件指针是否为NULL，以确保文件是否成功打开。 - 打开文件后，使用完毕应该使用
fclose()函数关闭文件，以释放资源并确保写入缓冲区的数据被刷新到文件中。 - 在使用文件操作相关函数时，应该检查每个函数的返回值以确保操作成功。
fopen() 是处理文件输入输出中常用的函数之一，使用正确的打开模式并检查返回值是确保文件操作正确执行的重要步骤。
Linux POSIX fclose() 详解
在 Linux POSIX 系统中，<stdio.h> 头文件提供了许多用于文件操作的函数。fclose() 是其中一个函数，用于关闭先前使用 fopen() 打开的文件流。这个函数的作用是关闭指定文件流，并确保在关闭文件之前将所有的缓冲区数据刷新到文件中。
以下是关于 fclose() 函数的详细解释：
函数原型
1
int fclose(FILE *stream);
参数
stream：指向FILE结构的指针，它标识了要关闭的文件流。
返回值
fclose()函数返回整型值。若关闭成功，则返回0；若出现错误，则返回EOF。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 对文件执行读取或其他操作
if (fclose(file) == 0) {
printf("文件关闭成功\n");
} else {
printf("文件关闭失败\n");
}
}
return 0;
}
注意事项
- 使用
fclose()函数关闭文件后，应该确保不再对该文件执行读取或写入操作，否则可能会导致未定义的行为。 - 关闭文件时，系统会清理所有与该文件相关的资源，并将缓冲区的数据刷新到磁盘中。因此，关闭文件是一个重要的操作，以确保数据完整性和释放资源。
fclose() 函数是在文件操作中非常重要的一个函数，用于安全地关闭文件流并清理相应的资源。使用时，应该注意检查其返回值，确保文件被成功关闭。
Linux POSIX fgets() 详解
在 POSIX 标准的 <stdio.h> 头文件中，fgets() 是用于从文件中读取一行数据的函数。它可以读取指定长度的字符或直到遇到换行符（\n）为止，并将结果存储到一个字符串缓冲区中。
以下是关于 fgets() 函数的详细解释：
函数原型
1
char *fgets(char *str, int size, FILE *stream);
参数
str：指向字符数组的指针，用于存储读取的字符串数据。size：要读取的最大字符数（包括结尾的空字符 ‘\0’）。stream：指向FILE结构的指针，表示要读取的文件流。
返回值
fgets()函数返回一个指向存储读取的字符串的指针，如果读取成功，则返回str；如果达到文件尾或发生错误，则返回NULL。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
char buffer[100]; // 定义一个缓冲区来存储读取的数据
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 读取文件中的一行数据
while (fgets(buffer, sizeof(buffer), file) != NULL) {
printf("读取的内容：%s", buffer);
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
fgets()函数从文件中读取一行文本数据，并在读取的数据中保留换行符（如果存在的话）。如果一行数据超过了指定的size - 1大小，则只会读取部分数据，剩余部分会在下一次读取时继续获取。- 使用
fgets()时应该检查返回值是否为NULL，以便判断是否读取到文件末尾或发生错误。
fgets() 函数在从文件中逐行读取数据时非常有用，特别是对于文本文件的处理。它允许你逐行读取文件内容并对每一行进行处理。
Linux POSIX fputs() 详解
在 POSIX 标准的 <stdio.h> 头文件中，fputs() 是用于向文件写入字符串的函数。它将字符串写入到指定的文件流中，不包括字符串结尾的空字符 (‘\0’)。
以下是关于 fputs() 函数的详细解释：
函数原型
1
int fputs(const char *str, FILE *stream);
参数
str：要写入的字符串，以 null 结尾。stream：指向FILE结构的指针，表示要写入的文件流。
返回值
fputs()函数返回一个非负整数值来表示成功写入的字符数。如果发生错误，则返回EOF。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "w");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 写入字符串到文件
if (fputs("Hello, fputs!\n", file) != EOF) {
printf("字符串写入成功\n");
} else {
printf("字符串写入失败\n");
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
- 使用
fputs()函数写入字符串时，不会自动添加换行符。如果需要换行，需要在字符串中包含\n。 - 需要检查
fputs()的返回值，以确保写入操作成功完成。返回值为EOF表示写入发生错误。
fputs() 函数是一个常用的文件操作函数，用于将字符串写入到指定的文件中。在使用时应该注意检查返回值，确保写入操作成功。
Linux POSIX fgetc() 详解
在 Linux POSIX 标准的 <stdio.h> 头文件中，fgetc() 函数用于从指定文件流中读取一个字符。它可以逐个字符地读取文件内容。
以下是关于 fgetc() 函数的详细解释：
函数原型
1
int fgetc(FILE *stream);
参数
stream：指向FILE结构的指针，表示要读取的文件流。
返回值
fgetc()函数返回一个整型值，即所读取的字符的 ASCII 值。如果到达文件结尾或发生错误，则返回EOF（End of File）。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
int character;
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 逐字符读取文件内容
while ((character = fgetc(file)) != EOF) {
printf("%c", character); // 打印所读取的字符
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
- 使用
fgetc()函数逐个字符地读取文件内容时，返回值是一个整数（ASCII 值），需要将其转换为字符或进行相应的处理。 - 在使用文件流的读取函数时，应该检查返回值是否为
EOF，以判断是否到达文件结尾或发生了错误。
fgetc() 函数允许你逐个字符地读取文件内容，适用于需要对文件内容逐个字符进行处理的场景。在读取文件时要确保文件能够成功打开，并在读取过程中对返回值进行适当的检查。
Linux POSIX fputc() 详解
在 Linux POSIX 标准的 <stdio.h> 头文件中，fputc() 函数用于将一个字符写入到指定的文件流中。
以下是关于 fputc() 函数的详细解释：
函数原型
1
int fputc(int c, FILE *stream);
参数
c：要写入的字符，以整数形式传入，会被转换为相应的字符。stream：指向FILE结构的指针，表示要写入的文件流。
返回值
fputc()函数返回写入的字符，如果写入成功，则返回写入的字符；如果出现错误，则返回EOF。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "w");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 写入字符到文件
if (fputc('A', file) != EOF) {
printf("字符写入成功\n");
} else {
printf("字符写入失败\n");
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
- 使用
fputc()函数写入字符时，会将整数参数c转换为相应的字符写入到文件中。 - 需要检查
fputc()的返回值，以确保写入操作成功完成。返回值为EOF表示写入发生错误。
fputc() 函数用于将单个字符写入到文件中。在使用时应该注意检查返回值，确保写入操作成功。
Linux POSIX feof() 详解
在 Linux POSIX 中，<stdio.h> 头文件中的 feof() 函数用于检查文件流的结束标志（End-of-File）。这个函数允许你判断文件指针当前是否位于文件结束位置。
以下是关于 feof() 函数的详细解释：
函数原型
1
int feof(FILE *stream);
参数
stream：指向FILE结构的指针，表示要检查的文件流。
返回值
feof()函数返回一个非零值（通常是整数1），表示已经到达文件的结束位置（End-of-File）。如果未到达文件结尾，则返回0。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 读取文件内容
int character;
while ((character = fgetc(file)) != EOF) {
printf("%c", character); // 输出读取的字符
}
// 检查是否到达文件结尾
if (feof(file)) {
printf("\n已到达文件结尾\n");
} else {
printf("\n未到达文件结尾\n");
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
feof()函数并不会主动读取文件流，它只是返回文件流的结束标志状态。- 通常在读取文件时，读取循环结束后可以使用
feof()函数来检查文件是否已经读取到了结束位置。
feof() 函数是一个用于检查文件流状态的工具，特别适用于循环读取文件并在文件末尾做出相应处理的情况。在使用时应该了解其返回值的含义，以正确判断文件的结束状态。
Linux POSIX ferror() 详解
在 Linux POSIX 中，<stdio.h> 头文件中的 ferror() 函数用于检查文件流的错误标志。这个函数允许你判断文件指针相关的错误状态。
以下是关于 ferror() 函数的详细解释：
函数原型
1
int ferror(FILE *stream);
参数
stream：指向FILE结构的指针，表示要检查的文件流。
返回值
ferror()函数返回一个非零值（通常是整数1），表示指定的文件流上发生了错误。如果没有发生错误，则返回0。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 读取文件内容
int character;
while ((character = fgetc(file)) != EOF) {
printf("%c", character); // 输出读取的字符
}
// 检查文件流是否发生错误
if (ferror(file)) {
printf("\n发生了文件流错误\n");
} else {
printf("\n文件流无错误\n");
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
ferror()函数用于检查文件流的错误状态，通常在读写文件时进行检查，以确保文件操作没有发生意外的错误。- 如果在文件流上发生了错误，
ferror()将返回非零值。这可能是由于设备错误、磁盘空间不足、权限问题等引起的文件流错误。
ferror() 函数是用于检查文件流错误状态的工具。在进行文件操作时，特别是在读写文件的过程中，建议在适当的位置使用 ferror() 来检查文件流是否发生了错误。
Linux POSIX fseek() 详解
在 Linux POSIX 中，<stdio.h> 头文件中的 fseek() 函数用于设置文件流的位置指针。这个函数可以在文件中移动文件位置指针，以便进行读写文件的操作。
以下是关于 fseek() 函数的详细解释：
函数原型
1
int fseek(FILE *stream, long offset, int whence);
参数
stream：指向FILE结构的指针，表示要设置位置的文件流。offset：表示偏移量，即要移动的字节数，可以为正数、负数或零。whence：表示起始点，可以取以下值：SEEK_SET：从文件起始位置开始偏移。SEEK_CUR：从当前位置开始偏移。SEEK_END：从文件末尾位置开始偏移。
返回值
fseek()函数返回一个非零值表示失败，返回0表示成功。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 将文件指针移动到文件末尾
if (fseek(file, 0, SEEK_END) == 0) {
printf("文件指针移动到文件末尾\n");
long fileSize = ftell(file); // 获取文件大小
printf("文件大小为 %ld 字节\n", fileSize);
} else {
printf("文件指针移动失败\n");
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
- 使用
fseek()函数时应该注意文件流的打开模式是否支持定位操作，例如，只读模式可能不允许随意移动文件指针。 fseek()可以用来移动文件指针到文件的特定位置，以便进行读取或写入操作。- 在使用
fseek()函数后应该检查返回值，确保文件指针移动操作是否成功。
fseek() 函数是一个用于定位文件指针的重要工具，可以在文件中定位到特定位置进行读写操作。在使用时应该了解 offset 和 whence 参数的用法，并检查返回值以确保操作成功。
Linux POSIX ftell() 详解
在 Linux POSIX 中，<stdio.h> 头文件中的 ftell() 函数用于获取文件流的当前位置指针相对于文件起始位置的偏移量，即返回当前文件指针的位置。
以下是关于 ftell() 函数的详细解释：
函数原型
1
long ftell(FILE *stream);
参数
stream：指向FILE结构的指针，表示要获取位置的文件流。
返回值
ftell()函数返回一个long类型值，表示文件指针的当前位置。如果发生错误，则返回-1L。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("无法打开文件\n");
} else {
printf("文件打开成功\n");
// 获取文件指针当前位置
long position = ftell(file);
if (position != -1L) {
printf("文件指针当前位置：%ld\n", position);
} else {
printf("获取文件指针位置失败\n");
}
fclose(file); // 关闭文件
}
return 0;
}
注意事项
ftell()函数返回文件指针相对于文件起始位置的偏移量，以字节为单位。- 返回值
-1L表示获取文件指针位置时出现了错误。 ftell()返回的值可以用于标识当前文件指针的位置，通常用于记录或控制文件的读写位置。
ftell() 函数用于获取文件指针的当前位置，允许你知道文件指针在文件中的偏移量。在文件处理时，了解当前文件指针的位置对于读取或写入文件非常有用。
Linux POSIX sprintf() 详解
在 Linux POSIX 系统中，<stdio.h> 头文件中的 sprintf() 函数用于将格式化的数据写入到字符串中。它类似于 printf() 函数，但是将格式化的输出写入到一个字符串中，而不是输出到标准输出流（屏幕）上。
以下是关于 sprintf() 函数的详细解释：
函数原型
1
int sprintf(char *str, const char *format, ...);
参数
str：指向字符数组的指针，用于存储格式化后的字符串。format：一个格式化字符串，包含要写入字符串的文本以及格式化指示符，与printf()中的格式化字符串相同。...：可变数量的参数，用于替换格式化字符串中的格式化指示符。
返回值
sprintf()函数返回一个整数值，表示写入到str中的字符数（不包括终止 null 字符\0）。如果发生错误，则返回一个负数。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
int main() {
char buffer[100];
int number = 42;
float floatValue = 3.14;
// 格式化数据并将结果存储到字符串中
int result = sprintf(buffer, "The number is %d and the float value is %.2f", number, floatValue);
if (result >= 0) {
printf("格式化后的字符串：%s\n", buffer);
printf("写入的字符数：%d\n", result);
} else {
printf("发生了错误\n");
}
return 0;
}
注意事项
sprintf()函数将格式化后的数据写入到一个字符数组中，并在末尾自动添加 null 终止符\0。- 需要确保目标字符数组足够大，以存储格式化后的数据，防止溢出问题。
sprintf()函数是一个强大的工具，但要注意避免缓冲区溢出，可以考虑使用安全版本的函数（如snprintf()），该函数允许指定要写入的最大字符数。
sprintf() 函数在需要将格式化的数据写入到字符串中时非常有用，能够对数据进行格式化并存储到一个指定的字符数组中。
Linux POSIX snprintf() 详解
在 Linux POSIX 中，<stdio.h> 头文件中的 snprintf() 函数类似于 sprintf() 函数，但是增加了对输出字符数量的控制。snprintf() 允许你指定要写入的最大字符数，以避免缓冲区溢出问题。
以下是关于 snprintf() 函数的详细解释：
函数原型
1
int snprintf(char *str, size_t size, const char *format, ...);
参数
str：指向字符数组的指针，用于存储格式化后的字符串。size：要写入的最大字符数（包括终止 null 字符\0）。format：格式化字符串，包含要写入字符串的文本以及格式化指示符，与printf()中的格式化字符串相同。...：可变数量的参数，用于替换格式化字符串中的格式化指示符。
返回值
snprintf()函数返回一个整数值，表示实际写入到str中的字符数（不包括终止 null 字符\0）。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
int main() {
char buffer[50];
int number = 42;
float floatValue = 3.14;
// 格式化数据并将结果存储到字符串中，最大存储字符数为 50
int result = snprintf(buffer, sizeof(buffer), "The number is %d and the float value is %.2f", number, floatValue);
if (result >= 0 && result < sizeof(buffer)) {
printf("格式化后的字符串：%s\n", buffer);
printf("写入的字符数：%d\n", result);
} else {
printf("发生了错误或缓冲区不足\n");
}
return 0;
}
注意事项
snprintf()函数与sprintf()类似，但允许指定要写入的最大字符数，以防止缓冲区溢出。- 函数返回值表示实际写入到
str中的字符数，如果返回值等于传入的size参数，表示字符串被截断。 - 使用
snprintf()可以更加安全地处理格式化数据，确保不会超出目标字符数组的大小。
snprintf() 函数是一个安全版本的格式化输出函数，允许指定最大写入字符数，避免了缓冲区溢出问题。
Linux POSIX stdin 详解
在 Linux POSIX 系统中，<stdio.h> 头文件中定义了三个标准的文件流指针：stdin、stdout 和 stderr。这些指针用于标准输入、标准输出和标准错误流。
stdin 概述
stdin是一个指向标准输入流的FILE结构指针，用于从用户输入设备（通常是键盘）读取数据。stdin是一个预定义的常量，无需额外定义即可使用。- 在程序中使用
stdin可以实现从标准输入读取用户输入的数据。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main() {
int number;
printf("请输入一个整数: ");
scanf("%d", &number); // 从标准输入(stdin)读取整数
printf("您输入的整数是: %d\n", number);
return 0;
}
注意事项
stdin是一个标准输入流指针，通常用于读取用户输入。使用标准输入时，可以通过函数如scanf()、fgets()等从键盘读取数据。stdin是一个常量指针，不允许修改，因为它指向标准输入流。
stdin 在 Linux POSIX 系统中是一个重要的标准输入流指针，允许程序从标准输入中读取用户输入。
Linux POSIX stdout 详解
在 Linux POSIX 系统中，<stdio.h> 头文件中定义了三个标准的文件流指针：stdin、stdout 和 stderr。这些指针用于标准输入、标准输出和标准错误流。
stdout 概述
stdout是一个指向标准输出流的FILE结构指针，用于向标准输出设备（通常是屏幕）写入数据。stdout是一个预定义的常量，无需额外定义即可使用。- 在程序中使用
stdout可以实现向标准输出打印数据。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int main() {
printf("这是标准输出示例\n");
fprintf(stdout, "这也是标准输出示例\n");
fprintf(stdout, "Hello, %s!\n", "World");
int number = 42;
fprintf(stdout, "The number is: %d\n", number);
return 0;
}
注意事项
stdout是一个标准输出流指针，通常用于输出程序的结果到屏幕。使用标准输出时，可以通过函数如printf()、fprintf()等向屏幕打印数据。stdout是一个常量指针，不允许修改，因为它指向标准输出流。
stdout 在 Linux POSIX 系统中是一个重要的标准输出流指针，允许程序向标准输出设备（通常是屏幕）打印数据。
Linux POSIX stderr 详解
在 Linux POSIX 系统中，<stdio.h> 头文件中定义了三个标准的文件流指针：stdin、stdout 和 stderr。这些指针用于标准输入、标准输出和标准错误流。
stderr 概述
stderr是一个指向标准错误流的FILE结构指针，用于向标准错误设备（通常也是屏幕）输出错误信息。stderr是一个预定义的常量，无需额外定义即可使用。- 在程序中使用
stderr可以实现向标准错误流输出错误信息。
示例用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main() {
int num = 10;
if (num < 20) {
fprintf(stderr, "发生了错误：数字太小\n");
}
FILE *file = fopen("nonexistent_file.txt", "r");
if (file == NULL) {
fprintf(stderr, "无法打开文件\n");
}
return 0;
}
注意事项
stderr是一个标准错误流指针，通常用于输出程序运行时的错误信息到屏幕。使用标准错误流时，可以通过函数如fprintf()向屏幕输出错误信息。stderr是一个常量指针，不允许修改，因为它指向标准错误流。
stderr 在 Linux POSIX 系统中是一个重要的标准错误流指针，允许程序输出错误信息到标准错误设备（通常是屏幕）。