0. 文件先前理解

1. C文件接口

1.1 写文件

1.2 读文件

1.3 输出信息到显示器

1.4 总结 and stdin & stdout & stderr

2. 系统调用文件I/O

2.1 系统接口使用示例

2.2 接口介绍

2.3 open函数返回值

3. 文件描述符fd及重定向

3.1 0 & 1 & 2

3.2 文件描述符fd的理解

3.3 文件描述符Linux内核源码分析

3.4 文件描述符的分配规则

3.5 重定向

3.6 使用 dup2 系统调用

4. 在minishell中添加重定向功能

5. 有关FILE缓冲区及Linux一切皆文件理解

5.1 一切皆文件及C语言实现运行时多态

5.2 缓冲区

5.3 C标准库FILE结构体及缓冲区

5.4 大致模拟缓冲区设计

0. 文件先前理解

文件 = 文件内容 + 文件属性

因此，对文件进行的操作无非：对内容，对属性

文件本质存放在磁盘上，访问文件，先写代码 -> 编译 -> exe -> 运行 ->访问文件，其本质是进程在访问文件！！！

要向硬件写入，只有操作系统具备权利，而普通用户写入，则需要使用操作系统提供的文件类系统调用接口，而语言层面对系统调用接口进行了封装，由于不同操作系统平台提供的系统调用接口不同，语言把所有平台的代码都实现条件编译—动态裁剪，使其语言具有跨平台性！如果语言不提供对文件的系统接口的封装，所有访问文件的操作，都必须使用OS的接口，一旦使用系统接口，编写所谓的文件代码，就无法在其他平台安全运行，就不再具有跨平台性。

学习OS层面的文件系统，本质是为了更好的理解不同语言底层操作实际是相通的！

显示器是硬件，而printf向显示器打印，本质也是一种写入！

Linux下，一切皆文件，又该如何理解？

文件而言：

曾经理解的文件，站在写程序的角度，将文件打开，加载到内存，进行read，write

显示器：printf，cout -> 一种write

键盘：scanf，cin -> 一种read

普通文件 -> fopen/fread -> 你的进程内部（内存） -> fwrite -> 文件中

input output

站在系统的角度，能够被input读取，或者output写出的设备就叫做文件！

狭义的文件——普通磁盘文件

广义上的文件——显示器，键盘，网卡，声卡，显卡，磁盘。几乎所有外色，都可以称之为文件

1. C文件接口

打开文件：fopen

打开方式： r，r+，w，w+，a，a+...

fopen以当前路径打开文件或者相对路径打开文件

当前路径默认是：当一个进程运行起来，在其pcb结构体中，没个进程都会记录当前所处的工作路径—cwd（创建工作的目录）即为该进程的当前路径！

1.1 写文件

//打开文件

FILE * fopen ( const char * filename, const char * mode );

//关闭文件

int fclose ( FILE * stream );

//fwrite:

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

buffer—要写入的数据 size—一个元素的大小 count—几个元素 stream—文件流
#include <stdio.h>
#include <string.h>
int main()
{
	FILE* fp = fopen("myfile", "w");
	if (!fp) {
		printf("fopen error!\n");
	}
	const char* msg = "hello Linux!\n";
	int count = 5;
	while (count--) {
		fwrite(msg, strlen(msg), 1, fp);
	}
	fclose(fp);
	return 0;
}
注意：这里写入字符串不计算'\0'，因为字符串结束标志是C语言提供的，而不是操作系统所具有的！

1.2 读文件

//fread:

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

#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 Linux!\n";
	while (1) {
		size_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 输出信息到显示器

将写入的数据流入stdout，即输出到显示器

#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 总结 and stdin & stdout & stderr

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

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

打开文件的方式：

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.

如上，是我们之前学的文件相关操作。还有 fseek ftell rewind 的函数，在C部分已经有所涉猎，请同学们自行复习。

2. 系统调用文件I/O

操作文件，除了上述C接口（当然，C++也有接口，其他语言也有），我们还可以采用系统接口来进行文件访问，先来直接以代码的形式，实现和上面一模一样的代码！

2.1 系统接口使用示例

open close read write O_CREAT O_TRUNC O_WRONLY O_RDONLY O_RDWR...

写文件：

#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 Linux!\n";
	int len = strlen(msg);
	while (count--) {
		write(fd, msg, len);//fd: 后续， msg：缓冲区首地址， len: 本次读取，期望写入多少个字节的数
		//据。 返回值：实际写了多少字节数据
	}
	close(fd);
	return 0;
}

读文件：

#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;
	}
	const char* msg = "hello Linux!\n";
	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;
}

在应用层看到一个很简单的动作，在系统接口层面甚至OS层面，可能要做非常多的动作！

2.2 接口介绍

open —— man 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

mode_t理解：直接 man 手册，比什么都清楚。

open 函数具体使用哪个，和具体应用场景相关，如目标文件不存在，需要open创建，则第三个参数表示创建文件的默认权限,否则，使用两个参数的open。

2.3 open函数返回值

在认识返回值之前，先来认识一下两个概念: 系统调用和库函数

上面的 fopen fclose fread fwrite 都是C标准库当中的函数，我们称之为库函数（libc）
而， open close read write lseek 都属于系统提供的接口，称之为系统调用接口
操作系统概念时，画的一张图

系统调用接口和库函数的关系，一目了然。所以，可以认为，f#系列的函数，都是对系统调用的封装，方便二次开发。

3. 文件描述符fd及重定向

由上述系统调用open可知成功返回新打开的文件描述符（file descriptor）（fp）
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main()
{
    //未做差错处理
	int fd1 = open("myfile1", o_rdonly);
	int fd2 = open("myfile2", o_rdonly);
	int fd3 = open("myfile3", o_rdonly);
	int fd4 = open("myfile4", o_rdonly);
	
	printf("open sucess, fd: %d", fd1);
	printf("open sucess, fd: %d", fd2);
	printf("open sucess, fd: %d", fd3);
	printf("open sucess, fd: %d", fd4);
	close(fd1);
	close(fd2);
	close(fd3);
	close(fd4);
	return 0;
}
而打开多个文件，发现其fd从3开始依次递增！0,1,2去哪里了？

可知文件描述符就是一个小整数，如何理解文件描述符？

3.1 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;
}

3.2 文件描述符fd的理解

FILE* fopen（const char* path， const char* mode）；

C标准库提供的文件操作可知，FILE是一个由C标准库提供的结构体

由上述可知，C语言库函数内部一定封装了系统调用接口，lib在系统调用之上，站在系统角度，操作系统并不认识C语言内部的FILE结构体，只认识fd，因此FILE结构体内部，必定封装了fd！！

所以，fd是什么？

进程想要访问文件，必须先打开文件

一般而言，进程：打开文件 = 1 ：n

文件要被访问，前提是加载到内存中，才能直接被访问！

可知一个进程可以打开多个文件，多个进程运行时，会存在大量的被打开的文件，所以，操作系统需要把这些被各个进程打开的文件管理起来，如何管理？先描述，在组织！！！

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

3.3 文件描述符Linux内核源码分析

文件：磁盘文件（未被打开的文件）内存文件（被进程打开的文件）

因此没每个进程的PCB中都一个文件表指针struct files_struct * files，指向一个struct files_struct文件表结构体，该文件表结构体内一定包含一个struct file* fd_array[]文件指针数组，其数组每个对应存取指向一个被打开文件结构体file的指针，file记录了该文件的所有属性及所有内容。

fwrite() -> FILE* -> fd -> write -> write(fd, ...) -> 自己执行操作系统内部的write方法 -> 能找到进程的task_struct -> *files -> files_struct -> fd_array[] -> fd_array[fd] -> struct file -> 内存文件被找到 -> 操作
#include<stdio.h>
#include<stdlib.h>

struct File {
	void(*read_p)();
	void(*write_p)();
};

void readByKeyBoard() {
	cout << "从键盘读取" << endl;
}
void writeByKeyBoard() {
	cout << "nothing to do!" << endl;
}

void readByFile() {
	cout << "从文件读取" << endl;
}
void writeFile() {
	cout << "往文件写入" << endl;
}

void TestFile(struct File file) {
	file.read_p();
	file.write_p();
}

int main() {
	struct File fileByKB;
	fileByKB.read_p = readByKeyBoard;
	fileByKB.write_p = writeByKeyBoard;

	struct File fileByFILE;
	fileByFILE.read_p = readByFile;
	fileByFILE.write_p = writeFile;

	TestFile(fileByFILE);
	TestFile(fileByKB);
	return 0;
}
每个文件被加载到内存，其文件管理创建对应的file结构体，结构体内部会根据驱动填充相应的函数指针write，read等操作函数的地址，因为磁盘、显示器、键盘、网卡等不用硬件的读写方法不同，因此为了实现多态调用，C语言可以采用函数指针，实例化对象时填充不同的函数地址，以实现多态调用！

3.4 文件描述符的分配规则

直接看代码：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
 int fd = open("myfile", O_RDONLY);
 if(fd < 0){
 perror("open");
 return 1;
 }
 printf("fd: %d\n", fd);
 close(fd);
 return 0;
}
输出发现是 fd: 3

关闭0或者2，在看
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.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;
}
发现是结果是： fd: 0 或者 fd 2 可见，文件描述符的分配规则：在files_struct数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。

3.5 重定向

那如果关闭1呢？看代码：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main()
{
	close(1);
	int fd = open("myfile", O_WRONLY | O_CREAT, 00644);
	if (fd < 0) {
		perror("open");
		return 1;
	}
	printf("fd: %d\n", fd);
	fflush(stdout);

	close(fd);
	exit(0);
}
此时，发现，本来应该输出到显示器上的内容，输出到了文件 myfile 当中，其中，fd＝1。这种现象叫做输出重定向。常见的重定向有:>, >>, <

重定向的本质，其实是在OS内部，更改fd对应的内容的指向！！！

3.6 使用 dup2 系统调用

函数原型如下:

#include<unistd.h>

int dup2(int oldfd, int newfd);

这里的oldfd copy 给 newfd，必要时会释放oldfd

代码如下：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main() {
	int fd = open("./log", O_CREAT | O_RDWR);
	if (fd < 0) {
		perror("open");
		return 1;
	}
	close(1);
	dup2(fd, 1);
	for (;;) {
		char buf[1024] = { 0 };
		ssize_t read_size = read(0, buf, sizeof(buf) - 1);
		if (read_size < 0) {
			perror("read");
			break;
		}
		printf("%s", buf);
		fflush(stdout);
	}
	return 0;
}