C语言库stdio.h操作
stdio .h 头文件定义了三个变量类型、一些宏和各种函数来执行输入和输出。
下面是头文件 stdio.h 中定义的变量类型：
1 size_t 这是无符号整数类型，它是 sizeof关键字的结果。
2 FILE 这是一个适合存储文件流信息的对象类型。
3 fpos_t 这是一个适合存储文件中任何位置的对象类型。
下面是头文件 stdio.h 中定义的宏
1 NULL 这个宏是一个空指针常量的值。
2 _IOFBF _IOLBF 和 _IONBF 这些宏扩展了带有特定值的整型常量表达式，并适用于 setvbuf 函数的第三个参数。
3 BUFSIZ 这个宏是一个整数，该整数代表了 setbuf 函数使用的缓冲区大小。
4 EOFM 这个宏是一个表示已经到达文件结束的负整数。
5 FOPEN_MAX 这个宏是一个整数，该整数代表了系统可以同时打开的文件数量。
6 FILENAME_MAX 这个宏是一个整数，该整数代表了字符数组可以存储的文件名的最大长度。如果实现没有任何限制，则该值应为推荐的最大值。
7 L_tmpnam 这个宏是一个整数，该整数代表了字符数组可以存储的由 tmpnam 函数创建的临时文件名的最大长度。
8 SEEK_CUR SEEK_END 和 SEEK_SET 这些宏是在These macros are used in the fseek 函数中使用，用于在一个文件中定位不同的位置。
9 TMP_MAX 这个宏是 tmpnam 函数可生成的独特文件名的最大数量。
10 stderr stdin 和 stdout 这些宏是指向 FILE 类型的指针，分别对应于标准错误、标准输入和标准输出流。
1.FILE *fopen(const char *filename, const char *mode)
FILE *fopen(const char *filename, const char *mode) 使用给定的模式 mode 打开 filename 所指向的文件
filename -- 这是 C 字符串，包含了要打开的文件名称。
mode -- 这是 C 字符串，包含了文件访问模式，模式如下。
"r" 打开一个用于读取的文件。该文件必须存在。
"w" 创建一个用于写入的空文件。如果文件名称与已存在的文件相同，则会删除已有文件的内容，文件被视为一个新的空文件。
"a" 追加到一个文件。写操作向文件末尾追加数据。如果文件不存在，则创建文件。
"r+" 打开一个用于更新的文件，可读取也可写入。该文件必须存在。
"w+" 创建一个用于读写的空文件。
"a+" 打开一个用于读取和追加的文件。 没有就创建
#include
#include
int main()
{
FILE * fp;
fp = fopen("D:/file.txt", "w"); //打开路径D:/file.txt文件 往该文件添加字符串 w模式覆盖之前的内容
fprintf(fp, "%s %s %s %d", "Hello", "World", "in", 2016); // 往FILE文件流 写内容
fclose(fp); //关闭File文件流
return 0;
}
2.int fclose(FILE *stream) 与fopen对应
int fclose(FILE *stream) 关闭流 stream 刷新所有的缓冲区
stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了要被关闭的流。
如果流成功关闭，则该方法返回零。如果失败，则返回 EOF
#include
#include
int main()
{
FILE * fp;
//fopen函数使用过程发现，当fopen要打开的文件路径中，包含一个不存在路径时，不管fopen函数的第二参数设成什么，都无法建立该文件
//若D:/A/A 路径不存在，fopen将不会建立mirror_im_protocol.cfg文件，导致fopen返回NULL。
//当D:/A/A/路径存在，而file.txt不存在时，函数会自动创建该文件
fp = fopen("D:/A/A/file.txt", "w");
if(fp == NULL){
printf("fp == NULL\n");
}
int value = fclose(fp); //关闭File文件流
printf("value = %d",value);
return 0;
}
打印结果:
fp == NULL
value = -1
3.int fprintf(FILE *stream, const char *format, ...)
int fprintf(FILE *stream, const char *format, ...) 发送格式化输出到流 stream 中File* 指针中
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
format -- C 字符串包含了要被写入到流 stream 中的文本它可以包含嵌入的 format 标签
format 标签可被随后的附加参数中指定的值替换并按需求进行格式化。
c 字符
d|i 有符号十进制整数
e 使用 e 字符的科学科学记数法（尾数和指数）
E 使用 E 字符的科学科学记数法（尾数和指数）
f 十进制浮点数
g 自动选择 %e 或 %f 中合适的表示法
G 自动选择 %E 或 %f 中合适的表示法
o 有符号八进制
s 字符的字符串
u 无符号十进制整数
x 无符号十六进制整数
X 无符号十六进制整数（大写字母）
p 指针地址
n 无输出
% 字符
#include
#include
int main()
{
FILE * fp;
fp = fopen ("D:/file.txt", "w+");
fprintf(fp, "%s %s %s %d", "Hello", "everyone", "now", 2016); //指定format输出到 file.txt
fclose(fp);
return 0;
}
打印结果: 在D:/file.txt 文件里面 有字符 Hello everyone now 2016
4.int fgetc(FILE *stream)
int fgetc(FILE *stream) 从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要在上面执行操作的流
该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF(-1)
#include
int main ()
{
FILE *fp;
int c;
int n = 0;
fp = fopen("D:/file.txt","r");
if(fp == NULL)
{
perror("D:/file.txt打开文件时发生错误");
return(-1);
}
do
{
c = fgetc(fp); // 以无符号 char 强制转换为 int 的形式返回读取的字符
if( feof(fp) )
{
break ;
}
printf("%c", c); // 无符号 char 与 int值一一对应
}while(1);
printf("\nD:/file.txt 文件读取完毕 ");
fclose(fp);
return 0;
}
打印结果:
Hello World in 2016Hello World in 2016
Hello World in 2016
D:/file.txt 文件读取完毕
5.void perror(const char *str)
void perror(const char *str) 把一个描述性错误消息输出到标准错误 stderr 。首先输出字符串 str，后跟一个冒号，然后是一个空格。
str -- 这是 C 字符串，包含了一个自定义消息，将显示在原本的错误消息之前
#include
int main ()
{
FILE *fp;
int c;
int n = 0;
fp = fopen("D:/A/A/file.txt","r");
if(fp == NULL)
{
perror("D:/A/A/file.txt 打开文件时发生错误");
return(-1);
}
do
{
c = fgetc(fp); // 以无符号 char 强制转换为 int 的形式返回读取的字符
if( feof(fp) )
{
break ;
}
printf("%c", c); // 无符号 char 与 int值一一对应
}while(1);
printf("\nD:/file.txt 文件读取完毕 ");
fclose(fp);
return 0;
}
打印结果: 【首先输出字符串 str，后跟一个冒号 然后是一个空格 最后是erroID对应的strerr 】
D:/A/A/file.txt 打开文件时发生错误: No such file or directory
6.int feof(FILE *stream)
int feof(FILE *stream) 测试给定流 stream 的文件结束标识符
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
当设置了与流关联的文件结束标识符时，该函数返回一个非零值，否则返回零。
当设置了与流关联的文件结束标识符时，该函数返回一个非零值（true），否则检测不到文件结束标志返回零(false)
#include
int main ()
{
FILE *fp;
int c;
int n = 0;
fp = fopen("D:/file.txt","r");
if(fp == NULL)
{
perror("D:/file.txt打开文件时发生错误");
return(-1);
}
do
{
c = fgetc(fp);
if( feof(fp) ) // 当设置了与流关联的文件结束标识符时，该函数返回一个非零值（true），否则检测不到文件结束标志返回零(false)。
{
printf("\n%s", "文件已经读取到末尾");
break ;
}
printf("%c", c);
}while(1);
printf("\nD:/file.txt 文件读取完毕 ");
fclose(fp);
return 0;
}
打印结果:
Hello World in 2016Hello World in 2016
Hello World in 2016
文件已经读取到末尾
D:/file.txt 文件读取完毕
7.int setvbuf(FILE *stream, char *buffer, int mode, size_t size)
int setvbuf(FILE *stream, char *buffer, int mode, size_t size) 定义流 stream 应如何缓冲 缓存策略
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了一个打开的流。
buffer -- 这是分配给用户的缓冲。如果设置为 NULL，该函数会自动分配一个指定大小的缓冲。
mode -- 这指定了文件缓冲的模式
size --这是缓冲的大小，以字节为单位。
_IOFBF 全缓冲：对于输出，数据在缓冲填满时被一次性写入。对于输入，缓冲会在请求输入且缓冲为空时被填充。
_IOLBF 行缓冲：对于输出，数据在遇到换行符或者在缓冲填满时被写入，具体视情况而定。
对于输入，缓冲会在请求输入且缓冲为空时被填充，直到遇到下一个换行符。
_IONBF 无缓冲：不使用缓冲。每个 I/O 操作都被即时写入。buffer 和 size 参数被忽略。
#include
#include
#include // #include Sleep(Linux下) #include Sleep(Windows下)
int main()
{
char buff[1024];
memset( buff, '\0', sizeof( buff ));
fprintf(stdout, "启用全缓冲\n");
setvbuf(stdout, buff, _IOFBF, 1024); // _IOFBF 全缓冲
Sleep(1000);
fprintf(stdout, "这里是 w3cschool.cc\n");
fprintf(stdout, "该输出将保存到 buff\n");
fflush( stdout );
//由于没有执行fflush 并且采用全缓冲策略 "这将在编程时出现" "最后休眠五秒钟" 字符串都存在缓冲区 还没保存到Stream 所以打印出来乱码
fprintf(stdout, "这将在编程时出现\n");
fprintf(stdout, "最后休眠五秒钟\n");
Sleep(5);
return 0;
}
打印结果:
启用全缓冲
这里是 w3cschool.cc
该输出将保存到 buff
X0 0:
8.int fflush(FILE *stream)
int fflush(FILE *stream) 刷新流 stream 的输出缓冲区
如果成功，该函数返回零值。如果发生错误，则返回 EOF，且设置错误标识符（即 feof）。
#include
#include
#include // #include Sleep(Linux下) #include Sleep(Windows下)
int main()
{
char buff[1024];
memset( buff, '\0', sizeof( buff ));
fprintf(stdout, "启用全缓冲\n");
setvbuf(stdout, buff, _IOFBF, 1024); // 使用全缓冲模式
Sleep(1000);
fprintf(stdout, "这里是 w3cschool.cc\n");
fprintf(stdout, "该输出将保存到 buff\n");
fflush( stdout );
fprintf(stdout, "这将在编程时出现\n");
fprintf(stdout, "最后休眠五秒钟\n");
fflush( stdout ); // 刷新流 stream【stdout】 的输出缓冲区 使得字符串填充到stream而不是缓冲区 使得打印出来正确结果
Sleep(5);
return 0;
}
打印结果:
启用全缓冲
这里是 w3cschool.cc
该输出将保存到 buff
这将在编程时出现
最后休眠五秒钟
#include
#include
#include // #include Sleep(Linux下) #include Sleep(Windows下)
int main()
{
char buff[1024];
memset( buff, '\0', sizeof( buff ));
fprintf(stdout, "启用全缓冲\n");
setvbuf(stdout, buff, _IOFBF, 1024);
Sleep(1000);
fprintf(stdout, "这里是 w3cschool.cc\n");
fprintf(stdout, "该输出将保存到 buff\n");
fflush( stdout );
//由于没有执行fflush "这将在编程时出现" "最后休眠五秒钟" 字符串都存在缓冲区 还没保存到Stream 所以打印出来乱码
fprintf(stdout, "这将在编程时出现\n");
fprintf(stdout, "最后休眠五秒钟\n");
Sleep(5);
return 0;
}
打印结果:
启用全缓冲
这里是 w3cschool.cc
该输出将保存到 buff
X0 0:
9.int fgetpos(FILE *stream, fpos_t *pos)
int fgetpos(FILE *stream, fpos_t *pos) 获取流 stream 的当前文件位置，并把它写入到 pos。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
pos -- 这是指向 fpos_t 对象的指针。
如果成功，该函数返回零。如果发生错误，则返回非零值
#include
int main ()
{
FILE *fp;
fpos_t position;
fp = fopen("file.txt","w+");
fgetpos(fp, &position); // 获得当前的文件文职 fpos_t 类型
fputs("Hello, World!", fp); //往fp 的Stream 写入字符串
fsetpos(fp, &position); // 设置 Stream当前的 位置为 指定的 fpos_t
fputs("这将覆盖之前的内容", fp); //由于重新设置了位置 之前的字符串就被覆盖了
fclose(fp);
return 0;
}
10.size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) 从给定流 stream 读取数据到 ptr 所指向的数组中
ptr -- 这是指向带有最小尺寸 size*nmemb 字节的内存块的指针。
size -- 这是要读取的每个元素的大小，以字节为单位。
nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流。
成功读取的元素总数会以 size_t 对象返回，size_t 对象是一个整型数据类型。
如果总数与 nmemb 参数不同，则可能发生了一个错误或者到达了文件末尾。
#include
#include
int main()
{
FILE *fp;
char c[] = "Hello World!";
char buffer[20];
/* 打开文件用于读写 */
fp = fopen("file.txt", "w+"); //创建一个用于读写的空文件
//写数据到文件 写入的数据地址开头地址是c指向的地址 写入的元素Item有 strlen(c)个 每个元素有1个字节大小 往fp指向的Stream写入
/* 写入数据到文件 */
fwrite(c, strlen(c) + 1, 1, fp);
/* 查找文件的开头 */
fseek(fp, SEEK_SET, 0); //
/* 读取并显示数据 */
fread(buffer, strlen(c)+1, 1, fp);
printf("%s\n", buffer);
fclose(fp);
return 0;
}
打印结果:
Hello World!
11.size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) 把 ptr 所指向的数组中的数据写入到给定流 stream 中
ptr -- 这是指向要被写入的元素数组的指针。
size -- 这是要被写入的每个元素的大小，以字节为单位。
nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输出流
如果成功，该函数返回一个 size_t 对象，表示元素的总数，该对象时一个整型数据类型。如果该数字与 nmemb 参数不同，则会显示一个错误。
#include
int main ()
{
FILE *fp;
char str[] = "Hello Hello !";
fp = fopen( "D:\test.txt" , "w" );
fwrite(str , 1 , sizeof(str) , fp );
fclose(fp);
return 0;
}
执行结果:
在路径D:\test.txt 存在该文件 并且打开为Hello Hello !
12. int fseek(FILE *stream, long int offset, int whence)
int fseek(FILE *stream, long int offset, int whence) 设置流 stream 的文件位置为给定的偏移 offset，
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
offset -- 这是相对 whence 的偏移量，以字节为单位。
whence -- 这是表示开始添加偏移 offset 的位置。它一般指定为下列常量之一：
SEEK_SET 文件的开头
SEEK_CUR 文件指针的当前位置
SEEK_END 文件的末尾
如果成功，则该函数返回零，否则返回非零值。
#include
int main ()
{
FILE *fp;
fp = fopen("D:/test2.txt","w+"); //覆盖创建空白文件
fputs("Today_is ......", fp);
// T o d a y _ i s . . . . . .
// 1 2 3 4 5 6 7 8 9 A B C D
fseek( fp, 10, SEEK_SET ); //位置文件流的当前位置为 文件开头的第10个位置 从该位开始填写
fputs(" I am Here", fp);
fseek( fp, 0, SEEK_SET );
int c = 0;
do
{
c = fgetc(fp);
if( feof(fp) )
{
break ;
}
printf("%c", c); // 打印 Today is . I am Here
}while(1);
fclose(fp);
return 0;
}
打印结果:
Today is . I am Here
13.long int ftell(FILE *stream)
long int ftell(FILE *stream) 返回给定流 stream 的当前文件位置
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
该函数返回位置标识符的当前值。如果发生错误，则返回 -1L，全局变量 errno 被设置为一个正值
#include
int main ()
{
FILE *fp;
int len;
fp = fopen("D:/file.txt", "r");
if( fp == NULL )
{
perror ("打开文件错误");
return(-1);
}
fseek(fp, 0, SEEK_END); // 设置流Stream当前的位置是文件的末尾
len = ftell(fp); // 返回当前文件的位置
fclose(fp);
printf("file.txt 的总大小 = %d 字节\n", len);
return 0;
}
文件内容为： This is w3cschool
打印结果：file.txt 的总大小 = 18 字节
14.int remove(const char *filename)
int remove(const char *filename) 删除给定的文件名 filename，以便它不再被访问
filename -- 这是 C 字符串，包含了要被删除的文件名称。
如果成功，则返回零。如果错误，则返回 -1，并设置 errno。
#include
#include
int main ()
{
int ret;
FILE *fp;
char filename[] = "D:/file.txt";
fp = fopen(filename, "w");
fprintf(fp, "%s", "This is new!");
fclose(fp);
ret = remove(filename); // 删除文件
if(ret == 0)
{
printf("文件删除成功");
}
else
{
printf("错误：不能删除该文件");
}
return 0;
}
文件结果：文件删除成功
15.int rename(const char *old_filename, const char *new_filename) 【没有file类型的参数?】
int rename(const char *old_filename, const char *new_filename) 把 old_filename 所指向的文件名改为 new_filename
old_filename -- 这是 C 字符串，包含了要被重命名/移动的文件名称。
new_filename -- 这是 C 字符串，包含了文件的新名称。
#include
int main ()
{
int ret;
char oldname[] = "D:/fileold.txt";
char newname[] = "D:/filenew.txt";
ret = rename(oldname, newname);
if(ret == 0)
{
printf("文件重命名成功");
}
else
{
printf("错误：不能重命名该文件");
}
return 0;
}
打印结果: 文件重命名成功 D:/fileold.txt 重命名为 D:/filenew.txt
16.void rewind(FILE *stream) //设置参数 fp的Stream的当前位置为文件的开头
void rewind(FILE *stream) 设置文件位置为给定流 stream 的文件的开头。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
该函数不返回任何值
#include
int main()
{
char str[] = "Hello Everyone in the World";
FILE *fp;
int ch;
/* 首先让我们在文件中写入一些内容 */
fp = fopen( "file.txt" , "w" );
fwrite(str , 1 , sizeof(str) , fp );
fclose(fp);
fp = fopen( "file.txt" , "r" );
while(1)
{
ch = fgetc(fp);
if( feof(fp) )
{
break ;
}
printf("%c", ch);
}
rewind(fp); //设置参数 fp的Stream的当前位置为文件的开头
printf("\n");
while(1)
{
ch = fgetc(fp);
if( feof(fp) )
{
break ;
}
printf("%c", ch);
}
fclose(fp);
return 0;
}
打印结果:
Hello Everyone in the World
Hello Everyone in the World
17.void setbuf(FILE *stream, char *buffer)
void setbuf(FILE *stream, char *buffer) 定义流 stream 应如何缓冲。
该函数应在与流 stream 相关的文件被打开时，且还未发生任何输入或输出操作之前被调用一次
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了一个打开的流。
buffer -- 这是分配给用户的缓冲，它的长度至少为 BUFSIZ 字节，BUFSIZ 是一个宏常量，表示数组的长度。
#include
int main()
{
char buf[BUFSIZ];
setbuf(stdout, buf); // 设置 缓存
puts("This is w3cschool");
fflush(stdout);
return 0;
}
程序在即将输出的时候，发送输出到 STDOUT，否则它将缓冲输出
打印结果:
This is w3cschool
#include
int main()
{
char buf[BUFSIZ];
setbuf(stdout, buf);
puts("This is w3cschool");
//fflush(stdout); //注释掉刷新缓存
return 0;
}
打印结果:
燢??? (乱码 因为数据都在缓存 还不存在与stdout)
18. FILE *tmpfile(void)
FILE *tmpfile(void) 以二进制更新模式(wb+)创建临时文件。被创建的临时文件会在流关闭的时候或者在程序终止的时候自动删除。
如果成功，该函数返回一个指向被创建的临时文件的流指针。如果文件未被创建，则返回 NULL。
#include
int main ()
{
FILE *fp;
fp = tmpfile();
printf("临时文件被创建\n");
fprintf(fp,"%s","hello world~"); // 往文件写 内容
int ch = 0;
rewind(fp); // 把当前文件流的位置设置为 首位置
while(1)
{
ch = fgetc(fp);
if( feof(fp) )
{
break ;
}
printf("%c", ch);
}
/* 您可以在这里使用临时文件 */
fclose(fp); // 在这里删除零时文件
return 0;
}
打印结果:
临时文件被创建
hello world~ // 读取文件内容打印出来的
19.char *tmpnam(char *str)
char *tmpnam(char *str) 生成并返回一个有效的临时文件名，该文件名之前是不存在的。如果 str 为空，则只会返回临时文件名。
str -- 这是一个指向字符数组的指针，其中，临时文件名将被存储为 C 字符串。
一个指向 C 字符串的指针，该字符串存储了临时文件名。
如果 str 是一个空指针，则该指针指向一个内部缓冲区，缓冲区在下一次调用函数时被覆盖。
如果 str 不是一个空指针，则返回 str。如果函数未能成功创建可用的文件名，则返回一个空指针。
#include
int main()
{
char buffer[L_tmpnam]; // L_tmpnam 这个宏是一个整数，该整数代表了字符数组可以存储的由 tmpnam 函数创建的临时文件名的最大长度
char *ptr;
tmpnam(buffer);
printf("临时名称 1: %s\n", buffer);
ptr = tmpnam(NULL);
printf("临时名称 2: %s\n", ptr);
return 0;
}
打印结果:
临时名称 1: \s61c.
临时名称 2: \s61c.1
20. int sprintf(char *str, const char *format, ...) 对char[] 进行赋值
int sprintf(char *str, const char *format, ...) 发送格式化输出到 str 所指向的字符串。
如果成功，则返回写入的字符总数，不包括字符串追加在字符串末尾的空字符。
如果失败，则返回一个负数。
#include
#include
int main()
{
char str[80];
sprintf(str, "Pi 的值 = %f", M_PI); // 对str进行赋值 值为 "Pi 的值 = 3.141593"
puts(str); // 把字符数组 输出到 stdout
return 0;
}
21.int vprintf(const char *format, va_list arg) 使用参数列表发送格式化输出到标准输出 stdout
format -- 这是字符串，包含了要被写入到标准输出 stdout 的文本。它可以包含嵌入的 format 标签，
如果成功，则返回写入的字符总数，否则返回一个负数
#include
#include
void WriteFrmtd(char *format, ...) // 可变参数
{
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
}
int main ()
{
WriteFrmtd("%d and oneXXXX\n", 100);
WriteFrmtd("%d and %s\n", 101, "building");
return 0;
}
打印结果:
100 and oneXXXX
101 and building
22.int fscanf(FILE *stream, const char *format, ...)
int fscanf(FILE *stream, const char *format, ...) 从流 stream 读取格式化输入
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符 和 format 说明符
如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。
#include
#include
int main()
{
char str1[10], str2[10], str3[10];
int year;
FILE * fp;
fp = fopen ("file.txt", "w+");
fputs("We are in 2016", fp); // 写入file流
rewind(fp); //重置当前位置为起点
fscanf(fp, "%s %s %s %d", str1, str2, str3, &year); // 以指定格式 得到文件流里面的内容
printf("Read String1 |%s|\n", str1 );
printf("Read String2 |%s|\n", str2 );
printf("Read String3 |%s|\n", str3 );
printf("Read Integer |%d|\n", year );
fclose(fp);
return 0;
}
打印结果:
Read String1 |We|
Read String2 |are|
Read String3 |in|
Read Integer |2016|
23.int scanf(const char *format, ...)
int scanf(const char *format, ...) 从标准输入 stdin 读取格式化输入
format -- 这是 C 字符串，包含了以下各项中的一个或多个：空格字符、非空格字符 和 format 说明符。
如果成功，该函数返回成功匹配和赋值的个数。如果到达文件末尾或发生读错误，则返回 EOF。
#include
int main()
{
char str1[30];
int age;
printf("请输入用户名：");
scanf("%s", &str1);
printf("请输入您的年龄：");
scanf("%d", &age);
printf("输入的用户名：%s\n", str1);
printf("输入的年龄：%d", age);
return 0;
}
打印结果:
请输入用户名：hhhh
请输入您的年龄：77
输入的用户名：hhhh
输入的年龄：77
24.char *fgets(char *str, int n, FILE *stream)
char *fgets(char *str, int n, FILE *stream) 从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。
当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定
str -- 这是指向一个字符数组的指针，该数组存储了要读取的字符串。
n -- 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流。
如果成功，该函数返回相同的 str 参数。如果到达文件末尾或者没有读取到任何字符，str 的内容保持不变，并返回一个空指针。
如果发生错误，返回一个空指针。
#include
int main()
{
FILE *fp;
char str[60];
/* 打开用于读取的文件 */
fp = fopen("D:/file.txt" , "r");
if(fp == NULL) {
perror("打开文件时发生错误");
return(-1);
}
if( fgets (str, 60, fp)!=NULL ) {
/* 向标准输出 stdout 写入内容 */
puts(str);
}
fclose(fp);
return 0;
}
文件D:/file.txt 存在 并且有内容
打印结果:
abcdefghijklmnopqrstuvwxyz
25.int fputc(int char, FILE *stream)
int fputc(int char, FILE *stream) 把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动
char -- 这是要被写入的字符。该字符以其对应的 int 值进行传递。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符的流。
如果没有发生错误，则返回被写入的字符。如果发生错误，则返回 EOF，并设置错误标识符。
#include
int main ()
{
FILE *fp;
int ch;
fp = fopen("D:/file.txt", "w+");
for( ch = 33 ; ch <= 127; ch++ )
{
fputc(ch, fp); // 往file.txt 填写 33 34 35 .. 127对应的字符
}
fclose(fp);
return 0;
}
打印结果为:
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
26.int fputs(const char *str, FILE *stream)
int fputs(const char *str, FILE *stream) 把字符串写入到指定的流 stream 中，但不包括空字符
str -- 这是一个数组，包含了要写入的以空字符终止的字符序列。
stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符串的流。
该函数返回一个非负值，如果发生错误则返回 EOF。
#include
int main ()
{
FILE *fp;
char str[100];
int c;
fp = fopen("D:/file.txt", "w+");
fputs("Hello World", fp);
fputs("Everyone", fp);
fclose(fp);
fp = fopen("D:/file.txt", "r");
while(1){
c = fgetc(fp);
if(feof(fp)) break;
printf("%c",c);
}
printf("/n结束");
return 0;
}
打印结果:
Hello WorldEveryone
结束
27. char *gets(char *str)
char *gets(char *str) 从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。
当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。
str -- 这是指向一个字符数组的指针，该数组存储了 C 字符串。
如果成功，该函数返回 str。如果发生错误或者到达文件末尾时还未读取任何字符，则返回 NULL。
#include
int main()
{
char str[50];
printf("请输入一个字符串：");
gets(str); // 从标准输入 stdin 读取一行
printf("您输入的字符串是：%s", str);
return 0;
}
打印结果:
请输入一个字符串：hello everyone in 2016
您输入的字符串是：hello everyone in 2016
