【Linux】基础IO —— 上

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

🎇Linux:基础IO详解


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

【Linux】基础IO —— 上

✨ ⭐️ 🌟 💫

💫 1. 简单复习文件操作

🌟 1.1 写文件

如果以"w"模式打开文件,默认是文本读写,且会把原始内容清掉再写。

#include<stdio.h>

int main()
{
	FILE* fp = fopen("./log.txt", "w");//以写的方式打开当前目录下的log.txt文件,没有就新建文件,如果目标文件存在,w写时会清空目标文件	
	//FILE* fp = fopen("log.txt", "w");//没有./,它默认是在当前路径下新建文件
    if(fp == NULL)
    {
        perror("fopen");
        return 1;
    }

    int count = 0;
    while(count < 10)
    {
        fputs("hello byih\n", fp);//往log.txt文件中写数据
        count++;                      
    }

    fclose(fp);//关闭文件

    return 0;
}

FILE* fp = fopen(“log.txt”, “w”);

虽然没有 ./ 指定路径,但是它还是在当前路径下新建文件了,因为每个进程都有一个内置的属性 cwd(可以在 /proc 目录下查找对应进程的属性信息),cwd 可以让进程知道自己当前所处的路径,这也解释了在 VS 中不指明路径,它也能新建对应的文件在对应的路径,换言之,进程在哪个路径运行,文件的新建就哪个路径。

【Linux】基础IO —— 上


🌟 1.2 读文件

fgets从特定文件流中按行读取,内容放在缓冲区。读取成功返回字符串起始地址,读失败返回NULL.

#include<stdio.h>

int main()
{
    FILE* fp = fopen("./log.txt", "r");//以读的方式打开当前目录下的log.txt文件,没有就报错
    if(fp == NULL)
    {
        perror("fopen");
        return 1;
    }

    int count = 0;
    char buffer[128];
    while(count < 10)
    {
        fgets(buffer, 128, fp);//从log.txt文件中读128个字符到buffer,\n会使fgets停止读取
        printf("%s\n", buffer);
        count++;
    }

    fclose(fp);//关闭文件

    return 0;
}


🌟 1.3 追加文件

#include<stdio.h>
#include<string.h>

int main()
{
    FILE* fp = fopen("./log.txt", "a");//以追加的打开当前目录下的log.txt文件,没有就新建,如果目标文件存在,a写时不会清空目标文件,在文件内容最后写入
    if(fp == NULL)
    {
        perror("fopen");
        return 1;
    }

    const char* msg = "Hello DanceBit\n";
    //fwrite(msg, strlen(msg) + 1, 1, fp);//乱码
    fwrite(msg, strlen(msg), 1, fp);                                                                               

    fclose(fp);

    return 0;
}


size_t fwrite ( const void* ptr, size_t size, size_t count, FILE* stream );

size 表示你要写入的基本单元是多大(以字节为单位),count 表示你要写入几个这样的基本单元。

fwrite(msg, strlen(msg) + 1, 1, fp);

strlen(msg) + 1 -> 乱码,也就是把 \0 也追加会造成,因为 \0 是 C 的规定,和文件无关。这里 cat log.txt 并没有看到乱码的原因是 \0 是不可见的,所以这里 vim log.txt 才可以看到乱码。


🌟 1.4 一切皆文件

C语言默认会打开三个输入输出流:stdin、stdout、stderr,它们的类型都是FILE*,C语言把它们当做文件看待;站在系统角度,stdin对应的硬件设备是键盘、stdout对应显示器、stderr对应显示器,本质上我们最终都是访问硬件。C++中也有cin、cout、cerr,几乎所有语言都提供标准输入、标准输出、标准错误。

【Linux】基础IO —— 上
默认情况下,标准输入是键盘文件,标准输出是显示器文件,标准错误是显示器文件。而这三个本身是硬件,如何理解 Linux 中,一切皆文件?

所有的外设硬件,本质对应的核心操作无外乎是 read 或 write。对于键盘文件,它的读方法就是从键盘读取数据到内存,对于显示器文件,如调用 printf 函数时,操作系统是要往显示器上写入的,其实你输入的命令是你通过键盘输入的,所以系统应该是往键盘读数据。至于用户能看到输入的命令,仅仅是为了方便用户,操作系统把从键盘输入的数据,一方面给了系统读取,一方面给显示器方便用户。所以不同的硬件,对应的读写方式肯定是不一样的,但是它们都有 read 和 write 方法,换言之,这里的硬件可以统一看作一种特殊的文件。比如这里设计一种结构叫做 struct file,它包括文件的属性、文件的操作或方法等。

Linux下的六字真言:先描述,在组织

组织就是要把每一个硬件对应的结构体关联起来,并用 file header 指向。所以在操作系统的角度,它看到的就是一切皆文件,也就是说所有硬件的差异,经过描述,就变成了同一种东西,只不过当具体访问某种设备时,使用函数指针执行不同的方法,就达到了不同的行为。

#include<stdio.h>
#include<string.h>

int main()
{
	const char* msg = "Hello DanceBit\n";
	fwrite(msg, strlen(msg), 1, stdout);

  	char buffer[64];
  	fread(buffer, 1, 10, stdin);//你输入时没有写\0,fread时也不会加,所以一旦超过10,就会出现乱码
  	buffer[10] = '\0';
  	printf("%s\n", buffer);

    return 0;
}

这里可以直接使用 fwrite 这样的接口,向显示器写数据的原因是因为 C 程序一运行,stdout 就默认打开了。同理 fread 能从键盘读数据的原因是 C 程序一运行,stdin 就默认打开了。

也就是说 C 接口除了对普通文件进行读写之外(需要打开),还可以对 stdin、stdout、stderr 进行读写(不需要打开)。

scanf -> 键盘、printf -> 显示器、perror -> 显示器


💫 2. 系统文件I/O

如上我们知道,这些文件操作最终都是访问硬件(显示器、键盘、文件(磁盘))。众所周知,OS是硬件的管理者。所有语言上对“文件”的操作,都必须贯穿操作系统。然而OS不相信任何人,访问操作系统,就必须要通过系统接口!!

其实我们学过的几乎所有的语言中,fopen/fclose,fread/fwrite,fputs/fgets,fgets/fputs 等底层一定需要使用OS提供的系统调用接口,下面咱们就来学习文件的系统调用接口

【Linux】基础IO —— 上

🌟2.1 open

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

int main()
{
    int fd = open("log.txt", O_WRONLY|O_CREAT, 0644);//打开
    if(fd < 0)
    {
        perror("open");
        return 1;
    }

    //操作
    const char* byh = "Hello System Call!\n";
    write(fd, byh, strlen(byh));
    write(fd, byh, strlen(byh));
    write(fd, byh, strlen(byh));
    write(fd, byh, strlen(byh));
                                                           
    close(fd);//关闭 

    return 0;
}

使用 open 需要包含三个头文件,它有两个版本。版本一:以 flags 方式打开 pathname;版本二:以 flags 方式打开 pathname,并设置 mode 权限。
【Linux】基础IO —— 上

pathname: 要打开或创建的目标文件文件名
flags:    打开方式。传递多个标志位,下面的一个或者多个常量进行“或”运算,构成flags.
             O_RDONLY: 只读打开
             O_WRONLY: 只写打开
             O_RDWR  : 读写打开
          以上这三个常量,必须指定一个且只能指定一个
             O_CREAT : 若文件不存在,则创建它。同时需要使用mode选项,来指明新文件的访问权限
             O_APPEND: 追加写
mode: 	  设置默认权限信息 

flags 可以是 O_RDONLY(read-only)、O_WRONLY(write-only)、O_RDWR(read/write),且必须包含以上访问模式之一。此外访问模式还可以带上 |标志位,下面会介绍一两个标志位,实际还要看场景使用。

以写的方式打开一个存在的文件,它同 fopen 一样,如果没有写操作,原文件的内容不会被覆盖;如果写操作,原文件的内容会被覆盖成写的内容。

以写的方式打开不存在的文件,权限是 644,运行程序发现没有新建文件 。

O_CREATE 发现文件不存在,将会新建文件,且必须指定 mode 权限(如果没有指定,那么新建的文件会变成可执行程序),如果没有 O_CREATE,说明文件是存在的,则可忽略 mode 权限(就算写了权限也不会对原来的文件更改权限)。


🌟2.2 close

【Linux】基础IO —— 上
使用 close 关闭文件,需要包含 unistd 头文件。fd 是 open 的返回值。


🌟2.3 read

要使用 read 读文件,需要包含 unistd 头文件。read 从 fd 文件描述符中读数据到 buf,读 count 个字节,返回值是实际读到的数据。

【Linux】基础IO —— 上

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

int main()
{
    int fd = open("log.txt", O_RDONLY);//打开
    if(fd < 0)
    {
        perror("open");
        return 1;
    }

    //操作
    char buffer[1024];
    ssize_t sz = read(fd, buffer, sizeof(buffer) - 1);//期望读1023个,但实际可能只有100个,是从文件读,文件并不遵守字符串\0的规则,所以要主动\0
    if(sz > 0)
    {
    	buffer[sz] = '\0';//利用read的返回值,实际读到的个数就是该被\0的位置
    	printf("%s\n", buffer);
    }                                                       

    close(fd);//关闭 

    return 0;
}


🌟2.4 write

使用 write 写入文件,需要包含 unistd 头文件。write 向 fd 文件描述符中写入 buf,写 count 个字节,返回值是写了多少个

【Linux】基础IO —— 上


🌟2.5 测试用例

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

int main()
{
    int fd = open("log.txt", O_WRONLY|O_APPEND);//打开
    if(fd < 0)
    {
        perror("open");
        return 1;
    }
    
    //操作
    const char* byh = "Hello System Call!\n";
    write(fd, byh, strlen(byh));
    write(fd, byh, strlen(byh));                    
                                                      
    close(fd);//关闭                                  
                                                      
    return 0;                                         
}                                                     

【Linux】基础IO —— 上


💫 3. 文件描述符fd

#include<stdio.h>  
#include<sys/types.h>  
#include<sys/stat.h>  
#include<fcntl.h>  
  
int main()  
{  
    int fd1 = open("log1.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
    int fd2 = open("log2.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
    int fd3 = open("log3.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
    int fd4 = open("log4.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);
    int fd5 = open("log5.txt", O_WRONLY|O_APPEND|O_CREAT, 0644);

    printf("fd1: %d\n", fd1);                                   
    printf("fd2: %d\n", fd2);  
    printf("fd3: %d\n", fd3);  
    printf("fd4: %d\n", fd4);  
    printf("fd5: %d\n", fd5);  
    
    return 0;  
}                                    

【Linux】基础IO —— 上
我们说过返回小于 0 的数,则代表 open 失败,显示这里 open 都成功了。但是这里为什么不从 0 开始依次返回?—— 上面我们说过 C 程序运行起来,默认会打开三个文件(stdin、stdout、stderr),所以 0, 1, 2 分别与之对应。

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

0,1,2对应的物理设备一般是:键盘,显示器,显示器
【Linux】基础IO —— 上

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


🌟 3.1 文件描述符的分配规则

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unisty.h>
int main()
{
	//close(0);
	close(2);
	int fd = open("myfile", O_RDONLY);
	if(fd < 0){
		perror("open");
		return 1;
	}
	
	printf("fd: %d\n", fd);
	
	close(fd);
	return 0;
}

【Linux】基础IO —— 上

每次给新文件分配的fd,是从fd_array[]中找一个最小的、未被使用的作为新的fd.

这其实很好理解,打开的文件要和进程产生关联,就要线性遍历数组中找一个未被使用的下标,填入文件地址。


💫 4. 重定向原理

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

int main()
{
    //close(0);
    close(1);

    int fd1 = open("log3.txt", O_CREAT|O_WRONLY, 0644);
    int fd2 = open("log4.txt", O_CREAT|O_WRONLY, 0644);

    printf("hello byh!: %d\n", fd1);
    printf("hello byh!: %d\n", fd2);

    fflush(stdout);
                                                       
    close(fd1);
    close(fd2);

    return 0;
}

【Linux】基础IO —— 上
要想看到数据也很简单,在 close 之前 fflush 强制刷新即可,但这里要注意 fd1 和 fd2 对应 1 和 3,它们都是磁盘文件,printf 时,因为缓冲区没满,所以都在语言层的缓冲区,但是 fflush 之后,就会一次性的把两次数据都往 fd1 指向的文件中刷新。本来 printf 应该往显示器上输出,但 close 1,open 新文件,导致 1 的指向由显示器转换为磁盘,导致最终往文件里输出,本质重定向改变的是底层文件描述符下标指针的内容,上层是不知道的,这种技术叫做输出重定向。

虽然 stdout 和 stderr 对应的设备都是显示器,但是它们是两个独立的文件描述符,且作用却大不相同。这里虽然它们最终都往显示器上输出,但是重定向时,却只能对 stdout 重定向,因为底层改的是 1,没有影响 2

【Linux】基础IO —— 上文章来源地址https://www.toymoban.com/news/detail-421989.html


基础IO上总结

  • 如何理解—— 一切皆文件。
  • 进程在启动时,默认会打开 0, 1, 2,对应 C 语言上,就是 stdin, stdout, stderr。
  • 库函数的文件操作和系统调用的文件操作。
  • FILE* 和 fd。
  • fd 本质是进程和文件之间对应关系的数组的下标,有了 fd,就可以找到,打开文件的所有细节。
  • FILE*,FILE 是一个结构体,它主要有两块重要的成员 _fileno、缓冲区。
  • 数据在文件层面的流动过程。
  • 初步了解了重定向的原理和现象。

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

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

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

相关文章

  • 【Linux】基础IO

    操作文件,除了C接口外,我们还可以采用系统接口来进行文件访问,我们来看看如下代码: 读文件 1.1 接口介绍 open man open open 函数具体使用那个,和具体的应用场景有关,如果目标文件不存在,需open创建,第三个参数表示创建文件的默认权限。 1.2 open函数返回值 认识一下

    2023年04月17日
    浏览(32)
  • 【linux】基础IO(四)

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

    2024年04月11日
    浏览(29)
  • Linux(基础IO详解)

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

    2024年02月08日
    浏览(42)
  • Linux 文件-基础IO

    文件=内容+属性 1 所有对文件的操作可分为两类:a 对内容操作 b 对属性操作 2 内容是数据,属性也是数据,存储文件必须既要存储内容,也要存储属性数据    默认文件在磁盘上 3 进程访问一个文件的时候,都要先把这个文件打开    打开前:普通的磁盘文件    打开后:将

    2024年02月22日
    浏览(50)
  • 【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&&fd&&重定向

    大家好我是沐曦希💕 空文件,也要在磁盘占据空间,因为文件也有属性,属性也属于数据,需要空间进行存储。所以 文件包括内容和属性 所以 对文件操作就是对内容或者对属性进行操作,或者对内容和属性进行操作。 文件具有唯一性,所以在 标定一个文件时候,必须使用

    2024年02月02日
    浏览(46)
  • 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、缓冲区相

    2024年02月10日
    浏览(41)
  • 【Linux】基础IO——文件系统

    磁盘计算机上唯一的一个机械设备,同时它还是外设 机械磁盘很便宜,虽然效率会慢一些,所以企业一般使用机械磁盘,因为便宜 磁盘不仅仅外设,还是一个机械设备(盘片、磁头),所以磁盘一定非常慢 盘片:一片两面,有一摞盘片 磁头:一面一个磁头 一个磁头负责一面的

    2023年04月09日
    浏览(46)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包