精华内容
下载资源
问答
  • 标准IO和文件IO的区别

    千次阅读 2010-02-04 09:27:00
     标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,具有一定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO提供了三种类型缓存。 ...

    作者:王珊珊    华清远见嵌入式学院讲师

    先来了解下什么是标准IO以及文件IO。

      标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准的IO提供了三种类型的缓存。

      (1)全缓存:当填满标准IO缓存后才进行实际的IO操作。
            (2)行缓存:当输入或输出中遇到新行符时,标准IO库执行IO操作。
            (3)不带缓存:stderr就是了。

      文件IO:文件IO称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务,与os绑定,特定于linix或unix平台。

      2区别

      首先:两者一个显著的不同点在于,标准I/O默认采用了缓冲机制,比如调用fopen函数,不仅打开一个文件,而且建立了一个缓冲区(读写模式下将建立两个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构。低级I/O一般没有采用缓冲,需要自己创建缓冲区,不过其实在linix或unix系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。

      其次从操作的设备上来区分,文件I/O主要针对文件操作,读写硬盘等,它操作的是文件描述符,标准I/O针对的是控制台,打印输出到屏幕等,它操作的是字符流。对于不同设备得特性不一样,必须有不同api访问才最高效。

      最后来看下他们使用的函数  

     

    标准IO

    文件IO(低级IO)

    打开

    fopen,freopen,fdopen

    open

    关闭

    fclose

    close

    getc,fgetc,getchar
    fgets,gets
    fread

    read

    putc,fputc,putchar
    fputs,puts,
    fwrite

    write

      1.fopen与open

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

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

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

      文件IO使用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");

      而文件IO使用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)
    文件IO中使用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,而对于*nix的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则是作为第二个参数。

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

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

      fd是文件描述符,buf是将要写入的内存数据,amt是要写的字节数。如果写入成功返回写入的字节数,通过result与amt的比较可以判断是否写入正常,如果写入失败返回-1

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

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

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

      第一个参数是文件指针,第二个参数是一个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类似,*nix系统提供了lseek来完成fseek的功能,原型如下:

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

      fildes是文件描述符,而offset也是偏移量,whence同样是指定起始点模式,唯一的不同是lseek有返回值,如果成功就 返回指针变化前的位置,否则返回-1。whence的取值与fseek相同:SEEK_SET,SEEK_CUR,SEEK_END,但也可以用整数 0,1,2相应代替。

      “本文由华清远见http://www.embedu.org/index.htm提供”

    展开全文
  • 一、先来了解下什么是文件I/O和标准I/O: 文件I/O:文件I/O称之为不带缓存的IO(unbuffered I/O)。不带缓存指是每个read,write都调用内核中一个系统调用。也就是一般所说低级I/O——操作系统提供基本IO服务...

    一、先来了解下什么是文件I/O和标准I/O:

    文件I/O:文件I/O称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务,与os绑定,特定于linix或unix平台。

    标准I/O:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性。标准I/O库处理很多细节。例如缓存分配,以优化长度执行I/O等。标准的I/O提供了三种类型的缓存。

    (1)全缓存:当填满标准I/O缓存后才进行实际的I/O操作。
    (2)行缓存:当输入或输出中遇到新行符时,标准I/O库执行I/O操作。
    (3)不带缓存:stderr就是了。

    二、二者的区别

    文件I/O 又称为低级磁盘I/O,遵循POSIX相关标准。任何兼容POSIX标准的操作系统上都支持文件I/O。标准I/O被称为高级磁盘I/O,遵循ANSI C相关标准。只要开发环境中有标准I/O库,标准I/O就可以使用。(Linux 中使用的是GLIBC,它是标准C库的超集。不仅包含ANSI C中定义的函数,还包括POSIX标准中定义的函数。因此,Linux 下既可以使用标准I/O,也可以使用文件I/O)。

    通过文件I/O读写文件时,每次操作都会执行相关系统调用。这样处理的好处是直接读写实际文件,坏处是频繁的系统调用会增加系统开销,标准I/O可以看成是在文件I/O的基础上封装了缓冲机制。先读写缓冲区,必要时再访问实际文件,从而减少了系统调用的次数。

    文件I/O中用文件描述符表现一个打开的文件,可以访问不同类型的文件如普通文件、设备文件和管道文件等。而标准I/O中用FILE(流)表示一个打开的文件,通常只用来访问普通文件。

    三、最后来看下他们使用的函数

    标准IO 文件IO(低级IO)
    打开 fopen,freopen,fdopen open
    关闭 fclose close
    getc,fgetc,getchar,fgets,gets,fread read
    putc,fputc,putchar,fputs,puts,fwrtie write

    1.fopen与open

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

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

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

    文件IO使用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”);

    而文件IO使用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)
    文件IO中使用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,而对于*nix的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则是作为第二个参数。

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

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

    fd是文件描述符,buf是将要写入的内存数据,amt是要写的字节数。如果写入成功返回写入的字节数,通过result与amt的比较可以判断是否写入正常,如果写入失败返回-1

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

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

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

    第一个参数是文件指针,第二个参数是一个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类似,*nix系统提供了lseek来完成fseek的功能,原型如下:

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

    fildes是文件描述符,而offset也是偏移量,whence同样是指定起始点模式,唯一的不同是lseek有返回值,如果成功就 返回指针变化前的位置,否则返回-1。whence的取值与fseek相同:SEEK_SET,SEEK_CUR,SEEK_END,但也可以用整数 0,1,2相应代替。

    四、系统调用与库函数

    上面我们一直在讨论文件I/O与标准I/O的区别,其实可以这样说,文件I/O是系统调用、标准I/O是库函数,看下面这张图:
    在这里插入图片描述

    POSIX:Portable Operating System Interface 可移植操作系统接口

    ANSI:American National Standrads Institute 美国国家标准学会

    1、系统调用

    操作系统负责管理和分配所有的计算机资源。为了更好地服务于应用程序,操作系统提供了一组特殊接口——系统调用。通过这组接口用户程序可以使用操作系统内核提供的各种功能。例如分配内存、创建进程、实现进程之间的通信等。

    为什么不允许程序直接访问计算机资源?答案是不安全。单片机开发中,由于不需要操作系统,所以开发人员可以编写代码直接访问硬件。而在32位嵌入式系统中通常都要运行操作系统,所以开发人员可以编写代码直接访问硬件。而在32位嵌入式系统中通常都要运行操作系统,程序访问资源的方式都发生了改变。操作系统基本上都支持多任务,即同时可以运行多个程序。如果允许程序直接访问系统资源,肯定会带来很多问题。因此,所有软硬件资源的管理和分配都有操作系统负责。程序要获取资源(如分配内存,读写串口)必须由操作系统来完成,即用户程序向操作系统发出服务请求,操作系统收到请求后执行相关的代码来处理。

    用户程序向操作系统提出请求的接口就是系统调用。所有的操作系统都会提供系统调用接口,只不过不同的操作系统提供的系统调用接口各不相同。Linux 系统调用接口非常精简,它继承了Unix 系统调用中最基本的和最有用的部分。这些系统调用按照功能大致可分为进程控制、进程间通信、文件系统控制、存储管理、网络管理、套接字控制、用户管理等几类。

    2、库函数

    库函数可以说是对系统调用的一种封装,因为系统调用是面对的是操作系统,系统包括Linux、Windows等,如果直接系统调用,会影响程序的移植性,所以这里使用了库函数,比如说C库,这样只要系统中安装了C库,就都可以使用这些函数,比如printf() scanf()等,C库相当于对系统函数进行了翻译,使我们的APP可以调用这些函数;

    3、用户编程接口API

    前面提到利用系统调用接口程序可以访问各种资源,但在实际开发中程序并不直接使用系统调用接口,而是使用用户编程接口(API)。为什么不直接使用系统调用接口呢?

    原因如下:

    1)系统调用接口功能非常简单,无法满足程序的需求。

    2)不同操作系统的系统调用接口不兼容,程序移植时工作量大。

    用户编程接口通俗的解释就是各种库(最重要的就是C库)中的函数。为了提高开发效率,C库中实现了很多函数。这些函数实现了常用的功能,供程序员调用。这样一来,程序员不需要自己编写这些代码,直接调用库函数就可以实现基本功能,提高了代码的复用率。使用用户编程接口还有一个好处:程序具有良好的可移植性。几乎所有的操作系统上都实现了C库,所以程序通常只需要重新编译一下就可以在其他操作系统下运行。

    用户编程接口(API)在实现时,通常都要依赖系统调用接口。例如,创建进程的API函数fork()对应于内核空间的sys_fork()系统调用。很多API函数西亚我哦通过多个系统调用来完成其功能。还有一些API函数不要调用任何系统调用。

    在Linux 中用户编程接口(API)遵循了在Unix中最流行的应用编程界面标准——POSIX标准。POSIX标准是由IEEE和ISO/IEC共同开发的标准系统。该标准基于当时想用的Unix 实践和经验,描述了操作系统的系统调用编程接口(实际上就是API),用于保证应用程序可以在源代码一级商多种操作系统上运行。这些系统调用编程接口主要是通过C库(libc )实现的。

    展开全文
  • 标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,具有一定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO提供了三种类型缓存。 ...

    “本文转载自华清远见嵌入式学院http://www.embedu.org/index.htm


    首先了解下什么是标准IO以及文件IO。

    标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准的IO提供了三种类型的缓存。

    (1)全缓存:当填满标准IO缓存后才进行实际的IO操作。 (2)行缓存:当输入或输出中遇到新行符时,标准IO库执行IO操作。 (3)不带缓存:stderr就是了。

    文件IO:文件IO称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务,与os绑定,特定于linix或unix平台。


    主要的区别:

    首先:两者一个显著的不同点在于,标准I/O默认采用了缓冲机制,比如调用fopen函数,不仅打开一个文件,而且建立了一个缓冲区(读写模式下将建立两个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构。低级I/O一般没有采用缓冲,需要自己创建缓冲区,不过其实在linix或unix系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。

    其次从操作的设备上来区分,文件I/O主要针对文件操作,读写硬盘等,它操作的是文件描述符,标准I/O针对的是控制台,打印输出到屏幕等,它操作的是字符流。对于不同设备得特性不一样,必须有不同api访问才最高效。

    最后来看下他们使用的函数

         

    标准IO

    文件IO(低级IO)

    打开

    fopen,freopen,fdopen

    open

    关闭

    fclose

    close

    getc,fgetc,getcharfgets,getsfread

    read

    putc,fputc,putcharfputs,puts,fwrite

    write


    1.fopen与open

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

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

    其中path是文件名,mod用于指定文件打开的模式的字符串,比如"r","w","w+","a"等等,可以加上字母b用以指定以二进制模式打开(对于 NULL,这里的文件指针并不是指向实际的文 件,而是一个关于文件信息的数据包,其中包括文件使用的缓冲区信息。

    文件IO使用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");

    而文件IO使用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)文件IO中使用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,而对于nix的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则是作为第二个参数。在文件IO中提供write函数用于写入文件,原型与read类似:

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

    fd是文件描述符,buf是将要写入的内存数据,amt是要写的字节数。如果写入成功返回写入的字节数,通过result与amt的比较可以判断是否写入正常,如果写入失败返回-1。


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

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

    int fseek(FILE stream, long offset, int whence);

    第一个参数是文件指针,第二个参数是一个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, int whence);

    fildes是文件描述符,而offset也是偏移量,whence同样是指定起始点模式,唯一的不同是lseek有返回值,如果成功就 返回指针变化前的位置,否则返回-1。whence的取值与fseek相同:SEEK_SET,SEEK_CUR,SEEK_END,但也可以用整数 0,1,2相应代替。

    展开全文
  • 标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,具有一定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO提供了三种类型缓存。  (1...

    标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准的IO提供了三种类型的缓存。
      (1)全缓存:当填满标准IO缓存后才进行实际的IO操作。 (2)行缓存:当输入或输出中遇到新行符时,标准IO库执行IO操作。 (3)不带缓存:stderr就是了。
      文件IO:文件IO称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务,与os绑定,特定于linix或unix平台。
      2区别
      首先:两者一个显著的不同点在于,标准I/O默认采用了缓冲机制,比如调用fopen函数,不仅打开一个文件,而且建立了一个缓冲区(读写模式下将建立两个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构。低级I/O一般没有采用缓冲,需要自己创建缓冲区,不过其实在linix或unix系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。
      其次从操作的设备上来区分,文件I/O主要针对文件操作,读写硬盘等,它操作的是文件描述符,标准I/O针对的是控制台,打印输出到屏幕等,它操作的是字符流。对于不同设备得特性不一样,必须有不同api访问才最高效。

     

    标准 IO 与文件 IO 的区别标准 IO 与文件 IO 比较

    文件IO

    标准IO

    POSIX 系统调用

    ANSI C 库函数

    低层次 IO

    高层次 IO,对系统调用的扩展和封装

    只能在 POSIX 操作系统上移植

    可移植到任何操作系统

    非缓冲 IO

    缓冲 IO

    利用文件描述符操作文件

    利用文件指针操作文件

     

    读写普通文件,还可以读写设备文件管

     

     

    一般用于读写普通文件

     

    道等

     

     

                 

    在谈两者区别之前,先来了解下什么是标准IO以及文件IO。

    1定义

    标准IO:

    标准 I/O 是 ANSI C 建立的一个标准 I/O 模型,是一个标准函数包和 stdio.h 头中的定义,具有一定的可移植性。标准 IO 库处理很多细节。例如缓存分配,以优化长度执行 IO 等。标准的 IO 提供了三种类型的缓存。

    1. 全缓存:当填满标准 IO 缓存后才进行实际的 IO 操作。
    2. 行缓存:当输入或输出中遇到新行符时,标准 IO 库执行 IO 操作。
    3. 不带缓存:stderr 就是了。

    文件IO:

    文件IO称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read, write 都调用内核中的一个系统调用。也就是一般所说的低级 I/O——操作系统提供的基本 IO 服务,与 os 绑定,特定于*nix 平台。

    2区别

    首先:两者一个显著的不同点在于,标准 I/O 默认采用了缓冲机制,比如调用 fopen 函数,不仅打开一个文件,而且建立了一个缓冲区读写模式下将建立一个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构

    (FILE *)。低级 I/O 一般没有采用缓冲,需要自己创建缓冲区,不过其实在

    *nix 系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。使用标准 IO 就不需要自己维护缓冲区了,标准 IO 库会根据 stdin/stdout 来选择缓冲类型,也就是说当你使用标准 IO 的时候,要清楚它的 stdin/stdou 是什么类型以及其默认的缓冲模式,如果不合适,你需要用 setvbuf 设置,再使用,例如协同进程的标准输入和输出的类型都是管道,所以其默认的缓冲类型是全缓冲的,如果要使用标准 IO,就需要现设置行缓冲。对于文件 IO,只要你自己能维护好缓冲区,完全可以不用标准 IO。

    其次从名字上来区分,文件 I/O 主要针对文件操作,读写硬盘等,标准

    I/O,主要是打印输出到屏幕等。因为他们设备不一样,文件 io 针对的是文件,标准 io 是对控制台,操作的是字符流。对于不同设备得特性不一样,必须有不同 api 访问才最高效。

    最后来看下他们使用的函数

     

    标准IO

    文件IO(低级 IO)

    打开

    fopen,freopen,fdopen

    open

    关闭

    fclose

    close

    getc,fgetc,getchar fgets,gets

    fread

    read

    putc,fputc,putchar fputs,puts,

    fwrite

    write

     

     

     

    1.fopen 与 open

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

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

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

    *nix 系统使用 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");

    而*nix 使用 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)

    *nix 系统中使用 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,而对于*nix 的 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 则是作为第二个参数。

    在*nix 系统中提供 write 函数用于写入文件,原型与 read 类似:ssize_t result=write(int fd,void *buf ,size_t amt);fd 是文件描述符,buf 是将要写入的内存数据,amt 是要写的字节数。如果写入成功返回写入的字节数,通过 result 与 amt 的比较可以判断是否写入正常,如果写入失败返回-1

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

    标准 I/O 使用 fseek 和 ftell 用于文件的随机存取,先看看 fseek 函数原型 int fseek(FILE *stream, long offset, int whence);第一个参数是文件指针,第二个参数是一个 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 类似,*nix 系统提供了 lseek 来完成 fseek 的功能,原型如下:

    off_t lseek(int fildes, off_t offset, int whence); fildes 是文件描述符,而 offset

    也是偏移量,whence 同样是指定起始点模式,唯一的不同是 lseek 有返回值,如果成功就返回指针变化前的位置,否则返回-1。whence 的取值与 fseek 相同: SEEK_SET,SEEK_CUR,SEEK_END,但也可以用整数 0,1,2 相应代替。

    lseek : fseek + ftell;

     

    展开全文
  • 文件IO操作通过文件描述符来完成 当程序运行时候,系统会默认打开3个流:标准输入、标准输出、标准错误,所对应文件描述符分别是0、1、2 #include <fcntl.h> int open(const char *...
  • 标准IO和文件IO区别

    2019-08-01 20:58:01
    标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,具有一定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO提供了三种类型缓存。 (1...
  • 标准IO和文件IO

    2017-05-19 14:54:46
    标准IO和文件IO的区别 标准IO带缓冲机制,文件IO不带缓冲机制。文件IO和标准IO的函数实现
  • 标准文件IO和系统文件IO的区别 标准文件IO:fopen() fclose() fread() fwrite() fseek() 系统文件IO:open() close() read() write() lseek() 区别:标准文件IO只能读写普通文本文件和二进制文件;系统文件IO...
  • 标准IO文件IO 的区别 作者:王姗姗,华清远见嵌入式学院讲师。 先来了解下什么是标准IO以及文件IO标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包stdio.h头文件中的定义,...
  • 标准IO文件IO的区别

    2020-04-19 07:49:25
    标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,具有一定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO提供了三种类型缓存。 (1...
  • 文件IO和标准IO的区别

    2021-03-25 11:57:25
    一、先来了解下什么是文件I/O和标准I/O: 文件I/O:文件I/O称之为不带缓存的IO(unbuffered I/O)。不带缓存指是每个read,write都调用内核中一个系统调用。也就是一般所说低级I/O——操作系统提供基本IO...
  • 标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,拥有必定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO供给了三种类型缓存。 (1...
  •  标准IO:标准I/O是ANSI C建立一个标准I/O模型,是一个标准函数包stdio.h头文件中定义,具有一定可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准IO提供了三种类型缓存。 ...
  • 一、什么是文件I/O和标准I/O: 文件I/O:文件I/O称之为不带缓存的IO(unbuffered I/O)。不带缓存指是每个read,write都调用内核中一个系统调用。也就是一般所说低级I/O——操作系统提供基本IO服务,与os绑定...
  • 嵌入式标准IO和文件IO

    2019-07-30 01:05:19
    标准IO文件IO的区别 文件IO 标准IO 直接调用内核提供的系统调用函数,头文件是unistd.h 间接调用系统调用函数,头文件是stdio.h

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 431
精华内容 172
关键字:

标准io和文件io的区别