精华内容
参与话题
问答
  • 本课程主要讲解linux中的文件读写和IO处理,包括API的概念、open函数的重要flag、linux内核管理文件的原理、inode和vnode、文件共享、标准IO等。终目的是让大家理解并掌握在linux中使用API和库函数进行文件操作的...
  • 标准IO与文件IO

    千次阅读 2016-12-30 16:34:21
    linux下文件操作包含下面4个头文件

      对于操作系统而言,I/O操作可以分为两类,一类是带缓存的IO,又称为标准IO(C标准库中提供了标准IO库,即stdio),它实现了跨平台的用户缓存解决方案。另一类是Unix/Linux下的文件IO,又称直接IO,即文件访问机制不经过操作系统内核的缓存,数据直接在磁盘和应用程序地址空间进行传输。相对而言,直接IO效率更高。本篇文章将从文件的打开、读写等方面来介绍这两类IO操作。

    一.标准IO

        标准IO在系统调用的上一层多加了一个缓冲区,也因此引入了流的概念,在UNIX/Linux下表示为FILE*(并不限于UNIX/Linux,ANSI C都有FILE的概念),FILE实际上包含了为管理流所需要的所有信息:实际I/O的文件描述符,指向流缓存的指针(标准I/O缓存,由malloc分配,又称为用户态进程空间的缓存,区别于内核所设的缓存),缓存长度,当前在缓存中的字节数,出错标志等。标准I/O对每个I/O流自动进行缓存管理,它提供了三种类型的缓存:

              1) 全缓存。当填满标准I/O缓存后才执行I/O操作。磁盘上的文件通常是全缓存的。
              2) 行缓存。当输入输出遇到新行符或缓存满时,才由标准I/O库执行实际I/O操作。stdin、stdout通常是行缓存的。
              3) 无缓存。相当于read、write了。stderr通常是无缓存的,因为它必须尽快输出。

        在linux的缓存IO机制中,操作系统会将IO的数据缓存在文件系统的页缓存(page cache)中,也就是说,数据会先被拷贝到操作系统内核的缓存区中,然后才会从操作系统内核的缓存区拷贝到应用程序的地址空间。标准I/O库在关闭流的时候自动释放缓存。另外,也可以使用函数fflush()将流所有未写的数据送入(刷新)到内核(内核缓冲区),fsync()将所有内核缓冲区的数据写到文件(磁盘)。第一次调用带缓存的文件操作函数时,标准库会自动分配内存并且读出一段固定大小的内容存储在缓存中。所以以后每次的读写操作并不是针对硬盘上的文件直接进行的,而是针对内存中的缓存的。何时从硬盘中读取文件或者向硬盘中写入文件有标准库的机制控制。实际上,标准IO最终还是通过调用系统提供的不带缓存的IO实现的(每次read/write都进行一次系统调用),标准IO的引入,避免了频繁的系统调用,减少了系统资源消耗,提高了IO效率。

       以fgetc/fputc 为例,当用户程序第一次调用fgetc 读一个字节时,fgetc 函数可能通过系统调用进入内核读1K字节到I/O缓冲区中,然后返回I/O缓冲区中的第一个字节给用户,把读写位置指 向I/O缓冲区中的第二个字符,以后用户再调fgetc ,就直接从I/O缓冲区中读取,而不需要进内核了,当用户把这1K字节都读完之后,再次调用fgetc时,fgetc函数会再次进入内核读1K字节到I/O缓冲区中。在这个场景中用户程序、C标准库和内核之间的关系就像在“Memory Hierarchy”中CPU、Cache和内存之间的关系一样,C标准库之所以会从内核预读一些数据放在I/O缓冲区中,是希望用户程序随后要用到这些数据,C标准库的I/O缓冲区也在用户空间,直接从用户空间读取数据比进内核读数据要快得多。另一方面,用户程序调用fputc通常只是写到I/O缓冲区中,这样fputc函数可以很快地返回,如果I/O缓冲区写满了,fputc 就通过系统调用把I/O缓冲区中的数据传给内核,内核最终把数据写回磁盘或设备。有时候用户程序希望把I/O缓冲区中的数据立刻传给内核,让内核写回设备或磁盘,这称为Flush操作,对应的库函数是fflush,fclose函数在关闭文件之前也会做Flush操作

        标准IO具有以下优点:(1)使用了操作系统内核缓冲区,在一定程度上分离了应用程序空间和实际的物理设备。(2)减少了直接读盘次数,提高性能。当应用程序尝试读取某块数据的时候,如果这块数据已经存放在了页缓存中,那么这块数据就可以立即返回给应用程序,而不需要经过实际的物理读盘操作。当然,如果数据在应用程序读取之前并未被存放在页缓存中,那么就需要先将数据从磁盘读到页缓存中去。对于写操作来说,应用程序也会将数据先写到页缓存中去,数据是否被立即写到磁盘上去取决于应用程序所采用的写操作机制:如果用户采用的是同步写机制( synchronous writes ), 那么数据会立即被写回到磁盘上,应用程序会一直等到数据被写完为止;如果用户采用的是延迟写机制( deferred writes ),那么应用程序就完全不需要等到数据全部被写回到磁盘,数据只要被写到页缓存中去就可以了。在延迟写机制的情况下,操作系统会定期地将放在页缓存中的数据刷到磁盘上。与异步写机制( asynchronous writes )不同的是,延迟写机制在数据完全写到磁盘上的时候不会通知应用程序,而异步写机制在数据完全写到磁盘上的时候是会返回给应用程序的。所以延迟写机制本身是存在数据丢失的风险的,而异步写机制则不会有这方面的担心。

        为了说明标准IO中缓存区的存在,参考下面代码的执行和输出:

    #include <stdio.h>
    #include <stdlib.h>
    #include <fcntl.h>
    
    int main(int argc, char *argv[])
    {
    	char temp[100];
    	FILE *myfile =stdin;
    	printf("before reading----------------\n");
    	printf("file buffer base: %p\n",myfile->_IO_read_base);
    	printf("read buffer length %ld\n", myfile->_IO_read_end - myfile->_IO_read_base);
    	printf("write buffer base %p\n", myfile->_IO_write_base);
    	printf("write buffer length %ld\n", myfile->_IO_write_end - myfile->_IO_write_base);
    	printf("buf buffer base %p\n", myfile->_IO_buf_base);
    	printf("buf buffer length %ld\n", myfile->_IO_buf_end - myfile->_IO_buf_base);
    	printf("\n");
    	printf("Please Enter: ");
    	fgets(temp, 100, myfile);
    	fputs(temp, myfile);
    	printf("\n");
    	printf("after reading-----------------\n");
    	printf("read FILE buffer base %p\n", myfile->_IO_read_base);
    	printf("read FILE buffer length %ld\n", myfile->_IO_read_end - myfile->_IO_read_base);
    	printf("write FILE buffer base %p\n", myfile->_IO_write_base);
    	printf("write FILE buffer length %ld\n", myfile->_IO_write_end - myfile->_IO_write_base);
    	printf("FILE buffer base %p\n", myfile->_IO_buf_base);
    	printf("FILE buffer length %ld\n", myfile->_IO_buf_end - myfile->_IO_buf_base);
    	
    	exit(0);	
    }


    输出:


    可以看出,在执行gfets之前,myfile缓存区是没有分配内存的,执行完fget后,myfile的缓存区才被分配,缓存区的长度是1024Byte。从而说明了标准IO中缓存区的存在。

        下面再补充一个标准IO文件操作的例子,代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main(int argc, char *argv[])
    {
    	FILE *filp = NULL;
    	char fileDir[] = "/home/yangzhiyuan/Documents/test.txt"; 
    	char dataPtr[] = "Helloworld";
    	filp = fopen(fileDir,"w+");  /* 可读可写,不存在则创建 */
    	if(fwrite(dataPtr,1,sizeof(dataPtr),filp) != sizeof(dataPtr)) {  /* 写数据到文件中 */
    		perror("fwrite error");
    		exit(1);
    	}
    	fclose(filp);
    	
    	FILE *fp = NULL;
    	fp = fopen(fileDir,"r");
    	char buffer[256];
    	fread(buffer,1,sizeof(buffer),fp);  /* 读取文件中的内容 */	
    	fclose(fp);
    
    	printf("%s\n",buffer);
    	exit(0);
    }

    二.文件IO

      Linux中一切皆文件,对于Linux文件的操作使用直接IO,应用程序中调用open,write,read,ioctl,close等函数操作linux中的文件。linux下文件IO的操作要包含下面4个头文件:

    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>

    下面主要介绍文件的读写,其他的参考man help。

    1.read读文件


      默认情况下,文件都是以阻塞方式打开的,文件的读也是默认采用阻塞方式。因此关于read的返回值,返回小于len的非零正整数也是合法的。关于read的返回值说明如下:

      (1)当采用默认方式打开文件时(阻塞读)

      read的返回值:a. 读取失败,返回值小于零,错误码在errno中有定义。

                             b.读取成功:返回实际读取字节个数,当到达文件末尾EOF时,调用read,会返回0,表示没有读取到任何字节。如果调用read读取指定len个字节,但是没有一个字节可读时,调用会被阻塞(sleep),直到有数据可读,程序才会继续执行。关于读取指定len个字节数据,可采用下面方法实现:

    ssize_t ret;
    while(len != 0 && (ret = read(fd,buf,len)) != 0) {  /* 一直读完len个字节或者读到EOF */
      if(ret == -1) {
        if(errno == EINTR)  /* 表示读取数据之前接收到信号 */
          continue;
        perror("read");
        break;
      }
      len -= ret;
      buf += ret;
    } 
      (2)采用非阻塞方式读

      这种情况需要使用非阻塞方式打开文件,open调用如下:

    fd = open(filename,O_NONBLOCK);
    char buf[BUFSIZ];
    ssize_t nr;
    
    start:
    nr = read(fd,buf,BUFSIZ);
    if(nr == -1) {
      if(errno == EINTR)
        goto start;
      if(errno == EAGAIN)
        /* resubmit later */
      else
        /* error */
    }
    非阻塞读的意义在于捕获EAGAIN。

    参考代码1:blockread.c

    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <errno.h>
    
    #define SIZE 1024
    
    int main(int argc,char * arg[])
    {
    	char buf[SIZE];
        int fd;
    	char *file = "/bin/blockreadfile";
    	ssize_t nr;
    	if((fd = open(file,O_RDONLY|O_CREAT,0777)) < 0) 
    		printf("open %s failed\n",file);
    	else {
    		printf("Before reading! \n");
    		if((nr = read(fd,buf,SIZE))<0) { //sleep
    			perror("read");		
    		}
    		else 
    			printf("The content is %s\n",buf);
    		printf("Reading finished!\n");
    	}
    	return 0;
    }


    2.write写文件

    注意:与read相比,write()调用不太可能出现部分写的情况,也不存在EOF场景,因此一般不会出现循环调用write(),但是对于socket类型,需要循环来保证写了所有的字节请求。

    ssize_t ret, nr;
    while(len != 0 && (ret = write(fd,buf,len)) != 0) {
      if(ret == -1) {
        if(errno == EINTR)
          continue;
        perror("write");
        break;
      }
      len -= ret;
      buf += ret;
    }
    此外,写文件的方式还与open()调用有关,可以有追加写(Append)模式、同步写模式等。

    参考代码2:write_read.c

    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <string.h>
    
    #define MAX_SIZE 1000
    
    int main(int argc,char* arg[])
    {
    	int fd;
    	ssize_t length_w,length_r = MAX_SIZE,ret;
    	char *testwrite = "/bin/testwrite";
        ssize_t count;
    	char buffer_write[] = "Hello Write Function!";
    	char buffer_read[MAX_SIZE];
    
    	if((fd = open(testwrite,O_RDWR|O_CREAT,0777))<0) {
    		printf("open %s failed\n",testwrite);    
    	}
        //check partial write
        count = sizeof(buffer_write);
        length_w = write(fd,buffer_write,count);
        if(length_w == -1)
    		perror("write");
    	else if(length_w != count)
            printf("It's partial write!\n");
    	else
            printf("Write Function OK!\n");
    	close(fd);
    
        if((fd = open(testwrite,O_RDWR|O_CREAT,0777))<0) {
    		printf("open %s failed!\n,testwrite");
    	}
    	if((ret = read(fd,buffer_read,length_r))<0) {
    		perror("read");
    	}
    	printf("Files Content is %s \n",buffer_read);
    	close(fd);
    
    	return 0;
    }


    参考:

    1. 《Linux系统编程》—— 第二版

    2.  http://blog.csdn.net/carolzhang8406/article/details/7227761

    3.  http://blog.sina.com.cn/s/blog_6592a07a0101gar7.html

    展开全文
  • linux文件IO

    千次阅读 2017-05-21 23:07:28
    { char *buf = malloc(MAX_BUF_SIZE); strncpy(buf, src, , MAX_BUF_SIZE); fwrite(buf, MAX_BUF_SIZE, 1, fp); fclose(fp); } ...malloc的buf对应图层中applicationbuffer,即应用程序buffer;...

     

    {
       char *buf = malloc(MAX_BUF_SIZE);
       strncpy(buf, src, , MAX_BUF_SIZE);
       fwrite(buf, MAX_BUF_SIZE, 1, fp);
       fclose(fp);
    }


    mallocbuf对应图层中applicationbuffer,即应用程序buffer


    调用fwrite后,把数据从application buffer 拷贝到了 CLib buffer,即C库标准IObufferfwrite返回后,数据还在CLib buffer;


    当调用fclose的时候,fclose调用会把数据刷新到磁盘介质上;


    除了fclose方法外,还有一个主动刷新操作fflush 函数,不过fflush函数只是把数据从CLibbuffer 拷贝到page  cache中,并没有刷新到磁盘上,从page cache刷新到磁盘上可以通过调用fsync函数完成;


    数据到了page cache后,内核有pdflush线程在不停的检测脏页,判断是否要写回到磁盘中。把需要写回的页提交到IO队列——即IO调度队列。由IO调度队列调度策略决定何时写回磁盘;

     

    IO队列有2个主要任务。一是合并相邻扇区的,二是排序。合并相信很容易理解,排序就是尽量按照磁盘选择方向和磁头前进方向排序。因为磁头寻道时间是和昂贵的;


    这里IO队列和我们常用的分析工具iostat关系密切。iostatrrqm/s wrqm/s表示读写合并个数。avgqu-sz表示平均队列长度;


    从IO队列出来后,就到了驱动层,驱动层通过DMA,将数据写入磁盘cache;

     

     

    磁盘操作优化


    去掉CLib buffer

    直接写到page cache调用write函数,是直接通过系统调用把数据从应用层拷贝到内核层,从application buffer 拷贝到 pagecache 

     

    去掉系统调用

    write会触发用户态/内核态切换。mmappage cache 地址空间映射到用户空间,应用程序像操作应用层内存一样,写文件。省去了系统调用开销

     

    去掉page cache

    open文件带上O_DIRECT参数, write文件时直接写到设备。

     

    去掉文件系统

    直接写扇区就是所谓的RAW设备写,绕开了文件系统,直接写扇区,像fdsik,dd,cpio之类的工具就是这一类操作.

     

     

    数据读写操作原子性


    write操作如果写大小小于PIPE_BUF(一般是4096),是原子操作,能保证两个进程“AAA”,“BBB”写操作,不会出现“ABAABB”这样的数据交错。


    O_APPEND 标志能保证每次重新计算pos,写到文件尾的原子性。

     

     

    磁盘IO性能


    机械硬盘顺序写30MB\s,顺序读取速率一般50MB\s,好的可以达到100多M\s, SSD读达到400MB\s,SSD写性能和机械硬盘差不多。

     

    展开全文
  • 文件IO(系统IO和标准IO)

    千次阅读 2016-02-18 09:33:43
    Linux系统下操作文件有两类基本API,一类由系统调用提供,被称为系统IO。一类由标准C库提供,被称为标准IO。   拓展: 它们都是Linux下操作文件的标准接口,那又有什么区别?我们该如何选择使用呢? 第...

    Linux系统下操作文件有两类基本API,一类由系统调用提供,被称为系统IO。一类由标准C库提供,被称为标准IO。

     

    拓展:

    它们都是Linux下操作文件的标准接口,那又有什么区别?我们该如何选择使用呢?

    第一:系统IO是更底层的接口,因此任何设备和文件最终都是可以通过系统IO来操作。系统IO不提供缓冲区,意味着每次读写都必须进入内核,对于大数据量的读写操作会影响效率。

    第二:标准IO是由标准库提供的接口,因此功能更加丰富,而且标准IO提供缓冲区,增加数据处理的吞吐量。标准IO还对读写操作提供更加丰富的操作方式,例如按字节、按行、按块、按数据格式读写。但是有些特殊文件无法使用标准IO,比如socket套接口,比如LCD显示屏。

    第三:在能使用标准IO的场合,我们尽量使用它,毕竟它功能丰富效率高,但在无法使用标准IO的场合,我们还是只能用系统IO。

    第四:所谓的系统IO,就是指这样的一堆函数:

    open()

    read()

    wirte()

    lseek()

    ioctl()

    close()

    等等

    所谓的标准IO,指的是这一堆函数:

    fopen()

    fgets()

    fread()

    scanf()

    getchar()

    fputs()

    fwrite()

    printf()

    fseek()

    fclose()

    等等。

    展开全文
  • linux 文件IO和标准IO

    千次阅读 2013-01-03 22:56:53
    linux编程使用的open、close、read、write等文件IO函数属于系统调用的,其实现方式是用了fctrl、ioctrl等一些底层操作的函数。而标准IO库中提供的是fopen、fclose、fread、fwrite等面向流对象的IO函
     
     668人阅读 评论(0) 收藏 举报

    今日阅读《UNIX环境高级编程2》才发现一些以前从未注意过的细节。

     

    linux编程使用的open、close、read、write等文件IO函数属于系统调用的,其实现方式是用了fctrl、ioctrl等一些底层操作的函数。而标准IO库中提供的是fopen、fclose、fread、fwrite等面向流对象的IO函数,这些函数在实现时本身就要调用linux的文件IO这些系统调用。

     

    在应用上,文件读写时二者并没区别,但是一些特殊文件,如管道等,只能使用文件IO操作。文件IO的一个方便之处在于,对于一切linux中的文件对象,都可以操作,这也是linux把系统中所有资源,都映射成文件节点的优越之处。另一方面,在一些应用中,如果需要格式化字符串输入输出时,标准IO提供了一个很好的接口,fprintf(FILE* fp, char *platestr,...),而在文件IO中没有这样的函数,那么如果我们按照习惯用open函数打开了文件,获得文件描述符fd,只要根据fd得到对应的标准IO流的指针fp,就可以使用fprintf函数做格式化输出了。

     

    实现这个功能的函数就是  fdopen

    标准IO提供了3个打开文件流的函数

    [c-sharp] view plaincopy
    1. #include <stdio.h>  
    2. FILE *fopen(const char *restrict pathname, counstchar *restrict type);   
    3. FILE *freopen(const char *restrict pathname, counst char *restrict type,  
    4.               FILE *restrict fp );  
    5. FILE *fdopen(int filedes, counst char *restrict type);  
    6.   
    7. 三个函数成功返回文件指针,出错返回NULL  

    其中fopen是最长用的函数。

    freopen的左右是在参数指定的流上打开一个文件,若文件已经打开则先关闭该流;若文件流已经定向,则清楚定向。此函数可以用于把指定的文件打开成为标准输入输出。

     

    fdopen的作用是从现有的文件描述符(从open、dup、fctrl、pipe、socket、accept等处获得)打开一个流使其与该文件描述符相关联。利用这个函数就可以实现前面所说的对于一般的文件IO做格式化输入输出等标准IO的操作。

    需要注意的是,前两个函数属于ISO C的标准,fdopen属于POSIX.1的标准。ISO C 的标准中没有文件描述符的概念。另外,fdopen的第二个参数与fopen的参数类似:

    r/rb

    w/wb

    a/ab

    r+ /r+b/rb+

    w+/w+b/wb+

    a+/a+b/ab+

    区别是fdopen的参数中如果是二进制文件,需要指定b参数,因为ISO C中是要区别二进制文件和文本文件的的,而在linux内核中对二者没有不同的待遇。另外,由于fdopen打开的文件是已经打开过的,因此w参数并不会把文件长度截断为0,是否截断取决于open参数中的O_TRUNC参数。所以每次fwrite写入的数据都将写入文件尾。

     

    以上就是从文件符获得文件IO流指针的方法。若我们先得到了文件IO流指针,再需要获得文件描述符,怎么办呢?因为所有的标准IO的函数最终都要调用linux提供的文件IO这类系统调用,所以每个标准IO流都必然关联一个文件描述符,用这个函数就可以得到关联的文件描述符了

          int fileno( FILE *fp);

    返回值:与该流关联的文件描述符

    展开全文
  • 标准IO与文件IO 的区别

    万次阅读 多人点赞 2016-07-01 21:44:17
    先来了解下什么是标准IO以及文件IO。 标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行...
  • Python文件io

    千次阅读 2017-09-25 18:19:32
    使用open打开第一个参数是你要访问文件的路径,第二个参数是打开文件的模式,以下是具体模式。 r :以只读方式打开文件文件的指针将会放在文件的开头。这是默认模式。rb: 以二进制格式打开一个文件用于只读。...
  • Linux文件IO编程

    千次阅读 2012-11-08 22:48:06
    Linux的文件结构:  在Linux中,几乎一切都可以看做是文件来处理,文件是操作系统与具体物理设备之间的一个简单而统一的接口。所以,我们在程序中可以像使用文件那样去读写磁盘、操作串口、打印机等其他设备。常用...
  • java文件IO操作

    千次阅读 2012-07-11 02:38:14
    import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.InputStream; import java.io.PrintWriter; public clas
  • Linux 文件IO理解

    千次阅读 2011-07-14 11:04:46
    linux文件IO操作有两套大类的操作方式:不带缓存的文件IO操作,带缓存的文件IO操作。不带缓存的属于直接调用系统调用(system call)的方式,高效完成文件输入输出。它以文件标识符(整型)作为文件唯一性的判断依据...
  • 文件IO和标准IO区别及其效率

    千次阅读 2016-10-16 21:10:20
    文件IO 就指的是我们通常讲的open、close、write、read等API函数构成的一套用来读写文件的体系,这套体系可以很好的完成文件读写,但是效率并不是最高的。 标准IO应用层C语言库函数提供了一些用来做文件读写的函数...
  • 文件IO(标准IO缓冲区)

    千次阅读 2016-02-16 09:07:02
    标准IO的缓冲区分成三类,分别是不缓冲、全缓冲和行缓冲。   拓展: 一般情况下,显示屏被打开两次,分别以行缓冲和不缓冲模式打开,即所谓的stdout和stderr,普通文件则默认是全缓冲。  文件的缓冲...
  • 【Unix】文件IO与标准IO

    千次阅读 2010-02-09 10:16:00
    一、文件IO 大多数UNIX文件IO只需用到5个函数:open、read、write、lseek以及close。 这些函数经常被称为不带缓存的IO(unbuffered IO),不带缓存是指每个read和write都调用内核中的一个系统调用。 这些不带缓存的IO...
  • QT文件IO操作

    千次阅读 2014-02-24 22:08:39
    打开文本文件到一个textEdit控件里 void MainWindow::loadFile(const QString &fileName) { QFile file(fileName); if (!file.open(QFile::ReadOnly | QFile::Text)) { QMessageBox::warning(this, tr("Applica
  • 漫谈linux文件IO

    千次阅读 2012-08-23 16:40:18
    这篇文章写的比较全面,也浅显易懂,备份下。... 在Linux 开发中,有几个关系到性能的东西,技术人员非常关注:进程,CPU...剖析文件IO的细节。从多个角度探索如何提高IO性能。本文尽量用通俗易懂的视角去阐述。不copy内
  • 文件IO消耗分析

    千次阅读 2013-02-07 11:05:38
    Linux在操作文件时,将数据放入文件缓存区,直到内存不够或系统要释放内存给用户进程使用,因此在查看Linux内存状况时经常会发现可用(free)的物理内存不多,但是cached用了很多,这是Linux提升文件IO速度的一种...
  • 7-文件IO-阻塞与非阻塞IO

    千次阅读 2016-09-25 19:01:51
    1. 阻塞 IO 通常来说,从普通文件读数据,无论你是采用 fscanf,fgets 也好,read 也好,一定会在有限的时间内返回。但是如果你从设备,比如终端(标准输入设备)读数据,只要没有遇到换行符(‘\n’),read 一定会...
  • 文件IO函数和标准IO库的区别

    千次阅读 2015-09-28 15:51:51
    1,文件IO函数,在Unix中,有如下5个:open,read,write,lseek,close。称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。 2,标准IO库,由ANSI C标准说明。...
  • C语言 文件IO的使用

    千次阅读 2018-01-22 17:10:57
    简单介绍C语言文件操作函数的用法(可以直接使用): fopen fclose fprintf fscanf fputc fgetc fread fwrite 头文件 #include 函数使用 fopen 函数原型: FILE *fopen( const char *...
  • Linux文件IO(文件的读写)

    千次阅读 2017-04-02 15:14:48
    内容源于朱友鹏老师的课程笔记的学习整理,如有侵权,请告知删除。
  • 文件IO(文件位置偏移量)

    千次阅读 2016-02-14 11:29:11
    每一个文件被打开之后,内核都维护一个所谓的当前文件位置偏移量,读和写操作都会对这个偏移量产生影响。   拓展: 文件位置偏移量被存放到内核的file结构体中,应用程序可以通过lseek()/和fseek()来调整...
  • 本文描述如果通过文件IO sysfs方式控制树莓派 GPIO端口。通过sysfs方式控制GPIO,先访问/sys/class/gpio目录,向export文件写入GPIO编号,使得该GPIO的操作接口从内核空间暴露到用户空间,GPIO的操作接口包括...
  • Linux文件IO_01

    千次阅读 2019-04-08 16:22:43
    Linux文件IO0.综述1.Linux常用文件IO接口(API)3.IO实例3.1打开文件3.2读取文件内容3.3向文件中写入内容 0.综述 IO就是input和output,文件IO就是文件的读写。文件没有打开时是存放在块设备中的文件系统里的,这样...
  • Python中文件的读写包含三个步骤:打开文件,读/写文件,关闭文件文件打开之后必须关闭,因为在磁盘上读写文件的功能是由操作系统提供的,文件作为对象,被打开后会占用操作系统的资源,而操作系统在同一时间内...
  • Linux文件IO_02

    千次阅读 2019-04-09 16:14:59
    Linux文件IO_024.lseek函数详解4.1lseek函数介绍4.2lseek实践:计算文件长度5.文件共享的实现5.1文件共享概念5.2文件共享的3种实现方式5.3文件描述符细节6.C语言标准库的文件IO介绍 4.lseek函数详解 4.1lseek函数...
  • Flutter系列之Dart文件IO操作

    万次阅读 2018-10-21 10:19:08
    这一部分学习下Dart语法怎么进行IO文件操作。 本身而言,Dart语法进行文件操作是十分简便的,下图是简单写入操作; final filePath = r"E:\back.txt"; try { File file = new File(filePath); file....
  • linux 文件IO和标准IO的一些实现细节

    千次阅读 2010-03-25 16:53:00
     linux编程使用的open、close、read、write等文件IO函数属于系统调用的,其实现方式是用了fctrl、ioctrl等一些底层操作的函数。而标准IO库中提供的是fopen、fclose、fread、fwrite等面向流对象的IO函数,这些函数在...

空空如也

1 2 3 4 5 ... 20
收藏数 125,585
精华内容 50,234
关键字:

文件io