精华内容
下载资源
问答
  • 2018-07-06 14:06:24

    前提:很早之前学完了朱有鹏老师的裸机课程,后来就没有看新的课程,去年大三出来实习到现在工作块一年了。感觉关于linux方面不是很清楚,然后购买了朱老师的Linux应用编程和网络编程的课程。此笔记大部分内容是老师上课的课件。

    1.什么是文件IO?

        IO就是input/output,文件IO就是对于文件的读写操作。

    2.什么是操作系统API?

        (1)API是一些函数,这些函数是由linux系统提供支持的,由应用层程序来使用。
        (2)应用层程序通过调用API来调用操作系统中的各种功能,来干活。

        (3)学习一个操作系统,其实就是学习使用这个操作系统的API。    

        note:API和函数?api其实本质上就是函数,但是更强调的是一个功能,你不需要关心api是怎么实现的,只知道调用它就可以实现功能就行。函数一般来说指自己写的功能块。

    3.Linux常用的文件IO接口

        write、read、open、close、lseek

    4.文件操作的一般步骤

        (1)在linux系统中要操作一个文件,一般是先open打开一个文件,得到一个文件描述符,然后对文件进行读写操作(或其他操作),最后close关闭文件即可
        (2)强调一点:我们对文件进行操作时,一定要先打开文件,打开成功后才能去操作(如果打开本身失败,后面就不用操作了);最后读写完成之后一定要close关闭文件,否则可能会造成文件损坏。
        (3)文件平时是存在块设备中的文件系统中的,我们把这种文件叫静态文件。当我们去open打开一个文件时,linux内核做的操作包括:内核在进程中建立了一个打开文件的数据结构,记录下我们打开的这个文件;内核在内存中申请一段内存,并且将静态文件的内容从块设备中读取到内存中特定地址管理存放(叫动态文件)。
        (4)打开文件后,以后对这个文件的读写操作,都是针对内存中这一份动态文件的,而并不是针对静态文件的。当我们对动态文件进行读写后,此时内存中的动态文件和块设备中的静态文件就不同步了,当我们close关闭动态文件时,close内部内核将内存中的动态文件的内容去更新(同步)块设备中的静态文件。
        (5)常见的一些现象:
    第一个:打开一个大文件时比较慢
    第二个:我们写了一半的文件,如果没有点保存直接关机/断电,重启后文件内容丢失。
        (6)为什么要这么设计?

    因为块设备本身有读写限制(回忆NnadFlash、SD等块设备的读写特征),本身对块设备进行操作非常不灵活。而内存可以按字节为单位来操作,而且可以随机操作(内存就叫RAM,random),很灵活。所以内核设计文件操作时就这么设计了。    

    5.重要概念:文件描述符

    (1)文件描述符其实实质是一个数字,这个数字在一个进程中表示一个特定的含义,当我们open打开一个文件时,操作系统在内存中构建了一些数据结构来表示这个动态文件,然后返回给应用程序一个数字作为文件描述符,这个数字就和我们内存中维护这个动态文件的这些数据结构挂钩绑定上了,以后我们应用程序如果要操作这一个动态文件,只需要用这个文件描述符进行区分。
    (2)一句话讲清楚文件描述符:文件描述符就是用来区分一个程序打开的多个文件的。

    (3)文件描述符的作用域就是当前进程,出了当前进程这个文件描述符就没有意义了    


    note:以前只知道文件描述符代表是一个程序已打开的一个文件,除此一无所知。现在知道其实文件描述符在内核中会放置在一张叫做文件描述表中,文件描述符作为数组index,而对应的内容为文件表指针,文件表就是每个已打开的文件在内存中的详细信息,便于内核定位与操作。

    更多相关内容
  • Node.js文件系统-文件流操作(四)

    千次阅读 2021-12-15 10:00:32
    上篇介绍了关于文件的删除、复制、重命名等操作,本篇将介绍文件流操作是对大型数据文件管理、传输高效地处理方式。 /** * 文件流操作 */ const fs = require("fs"); const path = require("path"); ...

    上篇介绍了关于文件的删除、复制、重命名等操作,本篇将介绍文件的流操作。流是对大型数据文件管理、传输高效地处理方式。

    /**
     * 文件流操作
     */
    
    const fs = require("fs");
    const path = require("path");
    const zlib = require("zlib");
    
    var targetFilePath = path.join(__dirname,"HelloWorld.txt");
    var targetOutPath = path.join(__dirname,"input.txt");
    //压缩文件路径
    var targetZipPath = path.join(__dirname,"HelloWorld.txt.gz");
    
    var data = "";
    
    //-----------一般的文件流操作------------------------
    //文件读取流
    var readSteam = fs.createReadStream(targetFilePath);
    readSteam.setEncoding("UTF8");
    
    readSteam.on("data",(chunk)=>{
        data += chunk;
    });
    
    //读取完成
    readSteam.on("end",()=>{
       console.log("文件读取完成内容:",data);
    });
    
    readSteam.on("error",(err)=>{
        console.log("文件读取错误:",err);
    });
    
    //文件写入流
    var writeStream = fs.createWriteStream(targetOutPath);
    
    writeStream.on("finish",()=>{
        console.log("文件写入完成!");
    });
    
    writeStream.on("error",(err)=>{
        console.log("文件写入错误:",err);
    });
    
    
    //从源文件读取时,将读取的数据写入到目标文件
    readSteam.pipe(writeStream);
    
    
    
    //-------文件流的链式操作------------
    //1.文件压缩处理
    fs.createReadStream(targetFilePath).pipe(zlib.createGzip()).pipe(fs.createWriteStream(targetZipPath));
    //2.文件解压处理
    fs.createReadStream(targetZipPath).pipe(zlib.createGunzip()).pipe(fs.createWriteStream(targetFilePath));

    【注意】可以通过屏蔽注释某些代码接口,测试各个接口,查看它们的执结果。

    Helloworld.txt文件内容写入到新文件input.txt中。

     

     文件HelloWorld压缩成Helloworld.txt.gz文件

     

     文件解压缩效果图(略)。使用流接口处理文件,是比较推荐的方式。

    展开全文
  • Node.js数据(Stream接口)1 概述2 什么是3 从中读取4 写入5 管道4 链式 1 概述 数据读写可以看作是事件模式(Event)的特例,不断发送的数据块好比一个个的事件。读数据是read事件,写数据是write事件...

    1 概述

    数据读写可以看作是事件模式(Event)的特例,不断发送的数据块好比一个个的事件。读数据是read事件,写数据是write事件,而数据块是事件附带的信息。Node 为这类情况提供了一个特殊接口Stream。

    “数据流”(stream)是处理系统缓存的一种方式。操作系统采用数据块(chunk)的方式读取数据,每收到一次数据,就存入缓存。Node应用程序有两种缓存的处理方式:

    1、所有数据接收完毕后,一次性从缓存读取(传统方式)。优点:符合直觉,流程非常自然;缺点:如果遇到大文件,要花很长时间,才能进入数据处理的步骤。

    2、采用“数据流”的方式,收到一块数据,就读取一块。优点:提高了程序的性能。

    2 什么是流

    流是可以从一个源读取或写入数据到连续的目标对象。在Node.js,有四种类型的数据流:

    • Readable:用于读操作。
    • Writable:用在写操作。
    • Duplex:用于读取和写入操作。
    • Transform:输出基于输入的地方进行计算的一种双相流。

    每种流都是事件触发器,当某个流被调用时,就会触发,抛出一个事件,一些常用的事件是:

    事件说明
    data表示流中有数据可以读取
    end表示流中没有数据可以读取
    error读写数据错误时触发
    finish数据刷新到底层系统时触发

    3 从流中读取

    fs模块的createReadStream方法,就可以创建一个读取数据的数据流。

    示例代码:

    const fs = require("fs");
    let data = "";
    
    //建立一个输入流
    let readerStream = fs.createReadStream("./out.txt");
    //设置字符集
    readerStream.setEncoding("UTF8");
    //绑定流事件-->data,end,and error
    readerStream.on("data", function (chunk) {
        data += chunk;
    })
    readerStream.on("end", function () {
        console.log(data);
    })
    readerStream.on("error", function (err) {
        console.log(err.stack);
    })
    console.log("程序结束");
    

    在这里插入图片描述
    上述程序将out.txt中的内容读出来了。

    4 写入流

    fs模块的createWriteStream方法,就可以创建一个写数据的数据流。

    示例代码:

    var fs = require("fs");
    var data = "橘猫吃不胖";
    
    //创建一个写入流
    var writerStream = fs.createWriteStream('./out.txt');
    //设置写入数据的字符集
    writerStream.write(data, 'UTF8');
    //文件结束退出
    writerStream.end();
    //绑定流事件 --> finish,and error
    writerStream.on("finish", function () {
        console.log("写入结束");
    });
    writerStream.on("error", function (err) {
        console.log(err.stack);
    });
    console.log("程序结束");
    

    在这里插入图片描述
    本程序将out.txt文件中的内容更新为了:橘猫吃不胖,原本的古诗被删除了。

    5 管道流

    管道是供一个流的输出作为输入到另一个流的机制。它通常被用于从一个流中获取数据,并通过该流输出到另一个流。

    示例:一个管道从一个文件中读取和写入到另一个文件

    var fs = require("fs");
    //创建一个可读流
    var readerStream = fs.createReadStream("./out.txt");
    //创建一个可写流
    var writerStream = fs.createWriteStream("./output.txt");
    //通过管道进行读和写操作
    //读取out.txt,并将数据写入output.txt
    readerStream.pipe(writerStream);
    console.log("程序结束");
    

    在这里插入图片描述
    原本的out.txt文件中含有内容:橘猫吃不胖,运行本程序后,output.txt文件中也包含该内容(原本有output.txt文件并且该文件是空文件)。

    4 链式流

    链式是一个机制,一个流的输出连接到另一个流,并创建一个链多流操作。它通常用于管道的操作。

    示例:使用管道和链接先压缩文件,然后解压缩
    zlib模块:用于对文件的压缩和解压缩

    示例代码:压缩文件

    const fs = require("fs");
    const zlib = require("zlib");
    
    //创建一个读数据的流
    let readerStream = fs.createReadStream("./out.txt").pipe(zlib.createGzip()).pipe(fs.createWriteStream("./out.zip"));
    
    readerStream.on("error", function (err) {
        console.log(err.stack);
    })
    console.log("-----程序结束-----");
    

    在这里插入图片描述
    在文件夹中出现了一个压缩包:out.zip

    示例代码:解压文件

    const fs = require("fs");
    const zlib = require("zlib");
    
    fs.createReadStream("./test.zip").pipe(zlib.createGunzip()).pipe(fs.createWriteStream("./output.txt"))
    

    文件夹中的test.zip文件被解压成了output.txt文件。

    展开全文
  • 汇总:C语言文件操作接口实例解析

    千次阅读 2019-01-16 20:43:40
    写在前面 计算机文件是以计算机...通过文件指针就可对它所指的文件进行各种操作,C语言规定该文件指针类型为FILE型。 FILE文件指针结构体定义: typedef struct { short level; // 缓冲区“满”或“空”的程...

    写在前面

    计算机文件是以计算机硬盘为载体存储在计算机上的信息集合,是存储在某种长期储存设备上的一段数据流。在C语言中用一个指针变量指向一个文件,这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作,C语言规定该文件指针类型为FILE型。

    FILE文件指针结构体定义:

    typedef struct
    {
        short level;            // 缓冲区“满”或“空”的程度
        unsigned flags;         // 文件状态标志
        char fd;                // 文件描述符
        unsigned char hold;     // 如缓冲区无内容不读取字符
        short bsize;            // 缓冲区的大小
        unsigned char *buffer;  // 数据缓冲区的位置
        unsigned ar *curp;      // 指针当前的指向
        unsigned istemp;        // 临时文件指示器
        short token;            // 用于有效性检查
    }FILE;
    

    例如我们定义一个文件指针:FILE *fp; fp指向某一个文件的文件信息区(是一个结构体变量),通过该文件信息区就能够访问该文件。如下图所示:
    在这里插入图片描述
    ps:文件缓冲区:缓冲文件系统是指系统自动地在内存区为程序中每一个正在使用的文件开辟一个文件缓冲区。从内存向磁盘输出数据必须先送到内存中的缓冲区,装满缓冲区后才一起送到磁盘中去。

    OK,接下来咱们认识一下C语言方面的文件操作接口。

    1.打开和关闭文件

    fopen 函数说明:

    #include <stdio.h>
    #define F_PATH "d:\\myfile\\file.dat"
     
    int main(void)
    {
        FILE *fp = NULL; /* 需要注意 */
        fp = fopen(F_PATH, "r");
        if (NULL == fp)
        {
            return -1; /* 要返回错误代码 */
        }
        fclose(fp);
        fp = NULL; /* 需要指向空,否则会指向原打开文件地址 */
        return 0;
    }
    

    作用:用来打开一个文件

    格式:FILE * fopen(const char * path,const char * mode);

    返回值:打开文件成功返回一个文件指针,若打开文件失败则返回NULL

    参数说明:

    *path:字符串包含欲打开的文件路径及文件名(例如:D:\\A.txt),注意在C语言中欲输出一个"\"则需要输两个"\\" 
    
    *mode:代表着流形态,mode有下列几种形态字符串:
    
                r      打开只读文件,该文件必须存在。 
    
                r+    打开可读写的文件,该文件必须存在。 
    
                rb+  读写打开一个二进制文件,只允许读写数据。
    
                rt+   读写打开一个文本文件,允许读和写。 
    
                w      打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。  
    
                w+    打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
    
                a       以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。(EOF符保留)
    
                a+     以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。(原来的EOF符不保留)
    
                wb    只写打开或新建一个二进制文件;只允许写数据。
    
                wb+  读写打开或建立一个二进制文件,允许读和写。  
    
                wt+   读写打开或着建立一个文本文件;允许读写。  
    
                at+    读写打开一个文本文件,允许读或在文本末追加数据。  
    
                ab+   读写打开一个二进制文件,允许读或在文件末追加数据。  
    
                上述的形态字符串都可以再加一个b字符,如rb、w+b或ab+等组合,加入b 字符用来告诉函数库打开的文件为二进制文件,而非纯文字文件。*
    

    fclose 函数说明:

    作用:关闭一个文件流,释放文件指针

    格式:int fclose( FILE *fp );

    返回值:如果流成功关闭,fclose 返回 0,否则返回EOF

    参数说明:

    *fp:需要关闭的文件指针
    

    注:在文件操作完成后我们应该调用该函数来关闭文件,如果不关闭文件将可能会丢失数据。因为在向文件写入数据时会先将数据输出到缓冲区,待缓冲区充满后才正式输出给文件。

    2.顺序读写数据文件

    fgetc 函数说明:

    #include<stdio.h>
    void main()
    {
        FILE *fp;
        int c;
        fp=fopen("exist","r");
        while((c=fgetc(fp))!=EOF)
            printf("%c",c);
        fclose(fp);
    }
    

    作用:从文件指针指向的文件流中读取一个字符,读取一个字节后,光标位置后移一个字节

    格式:int fgetc(FILE *stream);

    返回值:返回所读取的一个字节,如果读到文件末尾或者读取出错时返回EOF(EOF是文件结束标识符,一般值为-1)

    参数说明:

    *stream:文件指针,从该文件指针指向的文件中读取一个字符,然后将光标后移一个字节
    

    fputc 函数说明:

    #include <stdio.h>
    #include <string.h>
    int main(void)
    {
      char msg[]="Hello world";
      int i=0;
    while(msg[i]&&(i<strlen(msg)))
    {
      fputc(msg[i],stdout);
      i++;
    }
     return 0;
    }
    

    作用:将指定字符写到文件指针所指向的文件的当前写指针位置上

    格式:int fputc (char c, File *fp);

    返回值:在正常调用情况下,函数返回写入文件的字符的ASCII码值,出错时,返回EOF

    参数说明:

    c:需要写入的字符
    
    *fp:文件指针,在当前文件指针所指向的文件的当前写指针位置上写入一个字符c,然后文件内部写指针会自动后移一个字节位置
    

    fgets 函数说明:
    例:

    如果一个文件的当前位置的文本如下
    Love, I Have
    Since you can do it.
    
    如果用fgets(str1,6,file1);去读取
    则执行后str1 = "Love," ,读取了6-1=5个字符
    这个时候再执行fgets(str1,20,file1)则执行后str1 = " I Have\n"
    
    而如果
    fgets(str1,23,file1);
    则执行str1="Love ,I Have",读取了一行(包括行尾的'\n',并自动加上字符串
    结束符'\0'),当前文件位置移至下一行,虽然23大于当前行上字符总和,可是
    不会继续到下一行。而下一次调用fgets()继续读取的时候是从下一行开始读。
    

    格式:char *fgets(char *buf, int bufsize, FILE *stream);
    作用:从文件结构体指针stream中读取数据,每次读取一行。读取的数据保存在buf指向的字符数组中,每次最多读取bufsize-1个字符(第bufsize个字符赋’\0’),如果文件中的该行,不足bufsize个字符,则读完该行就结束。如若该行(包括最后一个换行符)的字符数超过bufsize-1,则fgets只返回一个不完整的行,但是,缓冲区总是以NULL字符结尾,对fgets的下一次调用会继续读该行。

    返回值:函数成功将返回buf,失败或读到文件结尾返回NULL。因此我们不能直接通过fgets的返回值来判断函数是否是出错而终止的,应该借助feof函数或者ferror函数来判断。

    参数说明:

    *buf: 字符型指针,指向用来存储所得数据的地址。  
    
    bufsize: 整型数据,指明存储数据的大小。  
    
    *stream: 文件指针,将要读取的文件流。
    

    fputs 函数说明:

    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
      char str[80]="asdhfdf\n";
      FILE *fp = NULL;
      if((fp=fopen("strfile.txt","w"))==NULL)
    {
      printf("cannot open file\n");
      exit(0);
    }
      fputs(str,fp);
    //putchar(str);
      fclose(fp);
      fp = NULL;
      return 0;
    }
    

    作用:向指定的文件写入一个字符串(不自动写入字符串结束标记符‘\0’)

    格式:int fputs(char *str, FILE *fp);

    返回值:若成功返回0,失败返回EOF

    参数说明:

    *str: 需要写入的字符串   
    
    *fp: 文件指针,将要写入的文件流
    

    fprintf 函数说明:

    //...
    #include <cstdio>
    int main(void) {
        FILE *FSPOINTER;
        char STRBUFF[16] = "Hello World.";
        //...
        FSPOINTER = fopen("HELLO.TXT", "w+");
        //...
        fprintf(FSPOINTER, "%s", STRBUFF);
        //...
        return 0;
    }
    输出至文件HELLO.TXT:
    Hello World
    

    作用:格式化后输出到文件中

    格式:int fprintf (FILE* stream, const char* format, [argument]);

    返回值:若成功返回值是输出的字符数,当发生错误时返回一个负值

    参数说明:

    *stream:文件指针
    
    *format:输出格式
    
    [argument]:附加参数列表
    

    注:用法与printf函数类似,这里只是参数多了一个文件指针,将格式后的结果输出到文件中

    fscanf 函数说明:

    #include <stdlib.h>
    #include <stdio.h>
    int main(void)
    {
        int i;
        printf("Input an integer:");
        /*从标准输入中读取一个整数*/
        if(fscanf(stdin, "%d",&i))
        printf("The integer read was:%d\n", i);
        else
        {
            fprintf(stderr, "Error reading an integer from stdin.\n");
            exit(1);
        }
        return 0;
    }
     
    返回EOF如果读取到文件结尾。
    

    作用: 其功能为根据数据格式(format)从输入流(stream)中读入数据(存储到argument);与fgets的差别在于:fscanf遇到空格和换行时结束,注意空格时也结束,fgets遇到空格不结束。

    格式:int fscanf(FILE* stream,constchar* format,[argument]);

    返回值:成功返回读入的参数的个数,失败返回EOF。

    参数说明:

    *stream:文件指针
    
    *format:格式字符串
    
    [argument]:输入列表
    

    注:用法与scanf函数类似

    fread 函数说明:

    #include<stdio.h>
    #include<string.h>
    int main(void)
    {
        FILE*stream;
        char msg[]="this is a test";
        char buf[20];
        if((stream=fopen("DUMMY.FIL","w+"))==NULL)
        {
            fprintf(stderr,"Can not open output file.\n");
            return 0;
        }
        /*write some data to the file*/
        fwrite(msg,1,strlen(msg)+1,stream);
        /*sizeof(char)=1 seek to the beginning of the file*/
        fseek(stream,0,SEEK_SET);
        /*read the data and display it*/
        fread(buf,strlen(msg)+1,1,stream);
    
        printf("%s\n",buf);
        fclose(stream);
        return 0;
    }
    

    作用:从一个文件流中读数据,最多读取count个元素,每个元素size字节

    格式:size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;

    返回值:如果调用成功返回实际读取到的元素个数,如果不成功或读到文件末尾返回0

    参数说明:

    *buffer:用于接收数据的内存地址
    
    size:要读的每个数据项的字节数,单位是字节
    
    count:要读count个数据项,每个数据项size个字节
    
    *stream:文件指针
    

    注:这个函数以二进制形式对文件进行操作,不局限于文本文件

    fwrite 函数说明:

    #include <stdio.h>
    struct mystruct
    {
        int i;
        char cha;
    };
     
    int main(void)
    {
        FILE *stream;
        struct mystruct s;
        if ((stream = fopen("TEST.$$$", "wb")) == NULL) /* open file TEST.$$$ */
        {
            fprintf(stderr, "Cannot open output file.\n");
            return 1;
        }
        s.i = 0;
        s.cha = 'A';
        fwrite(&s, sizeof(s), 1, stream); /* 写的struct文件*/
        fclose(stream); /*关闭文件*/
        return 0;
    

    作用:向文件写入一个数据块

    格式:size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);

    返回值:返回实际写入的数据块数目

    参数说明:

    *buffer:是一个指针,对fwrite来说,是要获取数据的地址;
    
    size:要写入内容的单字节数
    
    count:要进行写入size字节的数据项的个数
    
    *stream:文件指针
    

    注:这个函数以二进制形式对文件进行操作,不局限于文本文件

    四、随机读写数据文件

    rewind 函数说明:

    #include <stdio.h>
    #include <dir.h>
    int main(void)
    {
      FILE *fp;
      char fname[10] = "TXXXXXX", *newname, first;
      //mktempC语言创建临时文件
      newname = mktemp(fname);
      fp = fopen(newname,"w+");
      if(NULL==fp)
      return 1;
      
      fprintf(fp,"abcdefghijklmnopqrstuvwxyz");
      
      rewind(fp);
      
      fscanf(fp,"%c",&first);
      printf("The first character is: %c\n",first);
      fclose(fp);
      //remove()函数用来删除指定的文件
      remove(newname);
      return 0;
    }
    

    作用:将文件内部的位置指针重新指向一个流(数据流/文件)的开头

    格式:void rewind(FILE *stream);

    返回值:无

    参数说明:

    *stream:文件指针
    

    ftell 函数说明:

    #include <stdio.h>
    int main(void)
    {
      FILE *stream;
      stream = fopen("MYFILE.TXT", "w+");
      fprintf(stream, "This is a test");
      
      printf("The file pointer is at byte \
      %ld\n", ftell(stream));
      
      fclose(stream);
      return 0;
    }
    

    作用:得到文件位置指针当前位置相对于文件首的偏移字节数(测定文件位置标记的当前位置)

    格式:long ftell(FILE *stream);

    返回值:成功返回当前文件位置,失败返回-1L

    参数说明:

    *stream:文件指针
    

    注:因为ftell返回long型,根据long型的取值范围-231~231-1(-2147483648~2147483647),故对大于2.1G的文件进行操作时出错。

    fseek 函数说明:

    //ftell一般用于读取文件的长度,结合fseek()读取文本文件中的内容:
    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
      FILE *fp;
      int flen;
      char *p;
    
    /* 以只读方式打开文件 */
    if((fp = fopen ("1.txt","r"))==NULL)
    {
      printf("\nfile open error\n");
      exit(0);
    }
    
      fseek(fp,0L,SEEK_END); /* 定位到文件末尾 */
      flen=ftell(fp); /* 得到文件大小 */
      p=(char *)malloc(flen+1); /* 根据文件大小动态分配内存空间 */
    
      if(p==NULL)
     {
        fclose(fp);
       return 0;
    }
    
      fseek(fp,0L,SEEK_SET); /* 定位到文件开头 */
      fread(p,flen,1,fp); /* 一次性读取全部文件内容 */
      p[flen]='\0'; /* 字符串结束标志 */
      printf("%s",p);
    
      fclose(fp);
      free(p);
      return 0;
    }
    

    作用:重定位流(数据流/文件)上的文件内部位置指针

    格式:int fseek(FILE *stream, long offset, int origin);

    返回值:成功返回0,失败返回非0值

    参数说明:

    *stream:文件指针
    
    offset:偏移量,正数表示正向偏移,负数表示负向偏移。因为是long型数据,所以应在数字后面加一个字母L
    
    origin:设定从文件的哪里开始偏移,可取值为:SEEK_CUR、 SEEK_END 或 SEEK_SET,详见下表:
    

    名字 起始点 用数字代表
    SEEK_SET 文件开始位置 0
    SEEK_CUR 文件当前位置 1
    SEEK_END 文件末尾位置 2

    示例:

    fseek(fp,100L,0); // 把位置指针移动到离文件开头100字节处
    fseek(fp,100L,1); // 把位置指针移动到离文件当前位置100字节处
    fseek(fp,-100L,2); // 把位置指针退回到离文件结尾100字节处

    五、文件读写的出错检测

    ferror 函数说明:

    作用:在调用各种输入输出函数(如 putc、getc、fread、fwrite等)时,如果出现错误,除了函数返回值有所反映外,还可以用ferror函数检查

    格式:int ferror(FILE *stream);

    返回值:返回0表示未出错,返回非0值表示出错

    参数说明:

    *stream:文件指针
    

    clearerr 函数说明:

    作用:使文件错误标志和文件结束标志置为0。假设在调用一个输入输出函数时出现了错误,ferror函数值为一个非零值。在调用clearerr(fp)后,ferror(fp)的值变为0。只要出现错误标志,就一直保留,直到对同一文件调用clearerr函数或rewind函数,或任何其他一个输入输出函数。

    格式:void clearerr(FILE *stream);

    返回值:无

    参数说明:

    *stream:文件指针
    

    补充:clearerr函数的作用是清除由stream指向的文件流的文件尾标识和错误标识。它没有返回值,也未定义任何错误。你可以通过使用它从文件流的错误状态中恢复。

    综合ferror()和clearerr()的使用,举个例子:

    #include<stdio.h>
    int  main(void)
    {
       FILE*stream;
      
      /*openafileforwriting*/
      stream=fopen("DUMMY.FIL","w");
    
      /*forceanerrorconditionbyattemptingtoread*/
      (void)getc(stream);
      
      if(ferror(stream))/*testforanerroronthestream*/
    {
    
      /*displayanerrormessage*/
       printf("ErrorreadingfromDUMMY.FIL\n");
      /*resettheerrorandEOFindicators*/
       clearerr(stream);
    }
     
        fclose(stream);
        return0;
    }
    

    OK,总结完毕么么哒(づ ̄ 3 ̄)づ。

    展开全文
  • 1.文件操作的主要接口API

    千次阅读 2016-03-13 19:41:48
    1.1.什么是应用编程 1.2.操作系统API和文件IO接口 1.3.文件操作的一般步骤 1.4.文件描述符 1.5.打开文件和关闭文件 1.6.实时查询man手册 1.7.读取文件内容 1.8.向文件写入
  • 1 的概念         “是磁盘或其它外围设备中存储的数据的源点或终点。”。这是在《C程序设计语言》上的原话。 据我的理解,主要是指一种逻辑上的概念,它提供或...
  • 文件的区别

    千次阅读 2015-10-07 00:54:18
    前面介绍的Linux下的文件编程所涉及...对于编程来说,首先对文件所映射的进行操作,然后分阶段将相应的数据写入文件,极大地提高了相应的操作效率。Linux也提供了很多操纵库函数,称为标准I/O库,是ISO C的组成部
  • C语言的文件操作(一)

    千次阅读 2021-05-21 01:20:01
    C语言的文件操作(一)一.文件定义及分类概念:文件是指一组相关数据的有序集合,这个数据集有一个名称,即为文件名。§1 普通文件:普通文件是驻留在磁盘或其他外部介质上的一个有序数据集,可以是源文件、目标...
  • 操作系统文件知识概括

    千次阅读 2020-09-03 19:44:45
    操作系统文件知识概括文件磁盘 文件 文件定义: 一组有意义的信息的集合 一个文件有哪些属性? 文件名:由创建文件的用户决定文 件名,主要是为了方便用户找到文 件,同一目录下不允许有重名文件。 标识符:一个...
  • 操作系统之文件管理

    千次阅读 多人点赞 2020-09-22 03:05:15
    一、文件文件系统 1.1 文件是什么 文件是对磁盘的抽象 所谓文件是指一组带标识(标识即为文件名)的、在逻辑上有完整意义的信息项的序列。...从操作系统角度:怎样组织、管理文件 * 文件的描述、分类
  • JAVA WEB接口开发简述

    2021-02-12 09:35:22
    基本了解当我们想去访问其他网站的接口时候,而又不想要登录验证等操作,那么可以选择使用平台提供的接口进行调用得到我们需要的信息。比如说,一个网站A有一个接口路径:...
  • linux操作系统 第09章 操作系统接口

    千次阅读 2020-07-21 11:26:36
    第9章 操作系统接口  9.1 操作系统接口概述9.1.1 作业与作业调度  按操作系统的术语,用户是以提交“作业”的形式来使用系统的。因此,操作系统的接口可以看作是用户提交作业的接口。  1. 作业的概念  作业...
  • 文件和IO

    千次阅读 2019-12-07 10:07:46
    IO文件 回顾 Collection |_____List (特点:有序的,可以重复) |___ArrayList (存储结构:数组) |___LinkedList (存储结构:链表) |___Vector 数组 |___Stack 数组(栈)先进后出 |_____...
  • 到底什么是文件描述符???

    千次阅读 多人点赞 2021-10-28 10:10:51
      不管是学习语言还是学习操作系统,IO是我们学习过程中不可获取的一个阶段,在这一部分我们会学习打开文件、读写文件操作,在C语言中我们打开文件调用的是C语言的库函数接口,像fopen打开,fclose关闭,fputs...
  • 超详细|一篇搞定操作系统——文件管理

    千次阅读 多人点赞 2021-01-06 00:28:16
    文章目录5.1 文件管理概述5.2 文件结构5.2.1 文件的逻辑结构5.2.2 文件的物理结构5.3 文件目录管理5.4 文件的存储设备5.4.1 文件的存储...所以在操作系统中又增加了文件管理功能,即构成一个文件系统,负责管理在外存
  • 博主声明: 转载请在开头附加本文链接及作者信息,并标记... I/O 关于数据的存储,分为内部存储和外部存储。内部存储就像内存一样,是一种临时性的对数据进行储存的方式,这种方式存储的数据量不大,但是获...
  • 简述Linux系统结构

    千次阅读 2021-05-09 05:53:30
    Linux,全称GNU/Linux,是一种免费使用和自由传播的类UNIX操作系统,同时也是一个基于POSIX和Unix的多用户、多任务、支持多线程和多CPU的操作系统。Linux不仅系统性能稳定,而且是开源软件。其核心防火墙组件性能...
  • 前端文件下载常用方法及原理解析

    千次阅读 2021-07-16 11:27:00
    文件下载是前端开发中一个常见的功能,目前主流的下载实现主要有两种:静态文件直接下载和文件流下载 直接下载 顾名思义,直接下载即通过浏览器的文件策略直接下载文件。通常用于下载静态文件。 实现方法 常用的方法...
  • 什么是Linux操作系统及其功能

    千次阅读 2021-05-16 03:20:58
    导读:操作系统是计算机用户和计算机硬件之间的接口。它是一个管理计算机硬件资源并为计算机程序提供通用服务的软件集合。操作系统的定位是OS,而且,它是计算机中系统软件的重要组成部分。OS的主要目的是提供一种...
  • 对象(序列化机制)详解

    千次阅读 2021-02-20 16:47:00
    使用对象序列化操作2.使用对象反序列化操作 一、理解对象及序列化机制 1.对象作用 用于存储和读取基本数据类型数据或对象的处理。它的强大之处就是可以把Java中的对象写入到文件源中(序列化),也能把...
  • 不同的操作系统需要使用不同类型的文件系统,为了与其他操作系统兼容,以相互交换数据,通常操作系统都能支持多种类型的文件系统,比如Windows2000 Server,系统默认或推荐采用的文件系统是NTFS,但同时也支持FAT32或...
  • Java_io_流简述

    千次阅读 2013-05-04 18:57:50
    本博客为子墨原创,转载请注明出处... IO的本质是数据传输,根据数据传输特性将抽象为各种类,方便更直观的进行数据操作。  2.io分类  (1).数据的方向:输入和输出。   对输入只能进行读
  • Linux文件系统详解

    万次阅读 多人点赞 2019-05-29 16:07:53
    操作系统的角度详解Linux文件系统层次、文件系统分类、文件系统的存储结构、不同存储介质的区别(RAM、ROM、Flash)、存储节点inode。本文参考: http://blog.chinaunix.net/uid-8698570-id-1763151.html ...
  • 摘要:读完本章节,您对java 的IO有更清晰深刻的认识,对适配器模式、...从中取得数据的操作称为提取操作,亦称读操作;而向中添加数据的操作称为插入操作,亦称写操作。用来进行输入输出操作就称为IO...
  • 目录 文章目录目录Linux 文件系统目录结构文件系统类型虚拟文件系统文件类型 Linux 文件系统 文件系统是文件存放在磁盘...一个操作系统的运行离不开对文件操作,因此必然要拥有并维护自己的文件系统。 目录结构 和...
  • 容器技术简述

    千次阅读 多人点赞 2022-05-07 11:15:45
    好处:容器运行的时候就不再依赖宿主机上的文件操作系统类型和配置。帮助开发者跳过设置冗杂的开发环境,不用担心不同环境下的软件运行的环境配置问题(将应用程序的配置和所有依赖打包成一个镜像在容器中)。 1.3 ...
  • 计算机操作系统-1-总览

    千次阅读 2022-03-08 09:09:07
    计算机操作系统-1-总览
  • 文章目录写在前面的话uploader介绍用法与代码小程序前端后台接口 WebAPI采坑记录 写在前面的话 最近又自己在折腾微信小程序了。最新的一个功能中需要实现图片上传。幸运的是,微信小程序扩展能力中有现成的文件上传...
  • 接口测试理念及目的

    千次阅读 2022-01-14 14:00:36
    我们为什么需要接口测试? 接口的分类 与 对应测试方法 1.HTTP HTTPS RESTFUL 2.RPC 3.WebSocket 4.WebService 5.FTP、SMTP 接口文档系统 接口自动化测试

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,426
精华内容 10,170
关键字:

简述文件操作的流接口