Linux系统的I/O也就是一般所说的低级I/O——操作系统提供的基本IO服务,与os绑定,特定于Linux平台。而标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性。两者一个显著的不同点在于,标准I/O默认采用了缓冲机制,比如调用fopen函数,不仅打开一个文件,而且建立了一个缓冲区(读写模式下将建立两个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构。低级I/O一般没有采用缓冲,需要自己创建缓冲区,不过在Linux系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。

aaarticlea/png;base64,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" alt="" />

ANSI C定义了一组高级输入输出函数,成为标准I/O库,为程序员提供了Linux I/O的较高级别的替代。这个库(libc)提供了打开和关闭文件的函数(fopen和fclose)、读和写字节的函数(fread和fwrite)、读和写字符串的函数(fgets和fputs)、以及复杂的格式化I/O函数(printf和scanf)。

标准I/O库将一个打开的文件模型化为一个流。对于程序员而言一个流就是一个指向FILE类型的结构的指针。类型为FILE的流是对文件描述符和缓冲区的抽象。流的缓冲区的目的和RIO读缓冲区的目的是一样的:就是使开销较高的Linux I/O系统调用的次数尽可能的减少。例如,假如我们有一个程序,反复调用标准I/O的getc函数,每次调用返回文件的下一个字符。当第一次调用getc函数时,库函数通过调用一次read系统调用来填充流缓冲区,然后将缓冲区中的第一个字节返回给应用程序。只要缓冲区中还有未读的字节,接下来对getc函数的调用就能直接从流缓冲区中得到服务,而不必去调用开销较高的Linux I/O系统调用。

文本流是由一系列行组成的,每一行的结尾是一个换行符。如果系统没有遵循这种模式,则标准库将通过一些措施使得该系统适应这种模式。例如,标准库可以在输入端将回车符和换页符都转换成换行符,而在输出端进行反向转换。

最简单的输入机制是使用getchar()函数从标准输入中(一般为键盘)一次读取一个字符,getchar函数在每次被调用的时候返回下一个输入字符。若遇到文件结尾,则返回EOF。符号常量EOF在头文件stdio.h中定义为-1,但程序中应该使用EOF来测试文件是否结束,这样才能保证程序同EOF的特定值无关。

1.fopen与open

标准I/O使用fopen函数打开一个文件:

FILE* fp=fopen(const char* path,const char*mod)

其中path是文件名,mod用于指定文件打开的模式的字符串,比如"r","w","w+","a"等等,可以加上字母b用以指定以二进制模式打开(对于Linux系统,只有一种文件类型,因此没有区别),如果成功打开,返回一个FILE文件指针,如果失败返回NULL,这里的文件指针并不是指向实际的文件,而是一个关于文件信息的数据包,其中包括文件使用的缓冲区信息。

Linux系统使用open函数用于打开一个文件:

int fd=open(char *name,int how);

与fopen类似,name表示文件名字符串,而how指定打开的模式:O_RDONLY(只读),O_WRONLY(只写),O_RDWR (可读可写),还有其他模式请man 2 open。成功返回一个正整数称为文件描述符,这与标准I/O显著不同,失败的话返回-1,与标准I/O返回NULL也是不同的。

2.fclose与close

与打开文件相对的,标准I/O使用fclose关闭文件,将文件指针传入即可,如果成功关闭,返回0,否则返回EOF

比如:

if(fclose(fp)!=0)
printf("Error in closing file");

而Linux使用close用于关闭open打开的文件,与fclose类似,只不过当错误发生时返回的是-1,而不是EOF,成功关闭同样是返回0。C语言用error code来进行错误处理的传统做法。

3.读文件,getc,fscanf,fgets和read

标准I/O中进行文件读取可以使用getc,一个字符一个字符的读取,也可以使用gets(读取标准io读入的)、fgets以字符串单位进行读取(读到遇到的第一个换行字符的后面),gets(接受一个参数,文件指针)不判断目标数组是否能够容纳读入的字符,可能导致存储溢出(不建议使用),而fgets使用三个参数:

char* fgets(char *s, int size, FILE *stream);

第一个参数和gets一样,用于存储输入的地址,第二个参数为整数,表示输入字符串的最大长度,最后一个参数就是文件指针,指向要读取的文件。最后是fscanf,与scanf类似,只不过增加了一个参数用于指定操作的文件,比如fscanf(fp,"%s",words)

Linux系统中使用read函数用于读取open函数打开的文件,函数原型如下:

ssize_t numread=read(int fd,void*buf,size_t qty);

其中fd就是open返回的文件描述符,buf用于存储数据的目的缓冲区,而qty指定要读取的字节数。如果成功读取,就返回读取的字节数目(小于等于qty)。

4.判断文件结尾,如果尝试读取达到文件结尾,标准IO的getc会返回特殊值EOF,而fgets碰到EOF会返回NULL,而对于Linux的read函数,情况有所不同。read读取qty指定的字节数,最终读取的数据可能没有你所要求的那么多(qty),而当读到结尾再要读的话,read函数将返回0.

5.写文件:putc,fputs,fprintf和write

与读文件相对应的,标准C语言I/O使用putc写入字符,比如:

putc(ch,fp);

第一个参数是字符,第二个是文件指针。而fputs与此类似:

fputs(buf,fp);

仅仅是第一个参数换成了字符串地址。而fprintf与printf类似,增加了一个参数用于指定写入的文件,比如:

fprintf(stdout,"Hello%s.\n","dennis");

切记fscanf和fprintf将FILE指针作为第一个参数,而putc,fputs则是作为第二个参数。

在系统中提供write函数用于写入文件,原型与read类似:

ssize_t result=write(int fd,void *buf,size_t amt);

fd是文件描述符,buf是将要写入的内存数据,amt是要写的字节数。如果写入成功返回写入的字节数,通过result与amt的比较可以判断是否写入正常,如果写入失败返回-1。write函数仅仅是将数据写入了缓冲区,何时写入磁盘由内核决定,如果要强制写入硬盘,那么在open的时候选择O_SYNC选项,或者调用fsync函数

6.随机存取:fseek()、ftell()和lseek()

标准I/O使用fseek和ftell用于文件的随机存取,先看看fseek函数原型

int fseek(FILE *stream, long offset, intwhence);

第一个参数是文件指针,第二个参数是一个long类型的偏移量(offset),表示从起始点开始移动的距离。第三个参数就是用于指定起始点的模式,stdio.h指定了下列模式常量:

SEEK_SET            文件开始处

SEEK_CUR            当前位置

SEEK_END            文件结尾处

看几个调用例子:

fseek(fp,0L,SEEK_SET);  //找到文件的开始处
fseek(fp,0L,SEEK_END); //定位到文件结尾处
fseek(fp,2L,SEEK_CUR); //文件当前位置向前移动2个字节数

而ftell函数用于返回文件的当前位置,返回类型是一个long类型,比如下面的调用:

fseek(fp,0L,SEEK_END);//定位到结尾
long last=ftell(fp); //返回当前位置

那么此时的last就是文件指针fp指向的文件的字节数。

与标准I/O类似,Linux系统提供了lseek来完成fseek的功能,原型如下:

off_t lseek(int fildes, off_t offset, intwhence);

fildes是文件描述符,而offset也是偏移量,whence同样是指定起始点模式,唯一的不同是lseek有返回值,如果成功就返回指针变化前的位置,否则返回-1。因此可以通过下列方法模拟ftell函数来返回当前偏移量:

off_t   currpos;
currpos = lseek(fd, 0, SEEK_CUR);

whence的取值与fseek相同:SEEK_SET,SEEK_CUR,SEEK_END,但也可以用整数0,1,2相应代替。

最后,以一个例子结尾,通过c语言编写linux系统的cp指令,先看看使用标准I/O版本的:

#include<stdio.h>
#include<stdlib.h>
void oops(char *,char *);
int main(int ac,char *av[])
{
FILE *in,*out;
intch; if(ac!=3){
fprintf(stderr,"Useage:%s source-file target-file.\n",av[0]);
exit(1);
}
if((in=fopen(av[1],"r"))==NULL)
oops("can not open ",av[1]);
if((out=fopen(av[2],"w"))==NULL)
oops("can not open ",av[2]);
while((ch=getc(in))!=EOF)
putc(ch,out);
if(fclose(in)!=0||fclose(out)!=0)
oops("can not close files.\n"," ");
return 0;
}
void oops(char *s1,char* s2)
{
fprintf(stderr,"Error:%s %s\n",s1,s2);
exit(1);
}

再看一个使用Linux io的版本:

#include<unistd.h>
#include<stdio.h>
#include<fcntl.h> #define BUFFERSIZE 4096
#define COPYMODE 0644
void oops(char *,char *); int main(int ac,char *av[])
{
intin_fd,out_fd,n_chars;
char buf[BUFFERSIZE];
if(ac!=3){
fprintf(stderr,"useage:%s source-file target-file.\n",av[0]);
exit(1);
} if((in_fd=open(av[1],O_RDONLY))==-1)
oops("Can't open ",av[1]);
if((out_fd=creat(av[2],COPYMODE))==-1)
oops("Can't open ",av[2]);
while((n_chars=read(in_fd,buf,BUFFERSIZE))>0)
if(write(out_fd,buf,n_chars)!=n_chars)
oops("Write error to ",av[2]);
if(n_chars==-1)
oops("Read error from ",av[1]);
if(close(in_fd)==-1||close(out_fd)==-1)
oops("Error closing files","");
return 0;
}
void oops(char *s1,char *s2)
{
fprintf(stderr,"Error:%s",s1);
perror(s2);
exit(1);
}

显然,在使用Linux i/o的时候,你要更多地关注缓冲问题以提高效率,而stdio则不需要考虑。

Linux系统编程(1)——文件与I/O之C标准I/O函数与系统调用I/O的更多相关文章

  1. linux系统编程之文件与io(一)

    经过了漫长的学习,C语言相关的的基础知识算是告一段落了,这也是尝试用写博客的形式来学习c语言,回过头来看,虽说可能写的内容有些比较简单,但是个人感觉是有史起来学习最踏实的一次,因为里面的每个实验都是自 ...

  2. linux系统编程之文件与io(五)

    上一节中已经学习了文件描述符的复制,复制方法有三种,其中最后一种fcntl还并未使用到,关于这个函数,不光只有复制文件描述符的功能,还有其它一些用法,本节就对其进行一一剖析: fcntl常用操作: 这 ...

  3. Linux系统编程:简单文件IO操作

    使用Linux的文件API,经常看见一个东西,叫做文件描述符. 什么是文件描述符? (1)文件描述符其实实质是一个数字,这个数字在一个进程中表示一个特定的含义,当我们open打开一个文件时,操作系统在 ...

  4. linux系统编程之文件与IO(一):文件描述符、open,close

    什么是IO? 输入/输出是主存和外部设备之间拷贝数据的过程 设备->内存(输入操作) 内存->设备(输出操作) 高级I/O ANSI C提供的标准I/O库称为高级I/O,通常也称为带缓冲的 ...

  5. linux系统编程之文件与io(四)

    今天继续学习文件与io,主要是学习文件共享及文件.复制文件描述符,有点抽象,主要是概念上的理解,但是很重要,下面一一来分解: 文件共享: 回顾一下,在linux系统调用中,是通过文件描述符来访问文件的 ...

  6. linux系统编程之文件IO

    1.打开文件的函数open,第一个参数表示文件路径名,第二个为打开标记,第三个为文件权限 代码: #include <sys/types.h> #include <sys/stat. ...

  7. linux系统编程之文件与IO(二):系统调用read和write

    read系统调用 一旦有了与一个打开文件描述相连的文件描述符,只要该文件是用O_RDONLY或O_RDWR标志打开的,就可以用read()系统调用从该文件中读取字节 函数原型: #include &l ...

  8. Linux系统编程:文件I/O编程

    文件I/O操作在Linux编程时是经常会使用到的一个内容,通常可以把比较大的数据写到一个文件中来进行存储或者与其他进程进行数据传输,这样比写到一个全局数组或指针参数来实现还要方便好多. 一.文件常用操 ...

  9. linux系统编程之文件与IO(七):时间函数小结

    从系统时钟获取时间方式 time函数介绍: 1.函数名称: localtime 2.函数名称: asctime 3.函数名称: ctime 4.函数名称: difftime 5.函数名称: gmtim ...

随机推荐

  1. java.lang.OutOfMemoryError: GC overhead limit exceeded 问题分析和解决(转)

    在项目历史数据导入过程中,出现了应用无法访问的情况.立刻对Weblogic进行分析,发现Weblogic的内存.线程等性能良好,Server也是Running的状态.随后查看了Weblogic日志,在 ...

  2. mutate 转换

    zjtest7-frontend:/usr/local/logstash-2.3.4/config# cat geoip.conf input {stdin {} } filter { geoip { ...

  3. Intel处理器 天梯图

    http://www.mydrivers.com/zhuanti/tianti/cpu/ 更新日期: 2016年6月 纠      错: wenq#mydrivers.com   Core 2及之前 ...

  4. 【转】git与github在ubuntu下的使用 -- 不错

    原文网址:http://www.cnblogs.com/cocowool/archive/2010/10/19/1855616.html 最近开始使用git对kohana3的文档做一些补充的工作,使用 ...

  5. 做一个有理想的IT人

    前段时间一直以来都在思考生命的价值的问题,一直在想人的一生的追求是什么.在这个物欲横流的社会,对人的价值的定义只是在财富积累的多少,这个是大多数人所认为的.但人的一生顶多百年,百年之后这些虚荣划归为尘 ...

  6. What’s the difference between an interface and an abstract class in Java?

    原文 What’s the difference between an interface and an abstract class in Java? It’s best to start answ ...

  7. 雅虎工程师初始化css

    /*css reset code */ /**** 文字大小初始化,使1em=10px *****/ body { font-size:62.5%; } /* for IE/Win */ html&g ...

  8. pyqt QTreeWidget例子学习

    # -*- coding: utf-8 -*- # python:2.x __author__ = 'Administrator' from PyQt4.QtGui import  * from Py ...

  9. iOS 面试常见问题最全梳理

    序言 目前形势,参加到iOS队伍的人是越来越多,甚至已经到供过于求了.今年,找过工作人可能会更深刻地体会到今年的就业形势不容乐观,加之,培训机构一火车地向用人单位输送iOS开发人员,打破了生态圈的动态 ...

  10. CLR via C# - GC

    //像背书一样,记录下吧 1.CLR分配资源 托管堆上维护着一个指针NextObjPtr.该指针表示下一个新建对象在托管堆上的位置.C#的new Object会产生IL newobj指令,NextOb ...