Linux中的基础IO

这篇具有很好参考价值的文章主要介绍了Linux中的基础IO。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

1、关于C语言中的文件操作符

1.1 C语言中写文件

1.2 C语言读文件

1.3 往显示器上输出信息

1.4 stdin & stdout & stderr

1.5 打开文件的方式

2、系统文件IO

2.1 写操作文件

2.2 读操作文件、

2.3 open

open函数的返回值

2.4 文件描述符

0 & 1 & 2

文件描述符的分配规则

2.5 重定向和dup2

 3、缓冲区相关

4、理解文件系统

4.1 inode

4.2 理解硬链接

4.3 软链接

5、动态库和静态库

静态库和动态库

a. 生成静态库

b. 生成动态库


1、关于C语言中的文件操作符

1.1 C语言中写文件

#include <stdio.h> 
#include <string.h>
int main() 
{
    FILE *fp = fopen("myfile", "w"); 
    if(!fp){
        printf("fopen error!\n"); 
    }
    const char *msg = "hello ltx!\n"; 
    int count = 5;
    while(count--){
        fwrite(msg, strlen(msg), 1, fp); 
    }
    fclose(fp); 
    return 0;
}

1.2 C语言读文件

#include <stdio.h> 
#include <string.h>
int main() 
{
    FILE *fp = fopen("myfile", "r"); 
    if(!fp){
        printf("fopen error!\n"); 
    }
    char buf[1024];
    const char *msg = "hello bit!\n";
    while(1){
        ssize_t s = fread(buf, 1, strlen(msg), fp);
        if(s > 0){ 
            buf[s] = 0; 
            printf("%s", buf); 
        }
        if(feof(fp)){ 
            break; 
        }
    }
    fclose(fp); 
    return 0; 
}

1.3 往显示器上输出信息

#include <stdio.h> 
#include <string.h>
int main() 
{
    const char *msg = "hello fwrite\n"; 
    fwrite(msg, strlen(msg), 1, stdout);
    printf("hello printf\n");
    fprintf(stdout, "hello fprintf\n"); 
    return 0;
}

1.4 stdin & stdout & stderr

C默认会打开三个输入输出流,分别是stdin, stdout, stderr

仔细观察发现,这三个流的类型都是FILE*, fopen返回值类型,文件指针

1.5 打开文件的方式

        r     Open text file for reading.
              The stream is positioned at the beginning of the file.

       r+    Open for reading and writing.
              The stream is positioned at the beginning of the file.

       w    Truncate(缩短) file to zero length or create text file for writing.
              The stream is positioned at the beginning of the file.

       w+   Open for reading and writing.                                                                                                       The file is created if it does not exist, otherwise it is truncated.
               The stream  is  positioned at the beginning of the file.

       a      Open for appending (writing at end of file).
              The file is created if it does not exist.
              The stream is positioned at the end of the file.

       a+   Open for reading and appending (writing at end of file).
              The file is created if it does not exist.  The initial file  position
              for reading is at the beginning of the file,
              but output is always appended to the end of the file.

以上就是C语言中的一些文件操作

2、系统文件IO

操作文件,除了上述C接口(当然,C++也有接口,其他语言也有),我们还可以采用系统接口来进行文件访问,当然,其实其他语言在底层在一定程度上都可以说成时对系统操作的一些封装。

2.1 写操作文件

#include <stdio.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <unistd.h> 
#include <string.h>
int main() 
{
    umask(0);
    int fd = open("myfile", O_WRONLY|O_CREAT, 0644); 
    if(fd < 0){
        perror("open"); 
        return 1; 
    }
    int count = 5;
    const char *msg = "hello ltx!\n"; 
    int len = strlen(msg);
    while(count--){
        write(fd, msg, len);
        //fd: 文件操作符, msg:缓冲区首地址, len: 本次读取,期望写入多少个字节的数据。    
        //返回值:实际写了多少字节数据
    }
    close(fd); 
    return 0; 
}

2.2 读操作文件、

#include <stdio.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <unistd.h> 
#include <string.h>
int main() 
{
    int fd = open("myfile", O_RDONLY); 
    if(fd < 0){
        perror("open"); 
        return 1; 
    }
    char buf[1024];
    while(1){
        ssize_t s = read(fd, buf, strlen(msg));//类比write 
        if(s > 0){
            printf("%s", buf); 
        }else{
            break; 
        }
    }
    close(fd); 
    return 0; 
}

2.3 open

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

int open(const char *pathname, int flags);

int open(const char *pathname, int flags, mode_t mode);

        pathname: 要打开或创建的目标文件

        flags: 打开文件时,可以传入多个参数选项,用下面的一个或者多个常量进行“或”运算,构成flags。

参数:

        O_RDONLY: 只读打开

        O_WRONLY: 只写打开

        O_RDWR  : 读,写打开

上面这三个常量,必须指定一个且只能指定一个

        O_CREAT : 若文件不存在,则创建它。需要使用mode选项,来指明新文件的访问权限

        O_APPEND: 追加写

返回值

        成功:新打开的文件描述符

        失败:-1

如目标文件不存在,需要open创建,则第三个参数表示创建文件的默认权限,否则,使用两个参数的open。

open函数的返回值

        open函数的返回值是一个叫做文件描述符的东西,这个东西具体是什么呢,下面咱们展开讲讲:

        首先,我们得知道两个概念:一个是库函数、另一个是系统调用。

        什么是库函数,我们刚刚使用的C语言文件操作的相关函数,就叫做库函数。

        什么是系统调用呢:系统调用,其实也简单,他本质也是一些函数,但是是操作系统提供的。因为呢在一个操作系统的底层,他需要和一些驱动硬件的驱动做交互,也就是管理整个系统,不管是硬件,还是一些硬件驱动的软件,那些层面的功能十分的繁杂繁琐,要是这样暴露给开发者,那样的话,开发的成本会大大提升,所以呢在设计之初呢,人们选择对操作系统的底层做封装,不暴露下层的细节,对上层提供可操作的接口,这些接口就是系统调用,用来和底层交互。这就是系统调用。
 

Linux中的基础IO,linux,算法,运维

         了解万这些,我们再来看看open函数的返回值,

        既然open是操作系统对上层提供的一个系统调用,那么他的返回值,就一定和它内部的实现,也可以说是和操作系统对打开文件操作的实现有关系。接下来我们就说说操作系统是怎么对以打开文件做管理的:

        打开文件这个操作实际上就是将文件内容再加到内存,以便CPU进行操作,就是内存和磁盘的交互,文件从磁盘上被加载到内存,那操作系统是如何管理内存中的文件的呢?

        我们在之前的文章中提到过一个PCB,它本质上就是一个数据结构,用来管理内存中的进程的,那文件也是被某个进程打开的,是否也被他管理呢。是的,是这样的。

        用Linux做举例,Linux底层对PCB的实现,使用一个叫 task_struct 的结构体实现,在task_struct 这个结构体中,有一个叫 files 的结构体指针,指向一个 files 的结构体,这个 files 结构体中有一个指针数组,这些指针数组中的指针,用以指向一个个被打开的文件。这个指针数组中的下标,其实就是open函数的返回值,这样子说就很好理解了,而这个open函数的返回值,也就是指针数组的下标,就叫做文件描述符,

2.4 文件描述符

        接下来我们再详细分析一下这个文件描述符。

        通过上面的讲述,我们知道了,文件描述符就是一个数组的下标,也就是一个整数,那么我们打开第一个文件的时候,open的返回值是不是就是0呢,接着是1,2,3……我们来写代码验证一下,

#include <iostream>

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

using namespace std;

int main() {
    size_t fd1 = open("test01.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    size_t fd2 = open("test02.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    size_t fd3 = open("test03.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    cout << "fd1:" << fd1 << endl;
    cout << "fd2:" << fd2 << endl;
    cout << "fd3:" << fd3 << endl;

    close(fd1);
    close(fd2);
    close(fd3);

    return 0;
}

运行结果:

Linux中的基础IO,linux,算法,运维

         这里显示运行结果和我们想的并不一样,这是为什么,为什么从3开始,那么0,1,2去哪里了,接下来我们看看:

        人们都说在Linux中,一切皆文件,从哪里体现,在这里就能窥探到一些,

        在一个进程创建的时候,操作系统就会默认把标准输入(对应键盘),标准输出(对应显示器),标准错误(对应显示器),这三个打开文件加载到 files_struct 这个结构体中,这三个分别会将文件描述符为0 ,1,2的三个位置占据,所以我们在创建文件的时候,就会从3这个位置开始分配文件描述符。

0 & 1 & 2

        Linux进程默认情况下会有3个缺省打开的文件描述符,分别是标准输入0,  标准输出1,  标准错误2.

        0,1,2对应的物理设备一般是:键盘,显示器,显示器

所以输入输出还可以采用如下方式:

#include <stdio.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <string.h>
int main() 
{
    char buf[1024];
    ssize_t s = read(0, buf, sizeof(buf)); 
    if(s > 0){
        buf[s] = 0;
        write(1, buf, strlen(buf)); 
        write(2, buf, strlen(buf)); 
    }
    return 0; 
}

        而现在知道,文件描述符就是从0开始的小整数。当我们打开文件时,操作系统在内存中要创建相应的数据结构来描述目标文件。于是就有了file结构体。表示一个已经打开的文件对象。而进程执行open系统调用,所以必须让进程和文件关联起来。每个进程都有一个指针*files, 指向一张表files_struct,该表最重要的部分就是包涵一个指针数组,每个元素都是一个指向打开文件的指针!所以,本质上,文件描述符就是该数组的下标。所以,只要拿着文件描述符,就可以找到对应的文件

文件描述符的分配规则

        在一个进程启动的时候,文件描述符为0,1,2的三个位置已经被占了,如果我们将1或者0中对应的文件关闭,这个时候在打开文件,这个文件的文件描述符还会是3嘛,我们来验证一下:

#include <iostream>

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

using namespace std;

int main() {
    
    close(1);
    size_t fd1 = open("test01.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    cout << "fd1:" << fd1 << endl;
    
    close(fd1);
    return 0;
}

运行结果:

Linux中的基础IO,linux,算法,运维

         我们发现这里啥也看不到,这是为啥,因为我们关掉了文件描述符为1的文件,正是标准输出,那我们,打开这个文件,看看里面有没有内容

Linux中的基础IO,linux,算法,运维

         我们发现,原本该输出到命令行的内容,被写入到了这个文件中,而且显示,被打开的这个文件的文件描述符是1,而不是3,所以这里就说明了,文件描述符是从0开始,找到第一个空的,这样子进行分配的,

        细看上面这个例子,这不就是重定向嘛,哈哈哈哈,没错,其实linux使用 > 进行重定向底层的实现原理就和这个差不多,下面我们顺便看看重定向

2.5 重定向和dup2

        通过上面那个例子,我们发现本该输出到命令行上的内容,被写入到了test01.txt这个文件中了,这种现象就叫做重定向,

        上面那种实现,就是重定向的实现的一种,将系统的标准输出关闭,然后打开文件,使用系统打印函数,就可以将内容写入到文件中,

        另外呢,系统给我们提供了一个系统调用dup2,其实dup函数有好几个,但是最常用的就是dup2,

#include <unistd.h>
int dup2(int oldfd, int newfd);

注意:这里的oldfd和newfd各自所指的是什么,比如我们现在要将本该输出到命令行上的内容重定向到test01中,那么oldfd就是test01的文件描述符,newfd就是标准输出1,它的本质就是将oldfd中存储的指针,拷贝并覆盖newfd指针所在数组指针的位置,

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

using namespace std;

int main() {
    size_t fd = open("test01.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    dup2(fd, 1);
    cout << "hello ltx!" << endl;
    close(fd);
    return 0;
}

运行结果:

Linux中的基础IO,linux,算法,运维

 3、缓冲区相关

我们看一段代码:

#include <stdio.h> 
#include <string.h>
int main() 
{
    const char *msg0="hello printf\n";
    const char *msg1="hello fwrite\n";
    const char *msg2="hello write\n";
    printf("%s", msg0);
    fwrite(msg1, strlen(msg0), 1, stdout); 
    write(1, msg2, strlen(msg2));
    fork(); 
    return 0;
}

运行结果:

//hello printf
//hello fwrite
//hello write

但如果对进程实现输出重定向呢?./hello > file  我们发现结果变成了:

//hello write
//hello printf
//hello fwrite
//hello printf
//hello fwrite

        我们发现printf和fwrite都输出了两次,write输出了一次,这是为什么?那肯定就和fork有关了,

        一般C库函数写入文件时是全缓冲的,而写入显示器是行缓冲。printf和fwrite库函数会自带缓冲区库,当发生重定向到普通文件时,数据的缓冲方式由行缓冲变成了全缓冲。而我们放在缓冲区中的数据,就不会被立即刷新,甚至fork之后但是进程退出之后,会统一刷新,写入文件当中。但是fork的时候,父子数据会发生写时拷贝,所以当你父进程准备刷新的时候,子进程也就有了同样的一份数据,随即产生两份数据。

write没有变化,说明没有所谓的缓冲。

4、理解文件系统

        我们使用ls -l的时候看到的除了看到文件名,还看到了文件元数据。

Linux中的基础IO,linux,算法,运维

 每行包含7列:

        模式

        硬链接数

        文件所有者

        组

        大小

        最后修改时间

        文件名

ls -l读取存储在磁盘上的文件信息,然后显示出来

其实这个信息除了通过这种方式来读取,还有一个stat命令能够看到更多信息

Linux中的基础IO,linux,算法,运维

 上面的执行结果有几个信息需要解释清楚

4.1 inode

为了能解释清楚inode我们先简单了解一下文件系统

Linux中的基础IO,linux,算法,运维

         Linux ext2文件系统,上图为磁盘文件系统图(内核内存映像肯定有所不同),磁盘是典型的块设备,硬盘分区被划分为一个个的block。一个block的大小是由格式化的时候确定的,并且不可以更改。例如mke2fs的-b选项可以设定block大小为1024、2048或4096字节。而上图中启动块(Boot Block)的大小是确定的,

        Block Group:ext2文件系统会根据分区的大小划分为数个Block Group。而每个Block Group都有着相同的结构组成。政府管理各区的例子

        超级块(Super Block):存放文件系统本身的结构信息。记录的信息主要有:bolck 和 inode的总量,未使用的block和inode的数量,一个block和inode的大小,最近一次挂载的时间,最近一次写入数据的时间,最近一次检验磁盘的时间等其他文件系统的相关信息。Super Block的信息被破坏,可以说整个文件系统结构就被破坏了

        GDT,Group Descriptor Table:块组描述符,描述块组属性信息,有兴趣的同学可以在了解一下

        块位图(Block Bitmap):Block Bitmap中记录着Data Block中哪个数据块已经被占用,哪个数据块没有被占用

        inode位图(inode Bitmap):每个bit表示一个inode是否空闲可用。

        i节点表:存放文件属性  如  文件大小,所有者,最近修改时间等

        数据区:存放文件内容

创建一个新文件主要有一下4个操作:

1. 存储属性

        内核先找到一个空闲的i节点(这里是263466)。内核把文件信息记录到其中。

2. 存储数据

        该文件需要存储在三个磁盘块,内核找到了三个空闲块:300,500,800。将内核缓冲区的第一块数据复制到300,下一块复制到500,以此类推。

3. 记录分配情况

        文件内容按顺序300,500,800存放。内核在inode上的磁盘分布区记录了上述块列表。

4. 添加文件名到目录

        新的文件名abc。linux如何在当前的目录中记录这个文件?内核将入口(263466,abc)添加到目录文件。文件名和inode之间的对应关系将文件名和文件的内容及属性连接起来。

4.2 理解硬链接

我们看到,真正找到磁盘上文件的并不是文件名,而是inode。  其实在linux中可以让多个文件名对应于同一个inode。  

[root@localhost linux]# touch abc

[root@localhost linux]# ln abc def

[root@localhost linux]# ls -1i

abc def 263466 abc 263466 def

abc和def的链接状态完全相同,他们被称为指向文件的硬链接。内核记录了这个连接数,inode263466 的硬连接数为2。

我们在删除文件时干了两件事情:

        1.在目录中将对应的记录删除,

        2.将硬连接数-1,如果为0,则将对应的磁盘释放。

Linux中的基础IO,linux,算法,运维

 

4.3 软链接

硬链接是通过inode引用另外一个文件,软链接是通过名字引用另外一个文件,在shell中的做法

Linux中的基础IO,linux,算法,运维

 我们发现软链接的文件有自己的inode

5、动态库和静态库

静态库和动态库

        静态库(.a):程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库

        动态库(.so):程序在运行的时候才去链接动态库的代码,多个程序共享使用库的代码。

        一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表,而不是外部函数所在目标文件的整个机器码,在可执行文件开始运行以前,外部函数的机器码由操作系统从磁盘上的该动态库中复制到内存中,这个过程称为动态链接(dynamic linking)

        动态库可以在多个程序间共享,所以动态链接使得可执行文件更小,节省了磁盘空间。操作系统采用虚拟内存机制允许物理内存中的一份动态库被要用到该库的所有进程共用,节省了内存和磁盘空间。

a. 生成静态库

[root@localhost linux]$ ls
add.c  add.h  main.c  sub.c  sub.h
[root@localhost linux]$ gcc -c add.c -o add.o 
[root@localhost linux]$ gcc -c sub.c -o sub.o
#生成静态库
[root@localhost linux]$ ar -rc libmymath.a add.o sub.o 
#ar是gnu归档工具,rc表示(replace and create)
#查看静态库中的目录列表
[root@localhost linux]$ ar -tv libmymath.a 
rw-r--r-- 0/0   1240 Sep 15 16:53 2017 add.o 
rw-r--r-- 0/0   1240 Sep 15 16:53 2017 sub.o 
#t:列出静态库中的文件
#v:verbose 详细信息
[root@localhost linux]$ gcc main.c -L. -lmymath 
#-L 指定库路径
#-l 指定库名
#测试目标文件生成后,静态库删掉,程序照样可以运行。

库搜索路径

        从左到右搜索-L指定的目录。

        由环境变量指定的目录  (LIBRARY_PATH)

        由系统指定的目录

                /usr/lib

                /usr/local/lib

b. 生成动态库

shared: 表示生成共享库格式

fPIC:产生位置无关码(position independent code)

库名规则:libxxx.so

[root@localhost linux]$ ls
add.c  add.h  main.c  sub.c  sub.h
[root@localhost linux]$ gcc -fPIC -c add.c -o add.o 
[root@localhost linux]$ gcc -fPIC -c sub.c -o sub.o
#生成动态库
[root@localhost linux]$ gcc -shared -o libmymath.so *.o 
[root@localhost linux]$ gcc main.c -L. -lmymath 
#-L 指定库路径
#-l 指定库名

但是生成动态库之后,运行不了,还是会报错,

        动态链接器,在它内部有一个默认的搜索顺序,按照优先级从高到低的顺序是:

        1.可执行文件内部的 DT_RPATH 段

        2.系统的环境变量 LD_LIBRARY_PATH

        3.系统动态库的缓存文件 /etc/ld.so.cache

        4.存储动态库 / 静态库的系统目录 /lib/, /usr/lib 等

        按照以上四个顺序,依次搜索,找到之后结束遍历,最终还是没找到的话,动态连接器就会提示动态库找不到的错误信息。

这个时候,就需要把我们的动态库的路径配置到环境变量中,或者配置到系统配置文件中,,通常我们的解决办法:

        1、拷贝.so文件到系统共享库路径下, 一般指/usr/lib

        2、更改:LD_LIBRARY_PATH

                export LD_LIBRARY_PATH = #$LD_LIBRARY_PATH + "路径"

        3、ldconfig  配置/etc/ld.so.conf.d/,ldconfig更新

                cat /etc/ld.so.conf.d/ltx.conf(在创建的这个文件中配置我们的动态库路径)

                        /root/tools/linux

                ldconfig(创建出动态装入程序(ld.so)所需的连接和缓存文件)文章来源地址https://www.toymoban.com/news/detail-685547.html

到了这里,关于Linux中的基础IO的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • [Linux] 基础IO

    🥁 作者 : 华丞臧 . 📕 ​​​​专栏 :【LINUX】 各位读者老爷如果觉得博主写的不错,请诸位多多支持( 点赞+收藏+关注 )。如果有错误的地方,欢迎在评论区指出。 推荐一款刷题网站 👉 LeetCode刷题网站 C语言当中fopen和fclose通过文件的路径来打开和关闭文件,fread可以读取

    2023年04月22日
    浏览(31)
  • Linux——基础IO

    目录 C语言文件操作         fprintf​编辑 Linux下的文件操作(文件的系统调用接口)  open open的第三个参数 open的第二个参数 write  read 文件描述符fd 进程与被打开文件的关系(理解的关键) 见见猪跑 fd文件描述符的分配规则 结论 重定向 输入重定向原理  输出重定向原理  d

    2024年02月06日
    浏览(61)
  • Linux之基础IO

    1.即使是空文件也要在磁盘中占用空间,因为文件=文件数据+文件属性,空文件没有文件数据但是仍然有文件属性。 2.因为文件=文件内容+文件属性,所以对文件的操作无非就是对内容/属性的操作。 3.在一个C程序中调用了文件操作函数,如果程序没有被执行这些文件操作函数

    2023年04月18日
    浏览(32)
  • Linux基础IO

    🚀在C语言中我们学习了大量关于文件的接口: 🚀如果这些接口有哪些不熟悉可以阅读一下这篇博客: C语言文件操作 🚀在C语言中,对文件进行读写操作首先第一步是通过fopen打开文件,打开文件的时候我们可以选择以何种方式打开,例如以读方式‘r’,写方式‘w’,追加

    2024年02月06日
    浏览(34)
  • 【linux】基础IO(四)

    在上一篇基础IO中我们主要讲述了文件再磁盘中的存储,当然我们说的也都只是预备知识,为这一篇的文件系统进行铺垫。 我们在开始之前还要有一个补充细节: 我们说过 文件 = 内容 + 属性 而他们本质上都是数据。 那么内容的数据与属性的数据是在一起存放嘛? 不同的文

    2024年04月11日
    浏览(28)
  • 【Linux】:基础IO

    共识原理: 1.文件=属性+内容。 2.文件分为打开文件和未打开文件。 3.打开的文件:进程打开。 4.未打开的文件:在磁盘里存放着。 5.文件打开,必须先被加载到内存。 6.一个进程可以打开多个文件,那么操作系统就必须先描述再组织的对文件进行管理。 fopen打开的文件如果

    2024年02月06日
    浏览(39)
  • 【Linux】基础IO —— 上

    🎇Linux:基础IO详解 博客主页: 一起去看日落吗 分享博主的在Linux中学习到的知识和遇到的问题 博主的能力有限,出现错误希望大家不吝赐教 分享给大家一句我很喜欢的话: 看似不起波澜的日复一日,一定会在某一天让你看见坚持的意义,祝我们都能在鸡零狗碎里找到闪闪

    2023年04月23日
    浏览(33)
  • 【Linux】基础IO—1

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 目录 文章目录 前言 先来段代码回顾C文件接口 \\\"w\\\"写文件 \\\"a\\\"追加文件 \\\"r\\\"读文件 输出信息到显示器,你有哪些方法 stdin stdout stderr 提炼一下对文件的理解(第一阶段) 理解文件并采用系统调用接口来访问文

    2024年04月10日
    浏览(31)
  • Linux基础IO(二)

    Linux基础IO(二) 缓冲区 为什么会有缓冲区 其实缓冲区的意义是节省进程进行数据 IO 的时间 。 怎么理解呢?我来举个例子: 孩子上大学了,学校里的水果又很贵,孩子给家里人说了,家里人知道了要给孩子每隔一段时间送点水果。下面有两个选项: 1.亲自开车给孩子送 2.发快

    2024年02月15日
    浏览(33)
  • Linux(基础IO详解)

    在基础IO这篇博客中,我们将了解到文件系统的构成,以及缓冲区究竟是个什么东东,我们都知道缓冲区,有时也谈论缓冲区,但不一定真的去深入了解过缓冲区。为什么内存和磁盘交互速度如此之慢?为什么都说Linux中一切皆文件?别急,在这篇博客中,你都会找到答案。此

    2024年02月08日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包