精华内容
下载资源
问答
  • 标准io和系统io的区别
    2021-09-05 09:08:24

    标准IO:对数据的IO是有缓存机制。在处理大数据的时候,才会体现提高IO操作效率。
    文本中的数据,数据库中数据。

    系统IO:对数据的IO没有缓存机制,针对的是需要及时获取(需要具有较高的实时性)数据,一般指硬件设备产生的 数据(要获取的数据),专门操作设备文件:
    譬如:触摸屏获取坐标

    疑问:
    为什么有缓存操作,就针对大数据处理?
    为什么没有缓存操作就指针及时获取(需要具有较高的实时性)的数据处理?

    补充缓存机制:

    全缓存:当缓存区满的时候,才进行IO操作 fwrite fread
    行缓存:在缓存区里面遇到\n,直接进行IO —printf scanf fgets
    无缓存:直接IO操作 :read write 标准出错 perror

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

    2021-08-14 09:42:49
    1.系统IO操作文件时是无缓冲输入,一般用于操作字符设备文件(LCD, LED, BEEP ...,数据需 要实时刷新) 标准IO操作文件时是有缓冲输入,一般用于操作普通文件(.txt, .jpg...) 2.系统IO是Linux操作系统提供函数...

            1.系统IO操作文件时是无缓冲输入,一般用于操作字符设备文件(LCD, LED, BEEP ...,数据需要实时刷新)

               标准IO操作文件时是有缓冲输入,一般用于操作普通文件(.txt, .jpg...)

                    缓冲机制可分3类:全缓冲, 行缓存,无缓冲

                     全缓冲:填满标准I/O缓存区才进行实际的I/O操作。(fwrite/fread)

                     行缓存:当在遇到换行符或者缓冲区满时,标准IO库执行IO系统调用操作(printf)

                     无缓冲:标准I/O库不对字符进行缓冲存储 (标准出错)


             2.系统IO是Linux操作系统提供函数接口
                标准IO标准C语言库函数提供的


            系统IO的API接口有:open  read   write  close   lseek .....

            标准IO的API接口有:fopen fread  fwrite fclose  ftell  ferror feof .....    

            系统IO个人认为操作文件比较方便点,但方便的同时也没这么精确,可以根据自己的需求而选择。标准IO比较精确, 如果想要代码更加的精确完善可以使用标准IO。可以这么理解系统IO能实现的功能,标准IO都能实现,但标准IO能实现的,系统IO未必能实现。

    展开全文
  • 系统IO和标准IO

    千次阅读 2022-04-04 10:24:07
    一、系统IO和标准IO I/O:是一切实现的基础 stdio标准IO sysio系统调用IO(文件IO) stdio:FILE类型贯穿始终 sysio:fd是在文件IO中贯穿始终的类型,fd是文件描述符(整型数)

    一、系统IO和标准IO

    • I/O:是一切实现的基础
    • stdio标准IO
    • sysio系统调用IO(文件IO)

    1、stdio:FILE类型贯穿始终
    2、sysio:fd是在文件IO中贯穿始终的类型,fd是文件描述符
    文件IO与标准IO的关系
    3、文件描述符的概念:
    (1)整型数,数组的下标,文件描述符优先使用当前可用范围内最小

    二、标准IO

    (一)fopen()和fclose()

    1、fopen()

    #include <stdio.h>
    FILE *fopen(const char *path,const char *mode);

    • (1)fopen()函数返回值:是栈、静态区、堆的哪一个?
    FILE *fopen(const char *path,const char *mode)//栈上猜测
    {
        FILE  tmp; 
        tmp. = ;
        ...........
        return &tmp; 
    }
    
    FILE *fopen(const char *path,const char *mode)//静态区猜测
    {
        static FILE  tmp; 
        tmp. = ;
        ...........
        return &tmp; 
    }
    
    FILE *fopen(const char *path,const char *mode)//放在堆上
    {
        FILE  *tmp = NULL;
    
        tmp = malloc(sizeof(FILE));
        tmp-> = ;
        ...........
    
        return tmp; 
    }
    
    • 小结
      栈(F)    静态区(F)    堆(Ture)
      fopen();和fclose();是互逆操作,都是放在堆上 ———> 有互逆操作一定放在
      如果没有互逆操作的,就要自己用程序去判断是放在静态区还是堆上。
    • (2)fopen()只读方式,查看文件报错信息
    int main()
    {
       FILE *fp;
       fp = fopen("tmp","r");
       if (fp == NULL)
       {
           fprintf(stderr,"fopen() faild! errno = %d\n",errno);//errno已经被私有化
           perror("fopen()");
           fprintf(stderr, "fopen()%s\n", strerror(errno));
           exit(1);
       }
       else
       {
           fputs("ok!\n",stdout);
           fputs("OK\n",fp);
       }
       exit(0);
    }
    

    2、fclose()

    int main()
    {
       FILE *fp;
       fp = fopen("tmp","w");
       if (fp == NULL)
       {
           fprintf(stderr,"fopen() faild! errno = %d\n",errno);//errno已经被私有化
           perror("fopen()");
           fprintf(stderr, "fopen()%s\n", strerror(errno));
           exit(1);
       }
       puts("ok!");
       fclose(fp);
       exit(0);
    }
    

    3、文件打开信息

    • (1)一个进程中,默认打开3个流 stream —> stdin、stdout、stderr
    • (2)ulimit -a 控制打开的个数
    • (3)新文件权限 产生的公式: 0666(8进制) & ~umask
    • (4)umask 的值默认是0002(8进制),新建文件权限默认是:0664(8进制)
    //maxfopen(),w  查看文件最多可以打开多少个
    int main()
    {
        int count = 0;
        FILE *fp = NULL;
        
        while (1)
        {
            fp = fopen("tmp", "w");
            if (fp == NULL)
            {
                perror("fopen()");
                break;
            }
            count++;
        }
        printf("count=%d\n", count);//输出count=1021,因为默认打开3个流 stream ---> stdin stdout stderr
        exit(0);
    }
    

    4、比较文件是否相同

    • diff   文件名1   文件名2

    (二)fgetc()和fputc()

    1、fgetc()

    //这节主要讲fgetc 可以用来统计文件的大小
    int main(int argc,char **argv)
    {
       FILE *fp = NULL;
       int count = 0;
    
       if (argc < 2)
       {
           fprintf(stderr,"Usage:.....\n");
           exit(1);
       }
       fp = fopen(argv[1],"r");
       if (fp == NULL)
       {
           perror("fopen()");
           exit(1);
       }
       while(fgetc(fp) != EOF)
       {
           count++;
       }
       printf("%d\n",count);
       fclose(fp);
       exit(0);
    }
    

    2、fgetc()和fputc()联合使用

    • 通过fgetc()和fputc()函数章节,实现文件内容以字符操作方式
    int main(int argc,char **argv)
    {
       FILE *fps = NULL;
       FILE *fpd = NULL;
       int ch;
    
       if (argc < 3) //必须是3个参数
       {
           fprintf(stderr,"Usage:<s_file> <d_file>\n");
           exit(1);
       }
       
       fps = fopen(argv[1],"r");
       if (fps == NULL)
       {
           perror("fopen()");
           exit(1);
       }
       
       fpd = fopen(argv[2],"w");
       if (fpd == NULL)
       {
           fclose(fps);
           perror("fopen()");
           exit(1);
       }    
       
       while (1)
       {
           ch = fgetc(fps);
           if(ch == EOF)
           {
               break;
           }
           fputc(ch, fpd);
       }
    
       fclose(fpd);//先关目标文件,再关源文件
       fclose(fps);
       exit(0);
    }
    

    (三)fgets()和fputs()

    • 功能:实现文件内容以字符串操作方式
      1、fgets()函数详解
    //gets()函数不要使用,C基础中有讲
    //char *fgets(char *s, int size, FILE *stream);
    
    
    #define SIZE 5
    char bug[SIZE];
    fgets(buf,SIZE,stream);
    
    //fgets遇到 size-1 or '\n'停止
    
    (1)文件内容abcdef  读SIZE-1
    1  ----->  a b c d '\0'
    
    (2)文件内容ab      读SIZE-1
    2  ----->  a b '\n' '\0'
    
    (3)文件内容abcd    擦边球  用fgets(buf,SIZE,stream);来读取,读取两次
    1-> a b c d '\0'
    2-> '\n' '\0'  ....
    

    2、fgets()和fputs()函数进行读写

    #define BUFSIZE 1024
    
    int main(int argc,char **argv)
    {
        FILE *fps = NULL;
        FILE *fpd = NULL;
    
        char buf[BUFSIZE];
    
        if (argc < 3) //必须是3个参数
        {
            fprintf(stderr,"Usage:<s_file> <d_file>\n");
            exit(1);
        }
    
        fps = fopen(argv[1],"r");
        if (fps == NULL)
        {
            perror("fopen()");
            exit(1);
        }
    
        fpd = fopen(argv[2],"w");
        if (fpd == NULL)
        {
            fclose(fps);
            perror("fopen()");
            exit(1);
        }
    
        while (fgets(buf, BUFSIZE, fps) != NULL)
        {
            fputs(buf,fpd);
        }
    
        fclose(fpd);//先关目标文件,再关源文件
        fclose(fps);
        exit(0);
    }
    

    (四)fread()和fwrite()函数

    1、fread()函数详解

    • fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    • fread保险起见,size=1个字节方式读
    //1、知识点草稿
    //fread(buf, size, nmemb, fp);
    1 ---> 数据量足够  读一次   保险起见多1个字节方式  ********
    fread(buf,1,10,fp)  ---> 10个对象,读到10个字节
    fread(buf,10,1,fp)  ---> 1个对象, 读到10个字节
    
    2 ---> 只有5个字节
    fread(buf,1,10,fp)  ---> 5个对象,读到5个字节
    fread(buf,10,1,fp)  ---> 0个对象,文件剩余多少???不知道
    

    2、fread()和fwrite()函数进行读写

    #define BUFSIZE 1024
    
    int main(int argc,char **argv)
    {
        FILE *fps = NULL;
        FILE *fpd = NULL;
    
        char buf[BUFSIZE];
        int n;
    
        if (argc < 3) //必须是3个参数
        {
            fprintf(stderr,"Usage:<s_file> <d_file>\n");
            exit(1);
        }
    
        fps = fopen(argv[1],"r");
        if (fps == NULL)
        {
            perror("fopen()");
            exit(1);
        }
    
        fpd = fopen(argv[2],"w");
        if (fpd == NULL)
        {
            fclose(fps);
            perror("fopen()");
            exit(1);
        }
    
        while ((n = fread(buf, 1, BUFSIZE, fps)) > 0) //返回读到的字节数,然后写n个字节
        {
            printf("%d\n", n);
            fwrite(buf, 1, n, fpd);
        }
    
        fclose(fpd);//先关目标文件,再关源文件
        fclose(fps);
        exit(0);
    }
    

    (五)printf()和scanf()函数

    1、引申   sprintf   atoi**
    (1)atoi函数使用

    int main()
    {
        char str[] = "123a456";
    
        printf("%d\n", atoi(str));
    
        exit(0);
    }
    

    (2)sprintf函数使用

    int main()
    {
        char buf[1024];
        int y = 2022, m = 3, d = 26;
        
        sprintf(buf,"%d-%d-%d",y,m,d);
        puts(buf);
    
        exit(0);
    }
    

    (六)fseek()和ftell()函数

    1、fseek()和ftell()函数的缺陷

    • int fseek(FILE *stream, long offset, int whence);//设置文件指针位置 offset是偏移位置
    • long ftell(FILE *stream);//返回文件指针位置
    • 大小有局限性,因为long的大小在不同编译器中不确定

    (1)通过 fseek()和ftell() 两个函数可以读取 文件大小

    int main(int argc,char **argv)
    {
        FILE *fp = NULL;
        long count;
    
        if (argc < 2)
        {
            fprintf(stderr,"Usage:.....\n");
            exit(1);
        }
    
        fp = fopen(argv[1],"r");
        if (fp == NULL)
        {
            perror("fopen()");
            exit(1);
        }
    
        fseek(fp, 0, SEEK_END); //SEEK_SET, SEEK_CUR, or SEEK_END
        count = ftell(fp);
    
        printf("%ld\n",count);
        fclose(fp);
    
        exit(0);
    }
    

    2、fwind()函数

    • void rewind(FILE *stream);//使得文件指针回到文件开始位置
    • rewind是对fseek的封装:(void) fseek(stream, 0L, SEEK_SET)

    3、文件指针
    (1)何谓文件指针
         就像读书时眼睛移动一样,文件指针逐行移动
    (2)什么时候用?
         对一个文件先写后读的时候,比如:

    • FILE *fp = fopen();
    • fputc(fp); //放入10个字节,文件中有个文件位置指针,是指向最后一个字节的
    • fgetc(fp); //所以,再读取10个字节,无法得到刚刚写入的东西(指针已经向后偏移了)

    (七)fseeko()和ftello()函数的出现

    • int fseeko(FILE *stream, off_t offset, int whence);
    • off_t ftello(FILE *stream);

    1、弥补了fseek()和ftell()缺陷

    2、off_t的大小可以在makefile中加入宏定义: CFLAGS+=-D_FILE_OFFSET_BITS=64

    (八)标准IO的缓冲区和fflush()函数

    缓冲区的作用:大多数情况下是好事,合并系统调用

    1、行缓冲
         换行时候刷新,满了的时候刷新,强制刷新(标准输出都是这样的,因为是终端设备)   stdout

    2、全缓冲
    (1)满了的时候刷新,强制刷新(默认,只要不是终端设备都是全缓冲)
    (2)现在的"\n"只是起到了换行作用
    (3)缓冲区可以改的函数    setvbuf()

    int setvbuf(FILE *stream, char *buf, int mode, size_t size);
    

    3、无缓冲
         如:stderr,需要立即输出的内容

    4、缓冲区的实例说明

    (1) 缓冲区不够,不输出

    //无法输出Before while
    int main()
    {
        printf("Before while");
        while(1)
        {
            ;
        }
        printf("After while");
        exit(0);
    }
    

    (2) 行缓冲输出方式

    //末尾加换行符,可以输出Before while
    int main()
    {
        printf("Before while\n");
        while (1)
        {
            ;
        }
        printf("After while\n");
        exit(0);
    }
    

    (3)无缓冲输出方式

    //使用fflush()函数可以输出Before while
    int main()
    {
        printf("Before while");
        fflush(stdout);
        while (1)
        {
            ;
        }
        printf("After while");
        fflush(NULL);
        exit(0);
    }
    

    (九)getline()函数

    • 作用:取到完整的一行函数
    • getline()内部封装形式: malloc() realloc() realloc()…realloc()
    • getline()属于可控内存泄漏   还有不可控的内存泄漏:服务器一直运行下去
    • 使用getline()时,在makefile里面加-D_GNU_SOURCE   或者   函数里引用 #define _GNU_SOURCE
    int main(int argc, char **argv)
    {
        FILE *fp = NULL;
        char *linebuf;
        size_t linesize;
    
        if (argc < 2)
        {
            fprintf(stderr,"Usage:<s_file> <d_file>\n");
            exit(1);
        }
    
        fp = fopen(argv[1], "r");
        if(fp == NULL)
        {
            perror("fopen()");
            exit(1);
        }
    
        printf("%s——%d——%s\n", __FILE__, __LINE__, __FUNCTION__);
    
        linebuf = NULL; //加这句很重要!!!!!
        linesize = 0;   //加这句话很重!!!!!
    
        while (1)
        {
            if(getline(&linebuf, &linesize, fp) < 0)//getline()存在可控内存泄漏
            {
                break;
            }
            printf("%ld\n", strlen(linebuf));
            printf("%ld\n", linesize);
        }
    
        fclose(fp);
        exit(0);
    }
    

    (十)临时文件

    1、记住两点,①如何不冲突,②及时销毁
    (1)tmpnam()不合适,容易多个人同时拿到
    (2)tmpfile(): 合适,无文件名,不冲突,只要进程不是无休止的运行,不用fclose()也可以释放
    (3)用fclose()可以及时销毁!!!!!

    三、系统IO

    (一)open()和close()

    在这里插入图片描述

    1、文件的拷贝

    #define  BUFSIZE 1024
    
    int main(int argc, char **argv)
    {
        int sfd, dfd;
        char buf[BUFSIZE];
        int len, ret, pos;
    
        if (argc < 3)
        {
            fprintf(stderr, "Usage ....\n");
            exit(1);
        }
    
        sfd = open(argv[1], O_RDONLY);
        if (sfd < 0)
        {
            fprintf(stderr, "sfd open = %d\n", errno);
            perror("open()");
            exit(0);
        }
    
        dfd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0600);
        if (dfd < 0)
        {
            close(sfd);
            fprintf(stderr, "dfd open = %d\n", errno);
            exit(0);
        }
    
        while (1)
        {
            len = read(sfd, buf, BUFSIZE);
            if(len < 0)
            {
                perror("read()");
                break;
            }
            if(len == 0)
                break;
    
            pos = 0;
            while (len > 0)
            {
                ret = write(dfd, buf + pos, len);
                if (ret < 0)
                {
                    perror("write()");
                    close(dfd);
                    close(sfd);                
                    exit(1);
                }
                pos = ret;
                len -= ret;
            }
        }
    
        close(dfd);
        close(sfd);
        exit(0);
    }
    
    //139运行测试
    //1、   ./139ReadWrite /etc/services ./out
    //2、   diff /etc/services ./out  ————> 比较文件是否一样 
    
    //140运行测试
    //1、   time    ./139ReadWrite /etc/services ./out   当前进程执行所要的时间
    //(1)运行结果:
    //      real	0m0.001s   
    //      user	0m0.001s
    //      sys	    0m0.000s
    //(2)时间:
    //      real = user + sys + (调度等待时间)
    //      程序员解决是user和sys的时间
    

    (二)文件IO与系统IO的区别

    1、举例
      快递员送快递,分拣后批量送快递、单个快递送
    2、区别
      响应速度(系统IO)&吞吐量(标准IO的缓冲区)
    3、如何使一个程序更快
      结合响应速度和吞吐量回答
    4、转换
      fileno()和fdopen()
    5、注意:标准IO与文件IO不可以混用
      (1)FILE *fp; fputc —> pos++ ; fputc —> pos++
      (2)标准IO的pos有缓冲区,pos指针移动,不会影响系统IO的pos。
        举例:word保存与不保存。
      (3)系统IO的pos是等到标准IO缓冲区满,才会使系统IO的pos指针移动
    6、通过strace  ./xxx
      strace可以用来查看一个可执行文件的系统调用

    //1、 strace ./140StdioSysioDiff  运行后可以看到标准IO存在缓冲区,最后输出项
    int main()
    {
        printf("a");
        write(1, "b", 1);
    
        printf("a");
        write(1, "b", 1);
    
        printf("a");
        write(1, "b", 1);
    
        printf("\n");
    
        exit(0);
    
    }
    
    //更好的验证stdio的缓冲区
    //2、 ./140StdioSysioDiff  可以验证ulimit -a  内容里面的数值
    //    ulimit -a中的限制open files   (-n) 1024
    
    int main()
    {
        for (int i = 0; i < 1025; i++)
        {
            printf("a");
            write(1, "b", 1);
        }
    
        printf("\n");
        exit(0);    
    }
    

    (三)IO效率问题

    1、习题
      将mycpy.c程序进行更改,将BUFSIZE的值一直放大,并观察进程所消耗的时间,注意性能最佳拐点出现时的BUFSIZE值,以及何时程序会出现问题。

    (四)文件共享

    1、多个任务共同操作一个文件或者协同完成任务
    (1)面试:写程序删除一个文件的第10行
       补充函数:truncate() / ftruncate

    (五)原子操作

    1、不可分割的操作

    • 作用: 解决竞争和冲突,比如tmpnam的操作,不是原子

    (六)程序的重定向dup和dup2

    1、dup的作用

    int dup(int oldfd); 将传入的文件描述符复制到(未使用的)最小新文件描述符

    (1)close(1)是关闭stdout流 原始办法来实现输出到文件中

    #define FNAME "./out"
    
    int main()
    {
        int fd;
    
        close(1);
    
        fd = open(FNAME, O_WRONLY | O_CREAT | O_TRUNC, 0600);
        if(fd < 0)
        {
            perror("open()");
            exit(0);
        }
    
        /********************************************/
    
        puts("hello!");
    
        exit(0);
    }
    

    (2)使用dup函数,这个程序存在两种情况,主要因为dup函数不是原子操作
     ①dup() 假设天生只有0、2,没有1,那么函数中fd本身创建好就是1
     ②旁边的兄弟也在运行,也突然创建一个,那么就到1上去了,你本身是3最多副本占据到4

    #define FNAME "./out"
    
    int main()
    {
        int fd;
    
        fd = open(FNAME, O_WRONLY | O_CREAT | O_TRUNC, 0600);
        if(fd < 0)
        {
            perror("open()");
            exit(0);
        }
    
        close(1);
        dup(fd);
        close(fd);
    
        /********************************************/
        puts("hello!");
    
        exit(0);
    }
    

    2、dup2的函数
    (1)、dup2属于原子操作方式

    //实现输出到终端信息的内容,输出到对应的文件中
    
    #define FNAME "./out"
    
    int main()
    {
        int fd;
    
        fd = open(FNAME, O_WRONLY | O_CREAT | O_TRUNC, 0600);
        if(fd < 0)
        {
            perror("open()");
            exit(0);
        }
    
        dup2(fd, 1);//相当于这两句操作:close(1);dup(fd);
    
        if (fd != 1)
        {
            close(fd);
        }      
    
        /********************************************/
        puts("hello!");
    
        exit(0);
    

    (七)同步

    1、sync设备即将解除挂载时进行全局催促,将buffer cache的数据刷新
    2、fsync刷新文件的数据,并更新文件的属性
    3、fdatasync函数只刷新文件的数据部分,而除数据外的文件属性(文件的时间)不更新

    (八)Linux的ioctl和fcntl

    1、fcntl函数
     管家级函数,文件描述符所变得魔术几乎都来源于该函数
    2、ioctl函数
     (1)设备相关的内容
     (2)ioctl_list是跟设备打交道

    (九)虚目录

    1、/dev/fd/ 显示的是当前进程的文件描述符信息
    2、ls -l /dev/fd/      看到谁就是查看谁,即在看ls

    展开全文
  • 学了这么久的文件IO了,总是不知道什么时候该用系统IO,什么时候该用标准IO,今天就来整理整理,并分享出来
  • 标准IO和系统调用IO

    2020-11-06 20:58:31
    1.标准IO 标准IO有一个类型贯穿始终,FILE fopen();成功返回FILE指针,失败返回NULL fclose(); fgetc(); fputc(); fgetc(); fread(); fwrite(); printf(); scanf(); 文件位置指针相关内容: fseek(); ftell(); ...

    1.标准IO

        标准IO有一个类型贯穿始终,FILE这个结构体,在我们调用这些标准IO的时候,返回类型是FILE*,
    那么这块内存的地址是在堆区的.
        标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包和stdio.h头文件中的定义,具有一定的可移植性.标准IO库处理很多细节,例如缓存分配,以优化长度执行IO等.
        标准的IO提供了三种类型的缓存.
       (1)全缓存:当填满标准IO缓存后才进行实际的IO操作. 
        (2)行缓存:当输入或输出中遇到新行符时,标准IO库执行IO操作,标准输出就是行缓冲的模式. 
        (3)不带缓存:stderr就是了.
    
    fopen();成功返回FILE指针,失败返回NULL
    fclose();
    fgetc();
    fputc();
    fgetc();
    fread();
    fwrite();
    printf();
    scanf();
    
    文件位置指针相关内容:
    fseek();
    ftell();
    frewind();
    
    刷新缓冲区
    fflush();
    
    
    errno --一个全局变量
    /usr/include/asm-generic/errno.h
    /root/test/0001.c
    gcc -E 0001.c
    
    

    2.系统调用IO(又称作文件IO)

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

    3.标准IO与系统调用IO有什么区别

     首先:两者一个显著的不同点在于,标准I/O默认采用了缓冲机制,比如调用fopen函数,不仅打开一个文件,而且建立了一个缓冲区
    (读写模式下将建立两个缓冲区),还创建了一个包含文件和缓冲区相关数据的数据结构。低级I/O一般没有采用缓冲,需要自己创建缓冲区,
    不过其实在linux或unix系统中,都是有使用称为内核缓冲的技术用于提高效率,读写调用是在内核缓冲区和进程缓冲区之间进行的数据复制。
    其次从操作的设备上来区分,文件I/O主要针对文件操作,读写硬盘等,它操作的是文件描述符,标准I/O针对的是控制台,打印输出到屏幕等,
    它操作的是字符流。对于不同设备得特性不一样,必须有不同api访问才最高效。

     

     

     

    展开全文
  • 在相同情况下标准io系统io都可以的情况下,尽量选择标准io。 提醒一点:标准io与文件io不可混用。,,从我画那个图的时候,提到FILE结构体中一定有一个文件描述符fd 补充两个函数:fileno() 我本身有一个FILE* 我...
  • 非常详细的讲解清楚系统调用IO和文件IO区别,以及缓存的意义
  • 标准IO系统IO

    千次阅读 2018-08-09 17:45:11
    对于操作系统而言,I/O操作可以分为两类,一类是带缓存的IO,又称为标准IO(C标准库中提供了标准IO库,即stdio),它实现了跨平台的用户缓存解决方案。另一类是Unix/Linux下的文件IO,又称直接IO,即文件访问机制不...
  • 标准IO和文件IO的区别(基于Linux操作系统
  • 系统IO标准IO的联系与区别

    千次阅读 2018-05-30 14:54:31
    一、 什么是系统IO和标准IO 系统IO系统IO又称文件IO,也称低级磁盘IO,属于不带缓存的IO(unbuffered I/O)。也就是一般所说的低级I/O——操作系统提供的基本IO服务,与OS绑定,特定于Linux或unix平台。标准IO:...
  • 标准IO:标准I/O是ANSI C建立的一个标准I/O模型,是一个标准函数包stdio.h头文件中的定义,具有一定的可移植性。标准IO库处理很多细节。例如缓存分配,以优化长度执行IO等。标准的IO提供了三种类型的缓存。 ...
  • 标准IO系统IO比较

    2019-08-13 15:45:39
    分别使用标准IO系统IO随机写入1000000个整数到文件,比较哪种更快。 标准I/O程序: #include <stdio.h> #include <stdlib.h> int main() { FILE* fwp = fopen("std.bin","w"); for(int i=0; i<...
  • C | 文件IO和标准IO区别 文件IO和标准IO各有所长。文件IO属于系统调用,是由操作系统提供的API接口,执行速度快。但频繁调用文件IO会降低内核的工作效率。不同的操作系统的API接口不同,因此造成文件IO可移植性的...
  • 标准库IO与系统调用IO区别与联系

    千次阅读 2021-03-27 10:59:32
    标准IO接口: 一般程序运行起来,自动默认打开 标准输入文件(scanf),标准输出文件(printf), 标准错误文件 fopen 打开文件 FILE* fopen(带路径的文件名,打开方式:"r r+ w w+ a a+ b") r:只读 若文件不...
  • Linux中的系统IO标准IO

    千次阅读 多人点赞 2019-01-27 09:42:09
    一、系统IO标准IO区别 什么是系统IO标准IO:(IO为Input/Output,即...系统IO和标准IO的主要区别系统IO:不带缓冲机制,系统IO可以操作普通文件与驱动文件 标准IO:带缓冲机制,标准IO只可以操作普通...
  • 文件IO和标准IO区别

    2022-06-30 15:37:36
    文件IO和标准IO区别
  • 标准IO和文件IO

    2022-03-17 20:57:24
    一、标准IO 标准I/O指的是ANSIC中定义的用于I/O操作的一系列函数,所需头文件:#include<stdio.h> 流: 标准I/O都是基于流进行操作,当用标准I/O打开一个文件时,就会创建一个FILE结构体来描述这个文件,...
  • 文件操作既可以用系统IO实现,也可以用标准IO实现,那二者又有联系和区别呢? 联系 标准IO的实质是调用系统IO完成文件操作,即标准IO的执行依附于系统IO区别 系统IO是低级IO,通过API直接与操作系统内核...
  • 文章目录C语言标准IO和系统IO哪个更快以及原因 C语言标准IO和系统IO哪个更快以及原因 标准IO更快 因为标准IO使用了缓冲技术,当数据写入时并没有立即把数据交给内核,而是先存放在缓冲区中,当缓冲区满时,会一次性...
  • 标准C库IOlinux系统IO的关系:调用被调用的关系。 C库IO会调用linux系统IO 参考:牛客网 C++高薪求职项目《Linux高并发服务器开发》1.17标准C库IO函数linux系统IO函数对比 专属优惠链接: ...
  • 标准文件IO和系统文件IO区别

    千次阅读 2016-10-27 15:07:41
    标准文件IO和系统文件IO区别 标准文件IO:fopen() fclose() fread() fwrite() fseek() 系统文件IO:open() close() read() write() lseek() 区别标准文件IO只能读写普通文本文件二进制文件;系统文件IO...
  • 标准IO和系统IO写入速度比较 众所周知,标准IO的速度要比系统IO快。 那为什么系统调用要比标准C库调用慢呢? 测试: #include <fcntl.h> #include <stdio.h> #include <sys/stat.h> #include <...
  • 文件IO、标准IO区别及其效率

    千次阅读 2021-09-05 17:34:59
    系统IO:Unix/Linux下的系统文件IO,即文件访问机制不经过操作系统内核的缓存,数据直接在磁盘应用程序地址空间进行传输。 标准IO:带缓存的IO,又称为标准IO(C标准库中提供了标准IO库,即stdio),它实现了跨平台...
  • 文件 IO 是 Linux 系统提供的接口, 针对文件磁盘进行操作, 不带缓存机制; 标准 IO 是 C 语言函数库里的标准 I/O 模型, 在 stdio.h 中定义, 通过缓冲区操作文件, 带缓存机制。 Linux 系统中一切皆文件, 包括...
  • 因为标准IO使用缓存技术,当数据写入时并没有立即把数据交给内核,而是先放在缓存区中,当缓存区满时,会一次性把缓冲区中的数据交给内核,这样就减少了内核...如果为系统IO设置更大的缓冲区,它会比标准IO更快。 ...
  • 标准IO和文件IO区别

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

    2018-03-09 12:31:22
    Linux系统IO标准IO的具体使用介绍,摘自Linux 环境编程图文指南
  • 标准c库函数linux系统函数区别标准c库可以跨平台;(调用了不同平台的系统API) 在linux平台中,调用c库函数,底层是调用的是linux中的系统函数 linux系统I/O函数是没有缓冲区的,调用一次就会访问一次 ...
  • I/O输入/输出(Input/Output),分为IO设备和IO接口两个部分。 在POSIX兼容的系统上,例如Linux系统,I/O操作可以有多种方式,比如DIO(Direct I/O),AIO(Asynchronous,I/O 异步I/O),Memory-Mapped I/O(内存映设I/O)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 317,634
精华内容 127,053
关键字:

标准io和系统io的区别