总结：C标准库I/O函数

最新推荐文章于 2023-02-11 13:21:25 发布

初闻

最新推荐文章于 2023-02-11 13:21:25 发布

阅读量1.1k

点赞数 2

分类专栏： C语言文章标签： I/O函数 stdio.h C标准库

本文链接：https://blog.csdn.net/X_Perseverance/article/details/88975419

版权

C语言专栏收录该内容

12 篇文章 1 订阅

订阅专栏

一、函数列表

函数名	详细信息
clearerr()	点击查看
fclose	点击查看
fdopen()	点击查看
feof()	点击查看
ferror()	点击查看
fflush()	点击查看
fgetc()	点击查看
fgetpos()	点击查看
fgets()	点击查看
fileno()	点击查看
flockfile()	点击查看
fopen()	点击查看
fprintf()	点击查看
fputc()	点击查看
fputs()	点击查看
fread()	点击查看
freopen()	点击查看
fscanf()	点击查看
fseek()	点击查看
fseeko()	点击查看
fsetpos()	点击查看
ftell()	点击查看
ftello()	点击查看
ftrylockfile()	点击查看
funlockfile()	点击查看
fwrite()	点击查看
getc()	点击查看
getchar()	点击查看
pclose()	点击查看
perror()	点击查看
popen()	点击查看
printf()	点击查看
putc()	点击查看
putchar()	点击查看
puts()	点击查看
remove()	点击查看
rename()	点击查看
rewind()	点击查看
scanf()	点击查看
setbuf()	点击查看
setvbuf()	点击查看
snprintf()	点击查看
sprintf()	点击查看
sscanf()	点击查看
tmpfile()	点击查看
tmpnam()	点击查看
ungetc()	点击查看
vfprintf()	点击查看
vfscanf()	点击查看
vprintf()	点击查看
vscanf()	点击查看
vsnprintf)	点击查看
vsprintf()	点击查看
vsscanf()	点击查看

二、详细介绍

1. clearerr()

头文件：#include <stdio.h>
函数原型：void clearerr(FILE *stream);
功能：清除由stream指向的文件流的文件尾标识和错误标识，将文件结束标志和文件错误标志置为0，可以通过使用该函数从文件流的错误状态中恢复。

2. fclose ()

头文件：#include <stdio.h>
函数原型：int fclose(FILE *fp);
功能：关闭与流关联的文件并取消关联。与流关联的所有内部缓冲区都与其解除关联并刷新：写入任何未写入的输出缓冲区的内容，并丢弃任何未读输入缓冲区的内容。
返回值：成功返回0；否则将返回EOF，并将errno设置为错误标识符

3. fdopen()

头文件：#include <stdio.h>
函数原型：FILE *fdopen(int fd, const char *mode);
功能：取一个现存的文件描述符fd，并使一个标准的I/O流与该描述符相结合。此函数常用于由创建管道和网络通信通道函数获得的描述符。因为这些特殊类型的文件不能用标准I/O fopen函数打开，首先必须先调用设备专用函数以获得一个文件描述符，然后用fdopen使一个标准I/O流与该描述符相结合。
返回值：转换成功时返回指向该流的文件指针；失败则返回NULL，并将errno设置为错误标识符
参数：mode

mode值说明
r 以只读方式打开文件
r+ 以可读可写的方式打开文件
w 以只写方式打开文件，文件不存在则创建，存在则清空原有内容
w+ 以可读可写的方式打开文件，文件不存在则创建，存在则清空原有内容
a 以写追加的方式打开文件，文件不存在则创建，存在则将写入的数据写到文件结尾，即文件原有的内容会被保留
a+ 以可读、可写追加的方式打开文件，文件不存在则创建，存在则从文件结尾处写入数据，或从文件开头处读取数据

注：以上操作文件的类型都为文本文件，若加上 b 选项则为二进制文件。

mode值	说明
r	以只读方式打开文件
r+	以可读可写的方式打开文件
w	以只写方式打开文件，文件不存在则创建，存在则清空原有内容
w+	以可读可写的方式打开文件，文件不存在则创建，存在则清空原有内容
a	以写追加的方式打开文件，文件不存在则创建，存在则将写入的数据写到文件结尾，即文件原有的内容会被保留
a+	以可读、可写追加的方式打开文件，文件不存在则创建，存在则从文件结尾处写入数据，或从文件开头处读取数据

4. feof()

头文件：#include <stdio.h>
函数原型：int feof(FILE *stream);
功能：检测流上的文件结束符（文件结束符只能被clearerr()函数清除）
返回值：文件结束，返回非0值；文件未结束，返回0

5. ferror()

头文件：#include <stdio.h>
用法：int ferror(FILE *stream);
功能：检测流上的错误标识符（错误标识符只能被clearerr()函数清除）
返回值：如果设置了与流关联的错误标识符，该函数返回一个非零值，否则返回一个零值

6. fflush()

头文件：#include <stdio.h>
函数原型：int fflush(FILE *stream);
功能：清除读写缓冲区
对于输出流，fflush ( )会通过流的底层写函数强制写入给定输出或更新流的所有用户空间缓冲数据。
对于输入流，fflush ( )会丢弃从底层文件中提取但尚未被应用程序使用的任何缓冲数据。（非标准，标准没有指定输入流的行为）
如果流参数为空，fflush ( )将刷新所有打开的输出流。
返回值：成功则返回0；否则将返回EOF，并将errno设置为错误标识符

7. fgetc()

头文件：#include <stdio.h>
函数原型：int fgetc(FILE *stream);
功能：从指定的流 stream 中获取一个无符号字符，并把位置标识符往前移动
返回值：返回值是返回所读取的一个字节；如果读到文件末尾或者读取出错时，则将读取的字符作为无符号字符转换为整数或EOF返回

8. fgetpos()

头文件：#include <stdio.h>
函数原型：int fgetpos(FILE *stream, fpos_t *pos);
功能：获取当前访问指针位置信息
返回值：成功返回0；否则返回-1，并将errno设置为错误标识符

9. fgets()

头文件：#include <stdio.h>
函数原型：char *fgets(char *s, int size, FILE *stream);
参数：

（1）s: 字符型指针，指向用来存储所得数据的地址
（2）size: 整型数据，指明存储数据的字节大小
（3）stream: 文件结构体指针，将要读取的文件流

功能：
从文件结构体指针stream中读取数据，每次读取一行。读取的数据保存在s指向的字符数组中，每次最多读取size-1个字符（第size个字符赋’\0’）。如果文件中的该行不足size-1个字符，则读完该行就结束。若该行（包括最后一个换行符）的字符数超过size-1，则fgets只返回一个不完整的行，但是，缓冲区总是以NULL字符结尾，对fgets的下一次调用会继续读该行。函数成功将返回buf，失败或读到文件结尾返回NULL。因此我们不能直接通过fgets的返回值来判断函数是否是出错而终止的，应该借助feof函数或者ferror函数来判断。
返回值：

（1）成功，则返回第一个参数buf；
（2）在读字符时遇到end-of-file，则设置EOF标识符，如果还没读入任何字符就遇到这种情况，则buf保持原来的内容，返回NULL；
（3）如果发生读入错误，将errno设置为错误标识符，返回NULL，buf的值可能被改变。

10. fileno()

头文件：#include <stdio.h>
函数原型：int fileno(FILE *stream);
功能：获取参数stream指定的文件流所使用的文件描述符
返回值：某个数据流的文件描述符

实例：

#include <stdio.h>

int main() {
    FILE* fp = fopen("log.txt", "r");
    int fd = fileno(fp);
    printf("The file descriptor for stdin is %d\n", fileno(stdin));
    printf("The file descriptor for stdout is %d\n", fileno(stdout));
    printf("The file descriptor for stderr is %d\n", fileno(stderr));
    printf("The file descriptor for fp is %d\n", fd);
    fclose(fp);
    fp = NULL;
    return 0;
}

结果：
在这里插入图片描述

11. flockfile()

头文件：#include <stdio.h>
函数原型：void flockfile(FILE *filehandle);
功能：等待 *filehandle 不再被其他的线程锁定，然后使当前线程成为 *filehandle 的所有者，并增加锁计数 lockcount

12. fopen()

头文件：#include <stdio.h>
函数原型：FILE *fopen(const char *path, const char *mode);
功能：打开一个指定的文件，并把一个流和这个文件相关联
返回值：成功则返回一个指向该流的文件指针；失败则返回NULL，并将errno设置为错误标识符
参数：mode

mode值说明
r 以只读方式打开文件
r+ 以可读可写的方式打开文件
w 以只写方式打开文件，文件不存在则创建，存在则清空原有内容
w+ 以可读可写的方式打开文件，文件不存在则创建，存在则清空原有内容
a 以写追加的方式打开文件，文件不存在则创建，存在则将写入的数据写到文件结尾，即文件原有的内容会被保留
a+ 以可读、可写追加的方式打开文件，文件不存在则创建，存在则从文件结尾处写入数据，或从文件开头处读取数据

注：以上操作文件的类型都为文本文件，若加上 b 选项则为二进制文件。

mode值	说明
r	以只读方式打开文件
r+	以可读可写的方式打开文件
w	以只写方式打开文件，文件不存在则创建，存在则清空原有内容
w+	以可读可写的方式打开文件，文件不存在则创建，存在则清空原有内容
a	以写追加的方式打开文件，文件不存在则创建，存在则将写入的数据写到文件结尾，即文件原有的内容会被保留
a+	以可读、可写追加的方式打开文件，文件不存在则创建，存在则从文件结尾处写入数据，或从文件开头处读取数据

13. fprintf()

头文件：#include <cstdio> 或<bits/stdc++.h>

注：#include <stdio.h> 为旧版C语言用法

函数原型：int fprintf(FILE *stream, const char *format, ...);
参数：

（1）stream：文件流指针
（2）format：输出格式

格式说明
%d, %i 十进制有符号整数
%u 十进制无符号整数
%f 浮点数
%s 字符串
%p 指针的值
%e, %E 指数形式的浮点数
%x 无符号以小写十六进制表示的整数
%X 无符号以大写十六进制表示的整数
%o 无符号以八进制表示的整数
%g 自动选择合适的表示法

（3）…：附加参数列表

功能：根据指定的格式(format)发送信息(参数)到由stream指定的文件中
返回值：成功则返回打印的字符数(不包括用于输出到字符串的空字节)；错误则返回负值

格式	说明
%d, %i	十进制有符号整数
%u	十进制无符号整数
%f	浮点数
%s	字符串
%p	指针的值
%e, %E	指数形式的浮点数
%x	无符号以小写十六进制表示的整数
%X	无符号以大写十六进制表示的整数
%o	无符号以八进制表示的整数
%g	自动选择合适的表示法

14. fputc()

头文件：#include <stdio.h>
函数原型：int fputc(int c, FILE *stream);
功能：将 c 转换为无符号字符，然后写入到指定的流 stream 中
返回值：成功则返回被写入的字符；出错则返回 EOF，并将errno设置为错误标识符

15. fputs()

头文件：#include <stdio.h>
函数原型：int fputs(const char *s, FILE *stream);
功能：把字符串写入到指定的流 stream 中，但不包括空字符(’\0’)
返回值：成功则返回非负数，出错则返回 EOF

16. fread()

头文件：#include <stdio.h>
函数原型：size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
功能：从 stream 指向的流中读取 nmemb 个数据元素，每个元素的字节大小为 size，并将它们存储在 ptr 给定的位置
返回值：成功读取的元素总数会以 size_t 对象返回，如果总数与 nmemb 参数不同，则可能发生了错误或者到达了文件末尾

17. freopen()

头文件：#include <stdio.h>
函数原型：FILE *freopen(const char *path, const char *mode, FILE *stream);
功能：
打开文件名为 path 所指向的文件，并将该文件与 stream 流相关联。原始流(如果存在)被关闭。其中mode参数与fopen()函数一样使用。
通常，freopen()函数的主要用途就是更改与标准文本流(stderr、stdin或stdout)相关联的文件。
返回值：成功则返回一个文件流指针；失败则返回NULL，并将errno设置为错误标识符

实例：

#include <stdio.h>
 
int main() {
    printf("输出到 stdout\n");
    FILE* fp = freopen("test.txt", "w+", stdout); 
    printf("输出到 test.txt\n");
    
    fclose(fp); 
    return(0);
}

结果：
在这里插入图片描述

18. fscanf()

头文件：#include <stdio.h>
函数原型：int fscanf(FILE *stream, const char *format, ...);
功能：从流 stream 读取，格式化输入
返回值：成功则返回成功匹配和赋值的个数；如果到达文件末尾或发生读错误，则返回 EOF

实例：

#include <stdio.h>
        
int main() {
    FILE* fp = fopen("test.txt", "r");
    char str1[10]={0}, str2[10]={0}, str3[10]={0}, str4[10]={0};
    int num = 0;
        
    num = fscanf(fp, "%s %s %s %s", str1, str2, str3, str4);
        
    printf("num: %d\n", num);
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    printf("str3: %s\n", str3);
    printf("str4: %s\n", str4);                                                                                                        
        
    fclose(fp);
    return(0);
}

结果：
在这里插入图片描述

19. fseek()

头文件：#include <stdio.h>
函数原型：int fseek(FILE *stream, long offset, int whence);
功能：将流 stream 的文件位置设置为从 whence 位置偏移 offset 个字节处
参数：

（1）stream：文件指针
（2）offset：偏移量，以字节为单位，可以为负值
（3）whence：偏移起始位置，即从哪里开始偏移，它一般指定为下列常量之一：

常量描述
SEEK_SET 文件的开头
SEEK_CUR 文件指针的当前位置
SEEK_END 文件的末尾

返回值：成功则返回零；否则返回 -1，并将errno设置为错误标识符
当 offset 是向文件尾方向偏移的时候，无论偏移量是否超出文件尾，fseek()都是返回0。当偏移量没有超出文件尾的时候，文件指针指向偏移后的位置；而当其超过文件尾时，文件指针指向文件尾处。
当 offset 是向文件头方向偏移的时候，如果偏移量没有超过文件头，那么文件指针指向偏移后的位置，fseek()返回0；而当其超过文件头时，文件指针指向文件尾处，fseek()返回-1。

常量	描述
SEEK_SET	文件的开头
SEEK_CUR	文件指针的当前位置
SEEK_END	文件的末尾

实例：

#include <stdio.h>
        
int main() {
    FILE* fp = fopen("test.txt", "w+");
        
    fputs("abcdefg\n", fp);
    fseek(fp, -4, SEEK_CUR);                                                                                                         
    fputs("123", fp);
        
    fclose(fp);
    return(0);
}

结果：
在这里插入图片描述

20. fseeko()

头文件：#include <stdio.h>
函数原型：int fseeko(FILE *stream, off_t offset, int whence);
功能：将流 stream 的文件位置设置为从 whence 位置偏移 offset 个字节处
返回值：成功则返回零；否则返回 -1，并将errno设置为错误标识符
说明：该函数和 fseek() 类似，区别在于fseek()的参数 offset 是 long 类型的(32位)，而该函数的参数 offset 是 off_t 类型的(32位)，在编译时会将其转换为64位类型。

21. fsetpos()

头文件：#include <stdio.h>
函数原型：int fsetpos(FILE *stream, fpos_t *pos);
功能：将流 stream 的文件位置设置为给定的位置 pos
返回值：成功则返回零；否则返回 -1，并将errno设置为错误标识符

实例：

#include <stdio.h>
 
int main() {
    FILE* fp = fopen("test.txt", "w+");
    fpos_t pos;
 
    fgetpos(fp, &pos);
    fputs("abcde\n", fp);
                                                                                                                                     
    fsetpos(fp, &pos);
    fputs("123", fp);
 
    fclose(fp);
    return(0);
}

结果：
在这里插入图片描述

22. ftell()

头文件：#include <stdio.h>
函数原型：long ftell(FILE *stream);
功能：获取流 stream 所指向的流的文件位置标识符的当前值
返回值：成功则返回位置标识符的当前值；否则返回 -1，并将errno设置为错误标识符

23. ftello()

头文件：#include <stdio.h>
函数原型：off_t ftello(FILE *stream);
功能：获取流 stream 所指向的流的文件位置标识符的当前值
返回值：成功则返回位置标识符的当前值；否则返回 -1，并将errno设置为错误标识符
说明：该函数和 ftell() 类似，区别在于 ftell() 的返回值是 long 类型的(32位)，而该函数的返回值是 off_t 类型的(32位)，在编译时会将其转换为64位类型。

24. ftrylockfile()

头文件：#include <stdio.h>
函数原型：int ftrylockfile(FILE *filehandle);
功能：该函数是 flockfile() 的非阻塞版本。在其他线程拥有 *filehandle 的情况下，该函数什么也不做，否则它会获得所有权并增加锁计数 lockcount
返回值：成功则返回0（获得锁）；失败则返回非零

25. funlockfile()

头文件：#include <stdio.h>
函数原型：void funlockfile(FILE *filehandle);
功能：减少锁计数

26. fwrite()

头文件：#include <stdio.h>
函数原型：size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
功能：将 ptr 所指向的数据写入到 stream 指向的流中，每次写入 nmemb 个数据元素，每个元素的字节大小为 size
返回值：成功写入的元素总数会以 size_t 对象返回，如果总数与 nmemb 参数不同，则可能发生了错误或者到达了文件末尾

27. getc()

头文件：#include <stdio.h>
函数原型：int getc(FILE *stream);
功能：从指定的流 stream 中获取一个无符号字符，并把位置标识符往前移动
返回值：返回值是返回所读取的一个字节；如果读到文件末尾或者读取出错时，则将读取的字符作为无符号字符转换为整数或EOF返回

28. getchar()

头文件：#include <stdio.h>
函数原型：int getchar(void);
功能：从标准输入 stdin 获取一个无符号字符，等价于 getc(stdin)
返回值：返回值是返回所读取的一个字节；如果读到文件末尾或者读取出错时，则将读取的字符作为无符号字符转换为整数或EOF返回

29. pclose()

头文件：#include <stdio.h>
函数原型：int pclose(FILE *stream);
功能：等待由 popen() 打开的进程终止
返回值：如果发生错误，则返回-1，并将errno设置为错误标识

30. perror()

头文件：#include <stdio.h>
函数原型：void perror(const char *s);
功能：把一个描述性错误消息输出到标准错误 stderr。首先输出字符串 s，后跟一个冒号，然后是一个空格
参数：
s：自定义消息，将显示在原本的错误消息之前

实例：

#include <stdio.h>
 
int main() {
    rename("test.txt", "newtest.txt");
 
    FILE *fp = fopen("test.txt", "r");
    if(fp == NULL) {
        perror("fopen error");
        return -1; 
    }   
                                                                                                                                     
    fclose(fp);
    return 0;
}

结果：
在这里插入图片描述

31. popen()

头文件：#include <stdio.h>
函数原型：FILE *popen(const char *command, const char *type);
功能：该函数通过创建一个管道，调用fork()产生一个子进程，然后调用 execl("/bin/sh", “sh”, “-c”, command, 0); 执行shell命令。可以通过这个管道进行标准输入输出操作
参数：

（1）command：该参数是一个指向以NULL结束的shell命令字符串的指针。这行命令将被传到bin/sh并使用-c标志，shell将执行这个命令
（2）type：只能是读或者写中的一种，得到的返回值（标准I/O流）也具有和type相应的只读或只写类型。如果type是 “r” ，则文件指针是连接到子进程执行command命令的标准输出；如果type是 “w” ，则文件指针是连接到子进程执行command命令的标准输入

返回值：如果调用fork()或pipe()失败，或者无法分配内存将返回NULL，否则返回标准I/O流

实例1：

#include <stdio.h>                                                                                                                   
 
int main() {
    FILE *fp =  popen("pwd", "r"); //读取子进程的标准输出
    if(fp == NULL) {
        perror("popen error");
        return -1; 
    }   
    
    char buf[1024] = {0};
    if(fgets(buf, sizeof(buf), fp) == NULL) {
        perror("fgets error");
        return -2; 
    }   
 
    printf("%s", buf);
 
    pclose(fp);
    return 0;
}

结果：
在这里插入图片描述
实例2：

#include <stdio.h>                
                                  
int main() {                      
    FILE *fp =  popen("pwd", "w"); //写入到子进程的标准输入                                                                                                   
    if(fp == NULL) {              
        perror("popen error"); 
        return -1;                
    }                             
                                  
    pclose(fp);                   
    return 0;                     
}

结果：
在这里插入图片描述

32. printf()

头文件：#include <stdio.h>
函数原型：int printf(const char *format, ...);
功能：格式化输出到标准输出 stdout
参数：format

格式说明
%c 单个字符
%d 十进制有符号整数
%u 十进制无符号整数
%f 浮点数
%s 字符串
%p 指针的值
%e、%E 指数形式的浮点数
%o 无符号以八进制表示的整数
%x 无符号以小写十六进制表示的整数
%X 无符号以大写十六进制表示的整数
%g 把输出的值按照 %e 或者 %f 类型中输出长度较小的方式输出
%lu 32位无符号整数
%llu 64位无符号整数

返回值：成功则返回打印的字符数(不包括用于输出到字符串的空字节)；错误则返回一个负值

格式	说明
%c	单个字符
%d	十进制有符号整数
%u	十进制无符号整数
%f	浮点数
%s	字符串
%p	指针的值
%e、%E	指数形式的浮点数
%o	无符号以八进制表示的整数
%x	无符号以小写十六进制表示的整数
%X	无符号以大写十六进制表示的整数
%g	把输出的值按照 %e 或者 %f 类型中输出长度较小的方式输出
%lu	32位无符号整数
%llu	64位无符号整数

33. putc()

头文件：#include <stdio.h>
函数原型：int putc(int c, FILE *stream);
功能：把一个指定的无符号字符 c 写入到指定的流 stream 中，并把位置标识符往前移动
返回值：成功则将写入的字符作为无符号字符转换为整数返回；若出错则返回 EOF

34. putchar()

头文件：#include <stdio.h>
函数原型：int putchar(int c);
功能：把一个指定的无符号字符 c 写入到标准输出 stdout 中,等价于 putc(c, stdout)
返回值：成功则将写入的字符作为无符号字符转换为整数返回；若出错则返回 EOF

35. puts()

头文件：#include <stdio.h>
函数原型：int puts(const char *s);
功能：将字符串 s 和尾随的换行符写入到标准输出 stdout 中
返回值：成功则返回一个非负值；若出错则返回 EOF

36. remove()

头文件：#include <stdio.h>
函数原型：int remove(const char *pathname);
功能：从文件系统中删除给定的文件
返回值：成功则返回 0 ；错误则返回 -1，并设置 errno

37 rename()

头文件：#include <stdio.h>
函数原型：int rename(const char *old, const char *new);
功能：更改文件名
返回值：成功则返回 0 ；错误则返回 -1，并设置 errno，而且旧文件和新文件都不会被更改或创建

38. rewind()

头文件：#include <stdio.h>
函数原型：void rewind(FILE *stream);
功能：将流指向的流文件位置指示符设置为文件的开头，等价于 (void) fseek(stream, 0L, SEEK_SET)

39. scanf()

头文件：#include <stdio.h>
函数原型：int scanf(const char *format, ...);
功能：从标准输入 stdin 读取格式化输入
返回值：成功则返回成功匹配和赋值的个数；如果到达文件末尾或发生读错误，则返回 EOF

40. setbuf()

头文件：#include <stdio.h>
函数原型：void setbuf(FILE *stream, char *buf);
功能：将指定缓冲区与特定的文件流相关联，实现操作缓冲区时直接操作文件流的功能
其意义在于用户打开一个文件后，可以建立自己的文件缓冲区，而不必使用 fopen() 函数打开文件时设定的默认缓冲区。这样就可以让用户自己来控制缓冲区，包括改变缓冲区大小、定时刷新缓冲区、改变缓冲区类型、删除流中默认的缓冲区、为不带缓冲区的流开辟缓冲区等。
参数：

（1）stream：一个文件流指针，其指向的对象标识了一个打开的流
（2）buf：分配给用户的缓冲区，它的长度至少为 BUFSIZ 字节，BUFSIZ 是一个宏常量，表示数组的长度

实例：

#include <stdio.h>  
        
char outbuf[BUFSIZ];
        
int main() { 
    setbuf(stdout, outbuf); //将缓冲区和输出流相关联
        
    puts("This is a test code.");
    puts(outbuf); //此时 outbuf 中保存着字符串"This is a test code."
        
    fflush(stdout); //刷新输出缓冲区
    puts(outbuf); //此时 outbuf 中保留着两个相同的字符串"This is a test code."                                                       
        
    return 0;  
}

结果：
在这里插入图片描述

41. setvbuf()

头文件：#include <stdio.h>
函数原型：int setvbuf(FILE *stream, char *buf, int mode, size_t size);
功能：设置文件流 stream 的缓冲区
参数：

（1）stream：一个文件流指针，其指向的对象标识了一个打开的流
（2）buf：分配给用户的缓冲区。如果设置为 NULL，该函数会自动分配一个指定大小的缓冲区
（3）mode：文件缓冲的模式

模式描述
_IOFBF 全缓冲：对于输出，数据在缓冲填满时被一次性写入；对于输入，缓冲会在请求输入且缓冲为空时被填充
_IOLBF 行缓冲：对于输出，数据在遇到换行符或者在缓冲填满时被写入，具体视情况而定；对于输入，缓冲会在请求输入且缓冲为空时被填充，直到遇到下一个换行符
_IONBF 无缓冲：不使用缓冲，直接从流中读入数据或直接向流中写入数据，此时 buf 和 size 参数被忽略

（4）size：缓冲的大小，以字节为单位

返回值：成功则返回 0 ；失败则返回非零值

模式	描述
_IOFBF	全缓冲：对于输出，数据在缓冲填满时被一次性写入；对于输入，缓冲会在请求输入且缓冲为空时被填充
_IOLBF	行缓冲：对于输出，数据在遇到换行符或者在缓冲填满时被写入，具体视情况而定；对于输入，缓冲会在请求输入且缓冲为空时被填充，直到遇到下一个换行符
_IONBF	无缓冲：不使用缓冲，直接从流中读入数据或直接向流中写入数据，此时 buf 和 size 参数被忽略

42. snprintf()

头文件：#include <stdio.h>
函数原型：int snprintf(char *str, size_t size, const char *format, ...);
功能：将格式化的数据写入字符串 str
参数：

size：要写入字符的最大数目（包括字符 ‘\0’ ），超过size会被截断

返回值：成功则返回参数 str 字符串的长度；出错则返回一个负值，并设置错误标识符 errno

实例：

#include <stdio.h>                       
                                         
int main() {                             
    char buf[5] = {0};                   
                                         
    int ret = snprintf(buf, 4, "string");                                                                                            
                                         
    printf("ret：%d\n", ret);            
    printf("buf：%s\n", buf);            
                                         
    return 0;                            
}

结果：
在这里插入图片描述

43. sprintf()

头文件：#include <stdio.h>
函数原型：int sprintf(char *str, const char *format, ...);
功能：将格式化的数据写入字符串 str
返回值：成功则返回参数 str 字符串的长度；出错则返回一个负值，并设置错误标识符 errno

实例：

#include <stdio.h>                   
                                     
int main() {                         
    char buf[10] = {0};              
                                     
    int ret = sprintf(buf, "string");                                                                                                
                                     
    printf("ret：%d\n", ret);        
    printf("buf：%s\n", buf);        
                                     
    return 0;                        
}

结果：
在这里插入图片描述

44. sscanf()

头文件：#include <stdio.h>
函数原型：int sscanf(const char *str, const char *format, ...);
功能：从字符串 str 中读取指定格式的数据
返回值：成功则返回成功匹配和赋值的个数；如果到达文件末尾或发生读错误，则返回 EOF

实例：

#include <stdio.h>
 
int main() {
    int num = 0;
    char str[10] = {0};
 
    char src[20] = "123abc456def";
 
    sscanf(src, "%d%s", &num, str);
    
    printf("num：%d\n", num);
    printf("str：%s\n", str);
                                                                                                                                     
    return 0;
}

结果：
在这里插入图片描述

45. tmpfile()

头文件：#include <stdio.h>
函数原型：FILE *tmpfile(void);
功能：以二进制读/写(w+b)模式创建一个唯一的临时文件，当文件关闭或程序终止时，它将被自动删除
返回值：成功则返回一个指向被创建临时文件的流指针；如果无法生成唯一文件名或无法打开唯一文件，则返回 NULL，并设置错误指示符 errno

46. tmpnam()

头文件：#include <stdio.h>
函数原型：char *tmpnam(char *s);
功能：产生一个唯一包含路径的文件名，该文件名与系统中已经存在的文件都不相同，因此非常适合用来创建一个临时文件，而不用担心覆盖现有的文件
参数：s

（1）如果 s 为 NULL，那么文件名将被保存在一个系统自动创建的静态数组中，该数组会一直存在，直到再次调用tmpnam()函数或程序停止
（2）如果 s 不为 NULL，那么它必须指向一个长度不小于 L_tmpnam 的字符数组，该数组将用于保存产生的文件名。L_tmpnam 是在 stdio.h 中定义的宏，指明了tmpnam()函数产生的文件名的最大长度

返回值：成功时返回一个指向唯一临时文件名的指针；失败时返回 NULL

实例：

#include <stdio.h>
        
int main() {
    char buf[L_tmpnam] = {0};
        
    tmpnam(buf);
    printf("buf：%s\n", buf);                                                                                                        
        
    char* p = tmpnam(NULL);
    printf(" p ：%s\n", p); 
        
    return 0;  
}

结果：
在这里插入图片描述

47. ungetc()

头文件：#include <stdio.h>
函数原型：int ungetc(int c, FILE *stream);
功能：将字符 c 推回到指定流中，这个推回的字符可用于后续读取操作
返回值：成功则返回被推入的字符 c ；出错则返回 EOF，且流 stream 保持不变

实例：

#include <stdio.h>                                                                                                                   
 
int main() {
    int num = 0;
    char ch; 
 
    while((ch = getchar()) != EOF && isdigit(ch)) {
        num = num*10 + ch - '0';
    }   
 
    if(ch != EOF) {
        ungetc(ch, stdin); //把一个字符推回到标准输入流
    }   
 
    printf("num: %d\n", num); 
    printf("next character in buffer: %c\n", getchar());
    
    return 0;
}

结果：
在这里插入图片描述

48. vfprintf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vfprintf(FILE *stream, const char *format, va_list ap);
功能：使用可变参数列表发送格式化数据输出到指定流 stream中
参数：

ap：一个表示可变参数列表的对象

返回值：成功则返回打印的字符数(不包括用于输出到字符串的空字节)；错误则返回负值

实例：

#include <stdio.h>
#include <stdarg.h>
        
void WriteFunc(FILE *stream, char *format, ...) {
    va_list args;
    va_start(args, format);
    vfprintf(stream, format, args);
    va_end(args);
}       
        
int main() {
    FILE *fp = fopen("test.txt", "w");
        
    WriteFunc(fp, "num=%d, str=%s\n", 1024, "Hello");                                                                                
        
    fclose(fp);
    return(0);
}

结果：
在这里插入图片描述

49. vfscanf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vfscanf(FILE *stream, const char *format, va_list ap);
功能：从流 stream 中读取格式化数据，存储到可变参数列表中
参数：

ap：一个表示可变参数列表的对象

返回值：成功则返回成功填充的参数列表项数；如果到达文件末尾或发生读错误，则返回 EOF

实例：

#include <stdio.h>
#include <stdarg.h>
 
void ReadFunc(FILE* stream, char *format, ...) {
    va_list args;
    va_start(args, format);
    vfscanf(stream, format, args);
    va_end(args);
}
 
int main() {
    int num = 0;
    char str[10] = {0};
    FILE* fp = fopen("test.txt", "r");
 
    ReadFunc(fp, "%d %s", &num, str);
 
    printf("num: %d\n", num);
    printf("str: %s\n", str);
 
    return(0);
}

结果：
在这里插入图片描述

50. vprintf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vprintf(const char *format, va_list ap);
功能：使用可变参数列表发送格式化数据输出到标准输出 stdout
参数：

ap：一个表示可变参数列表的对象

返回值：成功则返回打印的字符数(不包括用于输出到字符串的空字节)；错误则返回一个负值

实例：

#include <stdio.h>
#include <stdarg.h>
        
void WriteFunc(char *format, ...) {
    va_list args;
    va_start(args, format);
    vprintf(format, args);                                                                                                           
    va_end(args);
}       
        
int main() {
    WriteFunc("num=%d, str=%s\n", 1024, "Hello");
        
    return(0);
}

结果：
在这里插入图片描述

51. vscanf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vscanf(const char *format, va_list ap);
功能：从标准输入 stdin 中读取格式化数据，存储到可变参数列表中
参数：

ap：一个表示可变参数列表的对象

返回值：成功则返回成功填充的参数列表项数；如果到达文件末尾或发生读错误，则返回 EOF

实例：

#include <stdio.h>
#include <stdarg.h>
        
void ReadFunc(char *format, ...) {
    va_list args;
    va_start(args, format);
    vscanf(format, args);
    va_end(args);
}       
        
int main() {
    int num = 0;
    char str[10] = {0};
        
    ReadFunc("%d %s", &num, str);                                                                                                    
        
    printf("num: %d\n", num);
    printf("str: %s\n", str);
        
    return(0);
}

结果：
在这里插入图片描述

52. vsnprintf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vsnprintf(char *str, size_t size, const char *format, va_list ap);
功能：使用可变参数列表发送格式化数据输出到字符串 str
参数：

size：要写入字符的最大数目（包括字符 ‘\0’ ），超过size会被截断
ap：一个表示可变参数列表的对象

返回值：成功则返回打印的字符数(不包括用于输出到字符串的空字节)；错误则返回一个负值

实例：

#include <stdio.h>
#include <stdarg.h>
        
void WriteFunc(char *str, size_t size, char *format, ...) {
    va_list args;
    va_start(args, format);
    vsnprintf(str, size, format, args);
    va_end(args);
}       
        
int main() {
    char buf[20] = {0};
    WriteFunc(buf, 10, "%s world", "Hello");                                                                                         
    puts(buf);
        
    return(0);
}

结果：
在这里插入图片描述

53. vsprintf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vsprintf(char *str, const char *format, va_list ap);
功能：使用可变参数列表发送格式化数据输出到字符串 str
参数：

ap：一个表示可变参数列表的对象

返回值：成功则返回打印的字符数(不包括用于输出到字符串的空字节)；错误则返回一个负值

实例：

#include <stdio.h>
#include <stdarg.h>
       
void WriteFunc(char *str, char *format, ...) {
    va_list args;
    va_start(args, format);
    vsprintf(str, format, args);
    va_end(args);
}   
       
int main() {
    char buf[100] = {0};
    WriteFunc(buf, "num=%d, str=%s", 1024, "Hello");                                                                                 
    puts(buf);
       
    return(0);
}

结果：
在这里插入图片描述

54. vsscanf()

头文件：#include <stdio.h>和#include <stdarg.h>
函数原型：int vsscanf(const char *str, const char *format, va_list ap);
功能：从字符串 str 读取格式化数据，存储到可变参数列表中
参数：

ap：一个表示可变参数列表的对象

返回值：成功则返回成功填充的参数列表项数；如果到达文件末尾或发生读错误，则返回 EOF

实例：

#include <stdio.h>
#include <stdarg.h>
 
void ReadFunc(char *str, char *format, ...) {
    va_list args;
    va_start(args, format);
    vsscanf(str, format, args);
    va_end(args);
}
 
int main() {
    int num = 0;
    char str[10] = {0};
    char src[10] = "123abc";
 
    ReadFunc(src, "%d %s", &num, str);
 
    printf("num: %d\n", num);
    printf("str: %s\n", str);
 
    return(0);
}

结果：
在这里插入图片描述

初闻

关注

2
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
总结：C标准库I/O函数

一、函数列表函数名详细信息clearerr()点击查看*fclose点击查看*fdopen()点击查看feof()点击查看*ferror()点击查看*fflush()点击查看*fgetc()点击查看*fgetpos()点击查看*fgets()点击查看*fileno()点击查看flockfile()...
复制链接

扫一扫