标准IO 文件和流

最新推荐文章于 2023-04-09 14:58:05 发布
最新推荐文章于 2023-04-09 14:58:05 发布
阅读量484 收藏
点赞数
分类专栏： 文件I/O 文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51153209/article/details/127498972
版权

文件的概念和类型

Linux系统一切皆文件

概念

一组相关数据的有序集合

文件类型

  1. 常规文件 r
  2. 目录文件 d
  3. 字符设备文件 c
  4. 块设备文件 b
  5. 管道文件 p
  6. 套接字文件 s
  7. 符号链接文件 l

如何理解标准IO

标准I/O由ANSI C标准定义

主流操作系统上都实现了C库

标准I/O通过缓冲机制减少系统调用，实现更高的效率

IO的概念

  • I input 输入设备 比如键盘鼠标都是Input设备
  • O output 输出设备 比如显示器
  • 优盘，网口，既是输入也是输出

系统调用和库函数

  • 系统调用就是操作系统提供的接口函数
  • 如果我们把系统调用封装成库函数就可以起到隔离的作用，提供程序的可移植性
  • printf就是库函数然后调用了系统调用才在显示器上显示字符

流（FILE）的含义

就是数据的流，在程序中就是一个结构体

FILE

标准IO用一个结构体类型来存放打开的文件的相关信息

标准I/O的所有操作都是围绕FILE来进行

流（stream）

FILE又被称为流(stream)

文本流/二进制流

标准I/O预定义3个流

标准I/O预定义3个流，程序运行时自动打开

标准输入流（键盘）0STDIN_FILENOstdin
标准输出流（显示器）1STDOUT_FILENOstdout
标准错误流2STDERR_FILENOstderr

流的缓冲类型（重点）

全缓冲

当流的缓冲区无数据或无空间时才执行实际I/O操作

全缓冲的空间为 1 k 1k 1k

C程序结束或者缓冲区满，缓冲区的内容才会被打印，如下：

#include <stdio.h>
#include <unistd.h>
int main(int argc,char*argv[]){

    int i=0;
    for(i=0;i<1025;i++){   //i大于1024才会被打印
       printf("a");

    }
    //    printf("hello world\n");
    while(1){
    sleep(1);
    }
}

行缓冲

当在输入和输出中遇到换行符(‘\n’)时，进行I/O操作

当流和一个终端关联时，典型的行缓冲

Windows 和linux的换行符区别

  1. Windows是\r\n
  2. Linux 是\n

无缓冲

数据直接写入文件，流不进行缓冲

文件的打开和关闭

打开就是占用资源

关闭就是释放资源

标准I/O – 打开文件

下列函数可用于打开一个标准I/O流：

FILE *fopen (const char *path, const char *mode);
  • 成功时返回流指针；出错时返回NULL; FILE是文件类型

mode参数：

“r” 或 “rb”以只读方式打开文件，文件必须存在。
“r+” 或 ”r+b”以读写方式打开文件，文件必须存在。
“w” 或 “wb”以只写方式打开文件，若文件存在则文件长度清为0。若文件不存在则创建。
“w+” 或 “w+b”以读写方式打开文件，其他同”w”。
“a” 或 “ab”以只写方式打开文件，若文件不存在则创建；向文件写入的数 据被追加到文件末尾。
“a+” 或 “a+b”以读写方式打开文件。其他同”a”

fopen-示例

#include <stdio.h>

int main(int argc,char *argv[]){
	FILE *fp;
	fp = fopen("1.txt","r");
	if(fp == NULL){
        printf("Open filr failed\n");
		//perror("(perror)fopen");
		//printf("(strerror)fopen:%s\n",strerror(errno));
	}
	else{
		printf("Open filr success\n");
	}
	return 0;
}

处理错误信息

errno 存放错误号，由系统生成

perror先输出字符串s，再输出错误号对应的错误信息

strerror根据错误号返回对应的错误信息

extern int errno;

void perror(const char *s);

char *strerror(int errno);

错误信息处理-示例

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main(int argc,char *argv[]){
	FILE *fp;
	fp = fopen("1.txt","r");
	if(fp == NULL){
		perror("(perror)fopen");
		printf("(strerror)fopen:%s\n",strerror(errno));
	}
	else{
		printf("Open filr success\n");
	}
	return 0;
}

标准I/O – 关闭文件

int fclose(FILE *stream)；
  • fclose()调用成功返回0，失败返回EOF，并设置errno
  • 流关闭时自动刷新缓冲中的数据并释放缓冲区
  • 当一个程序正常终止时，所有打开的流都会被关闭
  • 流一旦关闭后就不能执行任何操作

标准I/O的读写

流支持不同的读写方式:

  • 读写一个字符：fgetc()/fputc()一次读/写一个字符
  • 读写一行：fgets()和fputs()一次读/写一行
  • 读写若干个对象：fread()/fwrite() 每次读/写若干个对象，而每个对象具有相同的长度

打开文件后读取，是从文件开头开始读。读完一个后读写指针会后移。读写注意文件位置！

按字符输入

下列函数用来输入一个字符:

函数返回值设置成int型既能处理有符号数又能处理无符号数

函数返回值是int类型不是char类型，主要是为了扩展返回值的范围。

 #include <stdio.h>
int fgetc(FILE \*stream); 
int getc(FILE \*stream); //宏
int getchar(void);
  • 成功时返回读取的字符；若到文件末尾或出错时返回EOF（-1），
  • getchar()等同于fgetc(stdin)
  • getc()和fgetc()区别是一个是宏一个是函数
  • 调用getchar会阻塞，等待你的键盘输入

示例：

 FILE *fp;
 int ch, count = 0;

 if ((fp = fopen(argv[1], “r”)) == NULL) { 
  perror(“fopen”); return -1;
 }

 while ((ch = fgetc(fp)) != EOF) { 
  count++; 
 }
 
 printf(“total %d bytes\n”, count);

按字符输出

下列函数用来输出一个字符:

#include <stdio.h>
int fputc(int c, FILE *stream);
int putc(int c, FILE *stream);
int putchar(int c);
  • 成功时返回写入的字符；出错时返回EOF
  • putchar©等同于fputc(c, stdout)

示例：

 FILE *fp;
 int ch;

 if ((fp = fopen(argv[1], “w”)) == NULL) { 
   perror(“fopen”); return -1;
 }

 for(ch = ‘a’; ch <=‘z’; ch++) { 
   fputc(ch, fp); 
 }

按行输入

下列函数用来输入一行:

#include <stdio.h>
char *gets(char *s);
char *fgets(char *s, int size, FILE *stream);
  • 成功时返回s，到文件末尾或出错时返回NULL
  • gets不推荐使用，没有设置长度容易造成缓冲区溢出
  • 遇到’\n’或已输入size-1个字符时返回，总是包含’\0’
  • fgets 函数第二个参数，输入的数据超出size，size-1个字符会保存到缓冲区，最后添加’\0’，如果输入数据少于size-1 后面会添加换行符。

示例：

 #define N 6
 
 char buf[N];
 fgets(buf, N, stdin);
 printf(“%s”, buf);

假设键盘输入分别是：

  • abcd<回车> buf中的内容是abcd
  • abcdef<回车> buf中的内容是abcde

按行输出

下列函数用来输出字符串:

#include <stdio.h>
int puts(const char *s);
int fputs(const char *s, FILE *stream);
  • 成功时返回非负整数；出错时返回EOF
  • puts将缓冲区s中的字符串输出到stdout， 并追加’\n’
  • fputs将缓冲区s中的字符串输出到stream，不追加 ‘\n’

示例：

 puts(“hello world”);

 FILE *fp;
 char buf[] = “hello world”;

 if ((fp = fopen(argv[1], “a”)) == NULL) { 
   perror(“fopen”); 
   return -1;
 }

 fputs(buf, fp);

注意：输出的字符串中可以包含’\n’，也可以不包含

按对象读写

下列函数用来从流中读写若干个对象:

#include <stdio.h>
size_t fread(void *ptr, size_t size, size_t n, FILE *fp); (size_t = unsigned int)
size_t fwrite(const void *ptr, size_t size, size_t n, FILE *fp);

void *ptr 读写内容放的位置指针

size_t size 读写的块大小

size_t n 读写的个数

FILE *fp 读写的文件指针

  • 成功返回读写的对象个数；出错时返回EOF
  • 既可以读写文本文件，也可以读写数据文件
  • 效率高

注意事项：

文件写完后，文件指针指向文件末尾，如果这时候读，读不出来内容。

解决办法：

  • 移动指针（后面讲解）到文件头
  • 关闭文件，重新打开

流的刷新和定位

刷新流

#include <stdio.h>
int fflush(FILE *fp);
  • 成功时返回0；出错时返回EOF
  • 将流缓冲区中的数据写入实际的文件
  • Linux下只能刷新输出缓冲区,输入缓冲区丢弃

定位流

（long 32位返回2个G，这三个函数只适用2G以下的文件）

long ftell(FILE *stream);
  • ftell() 成功时返回流的当前读写位置，出错时返回EOF
long fseek(FILE *stream, long offset, int whence);
  • fseek()定位一个流，成功时返回0，出错时返回EOF
  • whence参数：SEEK_SET/SEEK_CUR/SEEK_END

SEEK_SET：从距文件开头 offset 位移量为新的读写位置

SEEK_CUR：以目前的读写位置往后增加 offset 个位移量

SEEK_END：将读写位置指向文件尾后再增加 offset 个位移量

  • offset参数：偏移量，可正可负
  • 打开a模式 fseek无效
void rewind(FILE *stream);
  • rewind()将流定位到文件开始位置
  • rewind(fp) 相当于 fseek(fp,0,SEEK_SET);
示例一(在文件末尾追加字符’t’)
FILE *fp = fopen(“test.txt”, “r+”);
fseek(fp, 0, SEEK_END);
fputc(‘t’, fp);
示例二(获取文件长度)
 FILE *fp;

 if ((fp = fopen(“test.txt”, “r+”)) == NULL) {
   perror(“fopen”);
   return -1;
 }

 fseek(fp, 0, SEEK_END);
 printf(“length is %d\n”, ftell(fp));

判断流是否出错和结束

#include <stdio.h>
int ferror(FILE *stream);
int feof(FILE *stream);

ferror()返回1表示流出错；否则返回0

feof()返回1表示文件已到末尾；否则返回0

格式化输入和输出

sprintf和sscanf常用，重点掌握sprintf 和sscanf

格式化输出

int printf(const char *fmt, …);
int fprintf(FILE *stream, const char *fmt, …);
int sprintf(char *s, const char *fmt, …);

成功时返回输出的字符个数；出错时返回EOF

格式化输入

int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *str, const char *format, ...);

练习题

题目

每隔1秒向文件test.txt中写入当前系统时间，格式如下：

1, 2014-10-15 15:16:42

2, 2014-10-15 15:16:43

该程序无限循环，直到按Ctrl-C中断程序

每次执行程序时，系统时间追加到文件末尾，序号递增

1, 2014-10-15 15:16:42

2, 2014-10-15 15:16:43

3, 2014-10-16 11:35:07

4, 2014-10-16 11:35:08

思路

time()用来获取系统时间(秒数)

time_t time(time_t *seconds) 返回值是从1970.1.1 0:0:0开始的秒数

localtime()将系统时间转换成本地时间

struct tm *localtime(const time_t *timer)

struct tm {

int tm_sec; /* 秒，范围从 0 到 59 */

int tm_min; /* 分，范围从 0 到 59 */

int tm_hour; /* 小时，范围从 0 到 23 */

int tm_mday; /* 一月中的第几天，范围从 1 到 31 */

int tm_mon; /* 月份，范围从 0 到 11 */

int tm_year; /* 自 1900 起的年数 */

int tm_wday; /* 一周中的第几天，范围从 0 到 6 */

int tm_yday; /* 一年中的第几天，范围从 0 到 365 */

int tm_isdst; /* 夏令时 */

};

注意：

int tm_mon; 获取的值要加1是正确的月份

int tm_year; 获取的值加1900是正确的年份

代码

#include <time.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(int argc,char *argv[]){
     FILE *fp;
     time_t ctime;
     struct tm *ctimestr;
     int linecount = 0; 
     char buf[32];
     fp=fopen("test.txt","a+");
     if(fp==NULL){
         perror("fopen");
         return 0;
 }
 //calculate test.txt  line    

 while(fgets(buf,32,fp)!=NULL){
      if(buf[strlen(buf)-1] =='\n'){
           linecount++;
      }
} 

 while(1){
     ctime = time(NULL);
     //printf("ctime=%d\n",(int)ctime);
     ctimestr = localtime(&ctime);
     printf("%04d-%02d-%02d %02d:%02d:%02d\n",ctimestr->tm_year+1900,ctimestr->tm_mon+1,ctimestr->tm_mday,
                                 ctimestr->tm_hour,ctimestr->tm_min,ctimestr->tm_sec);
     fprintf(fp,"%d, %04d-%02d-%02d %02d:%02d:%02d\n",linecount,ctimestr->tm_year+1900,ctimestr->tm_mon+1,ctimestr->tm_mday,
                                 ctimestr->tm_hour,ctimestr->tm_min,ctimestr->tm_sec);
     fflush(fp);
     linecount++;
     sleep(1);
 }
 fclose(fp);
}

注意（写完文件记得fflush,\n也不会读出缓冲区）

  • 写完文件记得fflush ，写到磁盘里面去。
  • 标准IO磁盘文件的缓冲区一般为4096
  • 注意和标准输出的全缓冲区别，标准输出是1024
深センのHZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Unix标准IO文件流及缓冲类型
langzi989的专栏
04-05 466
博客搬家，原地址：https://langzi989.github.io/2017/05/24/Unix标准IO缓冲类型/ Unix标准IO文件流 在文件IO相关函数的一节中,我们所有的I/O函数都是围绕着文件描述符来操作的，当打开一个文件的时候，即返回一个文件描述符，然后该文件描述符用于后续的文件操作。而对于标准IO库，对于文件的操作都是围绕这** 文件流 file stream**进行的。当我...
文件IO详解(四)---标准输入、标准输出和标准错误
diaoju3333的博客
01-04 343
每个进程都会默认打开3个文件描述符，即0、1、2。其中0代表标准输入流、1代表标准输出流、2代表标准错误流。通常标准输入流对应着键盘的设备文件、标准输出流和错误流对应着显示器的设备文件。在编程中通常使用宏STDIN_FILENO、STDOUT_FILENO和STDERR_FILENO分别来代表0，1，2。 要注意一点： 0、1、2这三个文件描述符对应的是标准输入流、标准...
IO学习笔记 《一》
m0_74938791的博客
11-19 367
IO学习笔记
FILE 指针、标准输入、标准输出和标准错误、打开文件 fopen()、读文件和写文件
Bit_Dong的博客
08-27 2135
文件 I/O 函数（open()、read()、write()、lseek()等）都是围绕文件描述符进行的，当调用 open()函数打开一个文件时，即返回一个文件描述符 fd，然后该文件描述符就用于后续的 I/O 操作。标准输入设备指的就是计算机系统的标准的输入设备，通常指的是计算机所连接的键盘； 标准输出设备指的是计算机系统中用于输出标准信息的设备，通常指的是计算机所连接的显示器； 标准错误设备则指的是计算机系统中用于显示错误信息的设备，通常也指的是显示器设备。
文件操作————标准IO
最新发布
qq_56288396的博客
04-09 324
以追加（只写）的方式打开文件，文件存在则打开，不存在则新建。： 以追加（读写）的方式打开文件，文件存在则打开，不存在则新建。： 以只写的方式打开文件，文件存在则打开，文件不存在则新建。： 以读写的方式打开文件，文件存在则打开，文件不存在则新建。： 以只读的方式打开文件，文件存在则打开，不存在则报错。： 以读写的方式打开文件，文件存在则打开，不存在则报错。函数返回值：成功：打开的文件的文件流指针。函数返回值：成功：成功写入的个数，失败，函数返回值：成功，读到的个数，失败。：要打开的文件（可以带路径）
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
文件IO 文件操作 操作文件 标准IO和文件IO
03-23
标准IO是指使用标准输入输出流来读取和写入文件，而文件IO是指使用文件指针来读取和写入文件。 标准IO是C语言标准库中的一部分，它提供了一些基本的输入/输出函数，例如printf、scanf、puts等。这些函数可以用来...
标准io流复制文件
06-27
标准io流复制文件
无缓存IO操作和标准IO文件操作区别
05-30
无缓存I/O操作与标准I/O文件操作之间的主要区别在于数据处理的层次和缓存机制。系统调用是操作系统内核提供给应用程序的一种接口，允许应用程序请求内核执行特定的任务，如I/O操作。在I/O操作中，无论是无缓存还是...
标准io流获取文件长度
06-27
标准io流获取文件长度
C++:53---IO库（标准输入输出流(iostream)、文件流(fstream)、string流(sstream)）
董哥的黑板报
03-04 1061
一、IO库 IO库主要分为三大类： iostream：标准输入输出流 fstream：文件的输入输出流 sstream：string对象流 宽字符类型： 为了支持宽字符的语言，标准库定义了一组类型和对象来操纵wchar_t类型的数据 宽字符版本的类型和函数的名字以一个w开始。例如，wcin、wcout、wcerr是分别对应cin、cout、cerr的宽字符版对象 ...
Linux文件IO与标准IO
qq_54924532的博客
07-28 288
文件io于标准io
标准IO与文件IO
m0_70983574的博客
06-27 1072
Linux标准IO的一些读写操作讲解
标准I/O库的缓冲模式
pcj_888的博客
03-22 356
问题描述 有时候，代码中明明执行了printf语句打印到终端，却没有看到输出的内容。 写文件的时候，明明成功执行了fwrite, fprintf语句，文件却没有写入相应的内容。 想搞清楚这些问题产生的原因，需要了解标准I/O库的缓冲模式。 标准I/O与unbuffered I/O linux对I/O文件操作分为不带缓存I/O(unbuffered I/O)和带缓存I/O(即标准I/O) 《APUE...
linux 之文件基础 (三)、标准IO的两个概念：流、缓冲区
江南又一春
03-30 1106
1. 标准IO的一些概念 文件IO中使用了文件描述符的概念，但是并不是所有操作系统都提供文件描述符这样抽象的机制。因此 文件IO 的那一套函数，可以在类unix系统下使用。但是换做别的系统，就没有了文件描述符的概念。而c标准库，为我们提供了一套函数叫做标准IO。无论在什么系统上，我们都可以使用标准IO 所提供的函数。标准IO相当于在所有的操作系统的实现上提供了一层封装，使用标准IO 函数 进行IO...
Linux----标准IO文件操作函数总结
weixin_52042488的博客
07-12 553
本文主要讲解了Linux下标准IO库函数，有： fopen—fclose feof—ferror—clearer fflush fseek—rewind—ftell fgets—fputs gets—puts fprintf—printf—sprintf fgetc—fputc fread—fwrite同时针对一部分函数提供了代码示例，便于学习......
Linux——标准IO
qq_43441284的博客
12-29 656
概念：一组相关数据的有序集合文件的类型：常规文件-r目录文件-d字符设备文件-c：键盘块设备文件-b:U盘 磁盘管道文件-p套接字文件-s符号链接文件-I：快捷方式。
IO流原理及流的分类
zjjcchina的博客
07-22 121
I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。Java程序中，对于数据的输入/输出操作以”流(stream)”的方式进行。java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。...
嵌入式Linux标准IO，刷新流fflush(),流定位ftell()/fseek()/rewind()，流出错和结束ferror()/feof()
m0_37542524的博客
11-01 460
fopen()打开一个普通文件时，默认是全缓冲 fputs(&amp;amp;quot;abc\n&amp;amp;quot;,fp);//此时，往流中写入的字符串只是在流的缓冲区里，只有当缓冲区满，或流关闭的时候，缓冲里的内容才会写到实际的文件中 去掉while(1)死循环，则流会关闭，关闭前自动刷新，缓冲区中的内容会被强制保存进文件 使用fflush()强制刷新流，缓冲区中的内容会被写入文件

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

深センのHZ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值