【Linux】文件IO

r囧r小猫 2024-03-16 07:39 52阅读 0赞

**目录**

【1】文件系统重点概念

【2】重谈C语言的文件操作

【2.1】向文件写入数据

【2.2】向文件读取数据

【2.3】向文件追加数据

【3】系统文件IO

【3.1】使用write写入数据(以只写的方式打开)

【3.2】使用write写入数据(以追加的方式打开)

【3.3】使用read读取数据

【4】如何理解文件

【5】文件描述符

【5.1】文件描述符(0 & 1 & 2)

【5.2】文件描述符的分配规则

【5.3】重定向

【5.4】重定向dup2系统调用

【5.5】在MyShell中添加重定向功能

【6】如何理解linux下一切皆文件

【7】理解缓冲区

【8】FILE结构

【9】文件系统

【10】软硬连接

【10.1】硬链接

【10.2】软链接

【11】动静态库

【11.1】静态库

【11.1.1】库文件作为发布者

【11.1.2】库文件作为使用者

【11.2】动态库

【11.1.1】库文件作为发布者

【11.2.2】库文件作为使用者

【12】使用外部库

--------------------

## 【1】文件系统重点概念 ##

*  空文件，也要占磁盘的空间。
 *  文件 = 内容 + 属性。
 *  文件操作：等于对内容和对属性进行操作。
 *  标定一个问题，必须使用：文件路径 + 文件名【唯一性】
 *  如果没有指明对应文件路径，默认是当前路径进行文件访问。
 *  当我们把fopen,fclose,fread,fwrite等接口写完后，代码编译之后，形成的二进制可执行文件后，但是没有运行，文件对应的操作有没有被执行呢？答：没有被执行，本质：进程对文件的操作！
 *  一个文件如果没有被打开，可以直接进行文件访问吗？答：不能！一个文件要被访问，就必须先打开！

## 【2】重谈C语言的文件操作 ##

//打开文件
    FILE * fopen ( const char * filename, const char * mode );
    //关闭文件
    int fclose ( FILE * stream );

<table> 
 <tbody> 
 <tr> 
 <td> 功能 </td> 
 <td> 函数名 </td> 
 <td> 适用于 </td> 
 </tr> 
 <tr> 
 <td> 字符输入函数 </td> 
 <td> fgetc </td> 
 <td> 所有输入流 </td> 
 </tr> 
 <tr> 
 <td> 字符输出函数 </td> 
 <td> fputc </td> 
 <td> 所有输出流 </td> 
 </tr> 
 <tr> 
 <td> 文本行输入函数 </td> 
 <td> fgets </td> 
 <td> 所有输入流 </td> 
 </tr> 
 <tr> 
 <td> 文本行输出函数 </td> 
 <td> fputs </td> 
 <td> 所有输出流 </td> 
 </tr> 
 <tr> 
 <td> 格式化输入函数 </td> 
 <td> fscanf </td> 
 <td> 所有输入流 </td> 
 </tr> 
 <tr> 
 <td> 格式化输出函数 </td> 
 <td> fprintf </td> 
 <td> 所有输出流 </td> 
 </tr> 
 <tr> 
 <td> 二进制输入 </td> 
 <td> fread </td> 
 <td> 文件 </td> 
 </tr> 
 <tr> 
 <td> 二进制输出 </td> 
 <td> fwrite </td> 
 <td> 文件 </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> 文件使用方式 </td> 
 <td> 含义 </td> 
 <td> 如果指定文件不存在 </td> 
 </tr> 
 <tr> 
 <td> “r”（只读） </td> 
 <td> 为了输入数据，打开一个已经存在的文本文件 </td> 
 <td> 出错 </td> 
 </tr> 
 <tr> 
 <td> “w”（只写） </td> 
 <td> 为了输出数据，打开一个文本文件 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 <tr> 
 <td> “a”（追加） </td> 
 <td> 向文本文件尾添加数据 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 <tr> 
 <td> “rb”（只读） </td> 
 <td> 为了输入数据，打开一个二进制文件 </td> 
 <td> 出错 </td> 
 </tr> 
 <tr> 
 <td> “wb”（只写） </td> 
 <td> 为了输出数据，打开一个二进制文件 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 <tr> 
 <td> “ab”（追加） </td> 
 <td> 向一个二进制文件尾添加数据 </td> 
 <td> 出错 </td> 
 </tr> 
 <tr> 
 <td> “r+”（读写） </td> 
 <td> 为了读和写，打开一个文本文件 </td> 
 <td> 出错 </td> 
 </tr> 
 <tr> 
 <td> “w+”（读写） </td> 
 <td> 为了读和写，建议一个新的文件 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 <tr> 
 <td> “a+”（读写） </td> 
 <td> 打开一个文件，在文件尾进行读写 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 <tr> 
 <td> “rb+”（读写） </td> 
 <td> 为了读和写打开一个二进制文件 </td> 
 <td> 出错 </td> 
 </tr> 
 <tr> 
 <td> “wb+”（读写） </td> 
 <td> 为了读和写，新建一个新的二进制文件 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 <tr> 
 <td> “ab+”（读写） </td> 
 <td> 打开一个二进制文件，在文件尾进行读和写 </td> 
 <td> 建立一个新的文件 </td> 
 </tr> 
 </tbody> 
</table>

### 【2.1】向文件写入数据 ###

#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #define FILE_NAME "log.txt"
 int main(){
 // 打开文件
 FILE* fp = fopen(FILE_NAME, "w");
 if(fp == NULL){
 perror("fopen");
 exit(1);
 }
 
 // 写入数据
 int count = 5;
 while(count > 0){
 fprintf(fp, "Hello File IO:%d!\n", count);
 count--;
 }
 
 // 关闭文件
 fclose(fp); fp = NULL;
 return 0;
 }

### 【2.2】向文件读取数据 ###

#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #define FILE_NAME "log.txt"
 int main(){
 // 打开文件
 FILE* fp = fopen(FILE_NAME, "r");
 if(fp == NULL){
 perror("fopen");
 exit(1);
 }
 
 // 读取数据
 char buffer[64] = {0};
 while(fgets(buffer, sizeof(buffer) - 1, fp) != NULL){
 buffer[strlen(buffer) - 1] = 0;
 puts(buffer);
 }
 
 // 关闭文件
 fclose(fp); fp = NULL;
 return 0;
 }

### 【2.3】向文件追加数据 ###

int main(){
        // 打开文件
        FILE* fp = fopen(FILE_NAME, "a");
        if(fp == NULL){
            perror("fopen");
            exit(1);
        }
    
        // 写入数据
        int count = 5;
        while(count > 0){
            fprintf(fp, "Hello File IO:%d!\n", count);
            count--;
        }
    
        // 关闭文件
        fclose(fp); fp = NULL;
        return 0;
    }

## 【3】系统文件IO ##

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

理解标记位传参：

#include <stdio.h>
 #define ONE (1 << 0) // 0000 0000 0000 0001 -- 一共32位
 #define TWO (1 << 1) // 0000 0000 0000 0010 -- 一共32位
 #define THREE (1 << 2) // 0000 0000 0000 0100 -- 一共32位
 #define FOUR (1 << 3) // 0000 0000 0000 1000 -- 一共32位
 
 void Show(int flag){
 if(flag & ONE)
 printf("One\n");
 if(flag & TWO)
 printf("TWO\n");
 if(flag & THREE)
 printf("THREE\n");
 if(flag & FOUR)
 printf("FOUR\n");
 }
 
 int main(){
 printf("------------------------------\n");
 Show(ONE); // 打印结果：ONE
 printf("------------------------------\n");
 Show(ONE | TWO); // 打印结果：ONE TWO
 printf("------------------------------\n");
 Show(ONE | TWO | THREE); // 打印结果：ONE TWO THREE
 printf("------------------------------\n");
 Show(ONE | TWO | THREE | FOUR); // 打印结果：ONE TWO THREE FOUR
 return ;
 }

接口：

// C语言中fopen -> 对应的系统文件中的open
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 // 创建文件
 int creat(const char *pathname, mode_t mode);
 // 打开文件
 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: 追加写
 // mode：
 // 指明权限一般为666 
 // 返回值：
 // 成功：新打开的文件描述符
 // 失败：-1
 
 
 // C语言中fclose -> 对应的系统文件中的close
 #include <unistd.h>
 // 关闭文件
 int close(int fd);
 
 // 写入数据系统接口.
 #include <unistd.h>
 ssize_t write(int fd, const void* buf, size_t count);
 
 // 读取数据系统接口.
 #include <unistd.h>
 ssize_t read(int fd, void *buf, size_t count);

### 【3.1】使用write写入数据(以只写的方式打开) ###

#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 #define FILE_NAME "log.txt"
 // 使用系统接口创建文件.
 int main(){ 
 // 这里执行umask将系统的umask设置为0，如果不进行设置那么 下面的0666 & 系统umask
 umask(0);
 
 // 创建文件，并且打开文件。
 // 创建文件失败会返回1. 
 // O_WRONLY - 只写
 // O_CREAT - 创建.
 // O_TRUNC - 创建后清空文件内容.
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 if(fd < 0){
 // perror("open");
 printf("%s\n", strerror(errno));
 exit(1);
 }
 
 // 写入数据
 int count = 5;
 char outBuffer[64] = {0};
 // 系统只接收文本数据，所有要将所有的数据统一转为文本，统一接入的文件中.
 while(count > 0){
 sprintf(outBuffer, "%s:%d\n", "Hello SYS_FILE", count--);
 write(fd, outBuffer, strlen(outBuffer));
 }
 
 // 关闭对应文件资源.
 close(fd);
 
 return 0;
 }

### 【3.2】使用write写入数据(以追加的方式打开) ###

#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 #define FILE_NAME "log.txt"
 // 使用系统接口创建文件.
 int main(){
 // 这里执行umask将系统的umask设置为0，如果不进行设置那么 下面的0666 & 系统umask
 umask(0);
 
 
 // 创建文件，并且打开文件。
 // 创建文件失败会返回1. 
 // O_WRONLY - 只写
 // O_CREAT - 创建.
 // O_TRUNC - 创建后清空文件内容.
 // O_APPEND - 追加选项，要删除O_TRUNC
 
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 // perror("open");
 printf("%s\n", strerror(errno));
 exit(1);
 }
 
 // 写入数据
 int count = 5;
 char outBuffer[64] = {0};
 // 系统只接收文本数据，所有要将所有的数据统一转为文本，统一接入的文件中. 
 while(count > 0){
 sprintf(outBuffer, "%s:%d\n", "Hello SYS_FILE", count--);
 write(fd, outBuffer, strlen(outBuffer));
 }
 
 // 关闭对应文件资源.
 close(fd);
 
 return 0;
 }

### 【3.3】使用read读取数据 ###

#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 #define FILE_NAME "log.txt"
 int main(){
 // 这里执行umask将系统的umask设置为0，如果不进行设置那么 下面的0666 & 系统umask
 umask(0);
 
 // 打开文件. 
 // 创建文件，并且打开文件。
 // 创建文件失败会返回1.
 // O_RDONLY：只读方式打开 
 int fd = open(FILE_NAME, O_RDONLY);
 if(fd < 0){
 printf("%s\n", strerror(errno));
 exit(1);
 }
 
 // 读取文件中的内容.
 char buffer[1024] = {0};
 ssize_t ret = read(fd, buffer, sizeof(buffer)-1);
 if(ret > 0){
 // 在这里读取完毕后需要进行处理一下：
 // 因为在C语言中的 \0 = 0 = NULL 都是 0.
 buffer[ret] = 0;
 printf("%s\n", buffer);
 }
 
 // 关闭对应文件资源.
 close(fd); 
 return 0;
 }

## 【4】如何理解文件 ##

文件操作的本质是：进程与被打开文件的关系。

研究几个问题：

1.  进程可以打开多个文件吗？ 答案：可以---系统中一定存在大量的被打开的文件。
2.  被打开文件要不要OS管理起来呢？ 答案：肯定要，先描述，在组织。操作系统为了管理对应的打开文件，必定要为文件创建对应的内核数据标识文件\{struct file\{\}\}包含文件的大部分属性。

## 【5】文件描述符 ##

通过对open函数的学习，我们知道了文件描述符就是一个小整数

#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/fcntl.h>
 #define FILE_NAME(NUMBER) "log.txt"#NUMBER
 
 int main(){
 umask(0);
 int fd1 = open(FILE_NAME(1), O_WRONLY | O_CREAT | O_APPEND, 0666);
 int fd2 = open(FILE_NAME(2), O_WRONLY | O_CREAT | O_APPEND, 0666);
 int fd3 = open(FILE_NAME(3), O_WRONLY | O_CREAT | O_APPEND, 0666);
 int fd4 = open(FILE_NAME(4), O_WRONLY | O_CREAT | O_APPEND, 0666);
 int fd5 = open(FILE_NAME(5), O_WRONLY | O_CREAT | O_APPEND, 0666);
 
 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);
 
 close(fd1);
 close(fd2);
 close(fd3);
 close(fd4);
 close(fd5);
 return 0;
 }
 
 // 打印结果：
 [shaxiang@VM-8-14-centos lesson]$ ./myFile 
 fd1文件描述符：3
 fd2文件描述符：4
 fd3文件描述符：5
 fd4文件描述符：6
 fd5文件描述符：7 // 问题：文件描述符的 0 1 2 呢？

### 【5.1】文件描述符(0 & 1 & 2) ###

*  Linux进程默认情况下会有3个缺省打开的文件描述符，分别是标准输入0， 标准输出1， 标准错误2。
 *  0,1,2对应的物理设备一般是：键盘，显示器，显示。

printf("stdin的文件描述符：%d\n", stdin->_fileno);
    printf("stdout的文件描述符：%d\n", stdout->_fileno);
    printf("stderr的文件描述符：%d\n", stderr->_fileno);
    // 打印结果：
    stdin的文件描述符：0
    stdout的文件描述符：1
    stderr的文件描述符：2

![261370ce1a3d4351832510fba05d9a1e.png][]

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

### 【5.2】文件描述符的分配规则 ###

// 测试一》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #define FILE_NAME "log.txt"
 
 int main(){
 
 // 设定子程序的umask
 umask(0000);
 // 打开文件，设定选择项，权限设置为666
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 }
 
 printf("open df:%d\n", fd); 
 
 // 关闭文件.
 close(fd);
 
 return 0;
 }
 // 这段程序打印结果是3.
 
 // 测试二 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #define FILE_NAME "log.txt"
 
 int main(){
 
 close(0);
 // close(1);
 // close(2); 
 // 设定子程序的umask
 umask(0000);
 // 打开文件，设定选择项，权限设置为666
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 }
 
 printf("open df:%d\n", fd);
 
 // 关闭文件.
 close(fd);
 
 return 0;
 }
 // 这段程序打印结果是0.
 
 // 测试三 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #define FILE_NAME "log.txt"
 
 int main(){
 
 // close(0);
 close(1);
 // close(2); 
 // 设定子程序的umask
 umask(0000);
 // 打开文件，设定选择项，权限设置为666
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 }
 
 printf("open df:%d\n", fd);
 
 // 关闭文件.
 close(fd);
 
 return 0;
 }
 // 这段程序打印结果不显示.
 
 // 测试三 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #define FILE_NAME "log.txt"
 
 int main(){
 
 // close(0);
 // close(1);
 close(2); 
 // 设定子程序的umask
 umask(0000);
 // 打开文件，设定选择项，权限设置为666
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 }
 
 printf("open df:%d\n", fd);
 
 // 关闭文件.
 close(fd);
 
 return 0;
 }
 // 这段程序打印结果是2.

文件描述符的规则是：从小到大，按照循序寻找最小的且没有被占用的fd进行分配。

发现是结果是： fd: 0 或者 fd 2 可见，在files\_struct数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。

### 【5.3】重定向 ###

重定向的本质就是：上层用的fd不变，在内核中更改fd对应的struct file\*的地址。

#include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #define FILE_NAME "log.txt"
 
 int main(){
 
 // close(0);
 close(1);
 // close(2); 
 // 设定子程序的umask
 umask(0000);
 // 打开文件，设定选择项，权限设置为666
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 }
 
 printf("open df:%d\n", fd);
 
 // 关闭文件.
 close(fd);
 
 return 0;
 }
 // 这段程序打印结果不显示.
 
 // 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #define FILE_NAME "log.txt"
 
 int main(){
 
 // close(0);
 close(1); 
 // close(2);
 // 设定子程序的umask
 umask(0000);
 // 打开文件，设定选择项，权限设置为666
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 }
 
 fprintf(stdout, "open df:%d\n", fd);
 fflush(stdout);
 
 // 关闭文件.
 close(fd);
 
 return 0;
 }
 // 观察代码，将内容打印到文件中.

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

![8790fa4dcfe2436086f6d7d03c6b2fc1.png][]

### 【5.4】重定向dup2系统调用 ###

// 接口.
 #include <unistd.h>
 // 在两个文件描述中拷贝.
 int dup(int oldfd);
 int dup2(int oldfd, int newfd); // (常用)
 参数：
 oldfd：填写fd
 oldfd：填写 0 | 1 | 2 ....
 返回值：
 成功返回新的fd(fb本身)，失败返回-1
 
 #define _GNU_SOURCE /* See feature_test_macros(7) */
 #include <fcntl.h> /* Obtain O_* constant definitions */
 #include <unistd.h>
 
 int dup3(int oldfd, int newfd, int flags);

*  **打开重定向：**

#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #define FILE_NAME "log.txt"
 int main(){
 umask(0);
 // 打开文件
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 if(fd < 0){
 perror("open");
 exit(-1);
 }
 
 // 重定向，将fd赋值到1里 1 = 标准输出
 dup2(fd, 1);
 printf("open fd = %d\n", fd);
 fprintf(stdout, "open fd = %d\n", fd);
 
 // 关闭文件
 close(fd);
 return 0;
 }

*  **追加重定向：**

#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #define FILE_NAME "log.txt"
 int main(){
 umask(0);
 // 打开文件
 int fd = open(FILE_NAME, O_WRONLY | O_CREAT | O_APPEND, 0666);
 if(fd < 0){
 perror("open");
 exit(-1);
 }
 
 // 重定向，将fd赋值到1里 1 = 标准输出
 dup2(fd, 1);
 printf("open fd = %d\n", fd);
 fprintf(stdout, "open fd = %d\n", fd);
 
 // 关闭文件
 close(fd);
 return 0;
 }

*  **输入重定向：**

#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #define FILE_NAME "log.txt"
 int main(){
 umask(0);
 // 打开文件
 int fd = open(FILE_NAME, O_RDONLY);
 if(fd < 0){
 perror("open");
 exit(-1);
 }
 
 // 更改标准输入重定向
 dup2(fd, 0);
 char buffer[64] = {'\0'};
 while(1){
 printf("> ");
 if(fgets(buffer, sizeof(buffer), stdin) == NULL) 
 break;
 printf("%s", buffer);
 }
 
 // 关闭文件
 close(fd);
 return 0;
 }

### 【5.5】在MyShell中添加重定向功能 ###

#include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 #include <assert.h>
 #include <ctype.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 
 #define NUM 1024
 #define OPT_NUM 64
 #define NONE_REDIR 0
 #define INPUT_REDIR 1
 #define OUTPUT_REDIR 2
 #define APPEND_REDIR 3
 #define TrimSpace(pStart) \
 do{ \
 while(isspace(*pStart)) pStart++; \
 }while(0)
 
 
 char lineCommand[NUM]; // 数组buffer.
 char* myArgv[OPT_NUM]; // 指针数组buffer.
 int lastCode = 0;
 int lastSig = 0;
 
 int redirType = NONE_REDIR;
 char* redirFile = NULL;
 
 void CommandCheak(char* lineCommand){
 // 确保指针不是空指针.
 assert(lineCommand);
 // 找到 指向头的指针，指向尾巴的指针.
 char* pStart = lineCommand;
 char* pEnd = pStart + strlen(lineCommand);
 
 // 开始检查用户输入的指令,
 while(pStart < pEnd){
 if(*pStart == '>'){
 
 *pStart = '\0';
 pStart++;
 
 // 这里直接判断是不是追加重定向.
 if(*pStart == '>'){
 redirType = APPEND_REDIR;
 pStart++;
 }
 else{
 redirType = OUTPUT_REDIR;
 }
 TrimSpace(pStart);
 redirFile = pStart;
 break;
 
 }
 else if(*pStart == '<'){
 
 *pStart = '\0';
 pStart++;
 TrimSpace(pStart);
 // 填写重定向信息：
 redirType = INPUT_REDIR; 
 redirFile = pStart;
 break;
 }
 else{
 // 条件不满足，继续往下前进.
 pStart++;
 } 
 }
 }
 
 int main(){
 // 循环shell.
 while(1){
 /* 初始化 */
 redirFile = NULL;
 redirType = NONE_REDIR;
 
 /* 模式输出shell提示符： */
 printf("用户名@主机名 当前路径#：");
 fflush(stdout); // 立即刷新.
 
 /* 获取用户输入，例如：ls -a -l 这种 */
 const char* s = fgets(lineCommand, sizeof(lineCommand) - 1, stdin);
 assert(s != NULL);
 (void)s;
 /* 打印发现会有两个\n - 这里需要进行处理一下 */
 lineCommand[strlen(lineCommand) - 1] = 0;
 
 #if 0
 printf("%s\n", lineCommand);
 #endif 
 
 // 命令检查.
 CommandCheak(lineCommand);
 
 /* 字符获取完成，需要进行分割 */
 myArgv[0] = strtok(lineCommand, " ");
 
 int i = 1;
 // ls 特殊处理.
 if(myArgv[0] != NULL && strcmp(myArgv[0], "ls") == 0){
 myArgv[i++] =(char*)"--color=auto";
 }
 
 while(myArgv[i++] = strtok(NULL, " "));
 
 // cd 特殊处理.
 if(myArgv[0] != NULL && myArgv[1] && strcmp(myArgv[0], "cd") == 0){
 chdir(myArgv[1]);
 continue;
 }
 
 // echo 特殊处理.
 if(myArgv[0] != NULL && myArgv[1] != NULL && strcmp(myArgv[0], "echo") == 0){
 if(strcmp(myArgv[1], "$?") == 0){
 printf("%d %d\n", lastCode, lastSig);
 }
 else{
 printf("%s\n",myArgv[1]);
 }
 }
 
 #if 0 
 i = 0;
 while(myArgv[i] != NULL){
 printf("%s\n", myArgv[i]);
 i++;
 }
 #endif 
 
 /* 子程序执行对应的命令 */
 pid_t id = fork();
 assert(id != -1);
 
 // 子程序 - 执行.
 if(id == 0){
 
 // 因为命令是子程序执行的，真正重定向的工作一定是子程序来完成的.
 // 如何重定向，是父进程要给子程序提供信息.
 // 重定向不会影响父进程.
 switch(redirType){
 case NONE_REDIR:
 // 这里什么都不需要做.
 break;
 case INPUT_REDIR:
 {
 // 打开文件.
 int fd = open(redirFile,O_RDONLY);
 if(fd < 0){
 perror("open");
 exit(2);
 }
 // 重定向文件更改.
 dup2(fd, 0);
 }
 break;
 
 case OUTPUT_REDIR:
 case APPEND_REDIR:
 {
 // 去掉系统的umask.
 umask(0000);
 int flags = O_WRONLY | O_CREAT;
 if(redirType == APPEND_REDIR){
 flags |= O_APPEND;
 }
 else{
 flags |= O_TRUNC;
 }
 
 // 打开文件.
 int fd = open(redirFile, flags, 0666);
 if(fd < 0){
 perror("open");
 exit(2);
 }
 dup2(fd, 1); 
 }
 break;
 
 default:
 printf("Bug?\n");
 break;
 }
 
 
 execvp(myArgv[0], myArgv);
 exit(1);
 }
 
 /* 父进程监控 */
 int status = 0;
 pid_t ret = waitpid(id, &status, 0);
 if(ret > 0){
 (void)ret;
 lastCode = ((status >> 8) & 0xFF);
 lastSig = (status & 0x7F);
 }
 }
 
 return 0;
 }

## 【6】如何理解linux下一切皆文件 ##

![9756839f8e7842ecb86e2e99d88e4b4b.png][]

## 【7】理解缓冲区 ##

缓冲区就是一段内存空间。

缓冲区刷新策略的问题：缓冲区一定会结合具体的设备，定制自己的刷新策略！

*  立即刷新 - 无缓冲 - 很少
 *  行刷新 - 行缓冲 - 显示器
 *  缓冲区满 - 全缓冲 - 磁盘

当然，缓冲区也有强制刷新的时候，比如说用户强制刷新(fflush())，进程退出，一般都要进行缓冲区刷新。

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

int main(){
    
        // 打印信息：C函数的接口.
        printf("Hello Printf!\n");
        fprintf(stdout, "Hello Fprintf!\n");
        fputs("Hello Fputs!\n", stdout);
    
        // 打印信息，系统的接口.
        const char* msg = "Hello System Write!\n";     
        write(1, msg, strlen(msg));
    
        return 0;
    }
    
    // 现象：
    [ShaXiang@VM-8-14-centos C_LessonExercise]$ ./myShell         // 打印4次
    Hello Printf!
    Hello Fprintf!
    Hello Fputs!
    Hello System Write!
    [ShaXiang@VM-8-14-centos C_LessonExercise]$ ./myShell  > log.txt
    [ShaXiang@VM-8-14-centos C_LessonExercise]$ cat log.txt 
    Hello System Write!                                            // 打印4次
    Hello Printf!
    Hello Fprintf!
    Hello Fputs!

int main(){
    
        // 打印信息：C函数的接口.
        printf("Hello Printf!\n");
        fprintf(stdout, "Hello Fprintf!\n");
        fputs("Hello Fputs!\n", stdout);
    
        // 打印信息，系统的接口.
        const char* msg = "Hello System Write!\n";     
        write(1, msg, strlen(msg));
        
        fork();
        return 0;
    }
    
    // 现象
    [ShaXiang@VM-8-14-centos C_LessonExercise]$ ./myShell             // 打印4次
    Hello Printf!
    Hello Fprintf!
    Hello Fputs!
    Hello System Write!
    [ShaXiang@VM-8-14-centos C_LessonExercise]$ ./myShell  > log.txt 
    [ShaXiang@VM-8-14-centos C_LessonExercise]$ cat log.txt         // 打印了7次
    Hello System Write!
    Hello Printf!
    Hello Fprintf!
    Hello Fputs!
    Hello Printf!
    Hello Fprintf!
    Hello Fputs!

观察第二段代码，C接口的函数被打印了两次，系统接口被打印了一次，与fork()有关。

int main(){
    
        // 打印信息：C函数的接口.
        printf("Hello Printf!\n");
        fprintf(stdout, "Hello Fprintf!\n");
        fputs("Hello Fputs!\n", stdout);
        
        // 解释：
        // 代码结束之前，进行创建子进程：
        // 1、如果我们没有进行重定向（>）我们看到了4条消息，sydout默认使用的是行刷新策略，在进程fork之前，三条C语言打印函数将数据进行打印输出，到显示器（外设上），FILE内部就不存在对应的数据了。
        // 2、如果我们进行了重定向（>）写入文件不在是显示器，而是普通的文件，采用的刷新策略是全缓冲，之前的3条C语言函数虽然带了\n,但是不足以将stdout缓冲区写满，数据并没有进行刷新。在执行fork()的时候，stdout属于父进程，创建子进程的时候，紧接着就是进程的退出，谁先退出，一定要进行缓冲区刷新（就是修改）。这是执行写时拷贝，数据最终会显示两份。
        // write为什么没有呢？
        // 上面的过程和write无关，write没有FILE，而是使用的fd，就是没有C语言提供的缓冲区。
        
        // 打印信息，系统的接口.
        const char* msg = "Hello System Write!\n";     
        write(1, msg, strlen(msg));
    
        return 0;
    }

综上：printf fwrite 库函数会自带缓冲区，而 write 系统调用没有带缓冲区。另外，我们这里所说的缓冲区，都是用户级缓冲区。其实为了提升整机性能，OS也会提供相关内核级缓冲区，不过不再我们讨论范围之内。那这个缓冲区谁提供呢？ printf fwrite 是库函数， write 是系统调用，库函数在系统调用的“上层”， 是对系统调用的“封装”，但是 write 没有缓冲区，而 printf fwrite 有，足以说明，该缓冲区是二次加上的，又因为是C，所以由C标准库提供 。

## 【8】FILE结构 ##

因为IO相关函数与系统调用接口对应，并且库函数封装系统调用，所以本质上，访问文件都是通过fd访问的。所以C库当中的FILE结构体内部，必定封装了fd。

// 在/usr/include/libio.h
    
    struct _IO_FILE {
        int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
    #define _IO_file_flags _flags
        //缓冲区相关
        /* The following pointers correspond to the C++ streambuf protocol. */
        /* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
        char* _IO_read_ptr; /* Current read pointer */
        char* _IO_read_end; /* End of get area. */
        char* _IO_read_base; /* Start of putback+get area. */
        char* _IO_write_base; /* Start of put area. */
        char* _IO_write_ptr; /* Current put pointer. */
        char* _IO_write_end; /* End of put area. */
        char* _IO_buf_base; /* Start of reserve area. */
        char* _IO_buf_end; /* End of reserve area. */
        /* The following fields are used to support backing up and undo. */
        char* _IO_save_base; /* Pointer to start of non-current get area. */
        char* _IO_backup_base; /* Pointer to first valid character of backup area */
        char* _IO_save_end; /* Pointer to end of non-current get area. */
        struct _IO_marker* _markers;
        struct _IO_FILE* _chain;
        int _fileno; //封装的文件描述符
    #if 0
        int _blksize;
    #else
        int _flags2;
    #endif
        _IO_off_t _old_offset; /* This used to be _offset but it's too small. */
    #define __HAVE_COLUMN /* temporary */
        /* 1+column number of pbase(); 0 is unknown. */
        unsigned short _cur_column;
        signed char _vtable_offset;
        char _shortbuf[1];
        /* char* _save_gptr; char* _save_egptr; */
        _IO_lock_t* _lock;
    #ifdef _IO_USE_OLD_IO_FILE
    };

封装系统的文件调用接口再次理解缓冲区

// myStdio.h 文件 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 #include <stdbool.h> 
 #include <string.h> 
 #include <sys/types.h> 
 #include <sys/wait.h> 
 #include <fcntl.h> 
 #include <stdlib.h> 
 #include <errno.h> 
 #include <unistd.h> 
 #include <stdlib.h> 
 
 #define SIZE 1024 
 #define SYNC_NOW 1 
 #define SYNC_LINE 2 
 #define SYNC_FULL 4 
 
 // 自定义文件类型 
 typedef struct _FILE{ 
 int _flags; // 刷新方式. 
 int _fileno; 
 int _capacity; // buffer的容量. 
 int _size; // buffer的已使用量. 
 char _buffer[SIZE]; 
 
 }_FILE; 
 
 
 // 自定义文件接口. 
 _FILE* _Open (const char* pathName, const char* mode); 
 
 void _Fwrite(const void* ptr, int num, _FILE* fp); 
 
 void _Fclose(_FILE* fp); 
 
 // myStdio.c 文件 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 #include "myStdio.h"
 
 // 自定义文件接口.
 _FILE* _Open (const char* pathName, const char* mode){
 
 // 判断模式处理.
 int flags = 0;
 if(strcmp(mode, "r") == 0){
 flags |= O_RDONLY;
 }
 else if(strcmp(mode, "w") == 0){
 flags |= (O_WRONLY | O_CREAT | O_TRUNC);
 }
 else if(strcmp(mode, "a") == 0){
 flags |= (O_WRONLY | O_CREAT | O_APPEND);
 }
 else{
 // TODO.
 }
 
 // 打开文件接口处理.
 int fd = 0;
 if(flags & O_RDONLY)
 fd = open(pathName, flags);
 else
 fd = open(pathName, flags, 0666);
 
 if(fd < 0){
 printf("测试！\n");
 const char* strErr = strerror(errno);
 write(1, strErr, strlen(strErr));
 return NULL;
 }
 // 文件打开成功，申请文件空间.
 _FILE* fp = (_FILE*)malloc(sizeof(_FILE));
 if(fp == NULL){
 const char* strErr = strerror(errno);
 write(1, strErr, strlen(strErr));
 return NULL;
 }
 
 // 默认初始化.
 fp->_flags = SYNC_LINE; // 默认设置为行刷新.
 fp->_fileno = fd;
 fp->_capacity = SIZE;
 fp->_size = 0;
 memset(fp->_buffer, 0, SIZE);
 
 return fp;
 }
 
 void _Fwrite(const void* ptr, int num, _FILE* fp){
 
 // 1.写入到缓冲区中.
 memcpy(fp->_buffer + fp->_size, ptr, num);
 fp->_size += num;
 
 // 2.判断是否刷新.
 if(fp->_flags == SYNC_NOW){
 
 write(fp->_fileno, fp->_buffer, fp->_size);
 fp->_size = 0;
 }
 else if(fp->_flags == SYNC_LINE){
 
 if(fp->_buffer[fp->_size - 1] == '\n'){
 write(fp->_fileno, fp->_buffer, fp->_size);
 fp->_size = 0;
 }
 
 }
 else if(fp->_flags == SYNC_FULL){
 
 if(fp->_size == fp->_capacity){
 
 write(fp->_fileno, fp->_buffer, fp->_size);
 fp->_size = 0;
 }
 }
 else{
 // TODO.
 }
 }
 void _Fflush(_FILE* fp){
 
 if(fp->_size > 0){
 write(fp->_fileno, fp->_buffer, fp->_size);
 fsync(fp->_fileno);
 }
 }
 
 void _Fclose(_FILE* fp){
 
 _Fflush(fp);
 close(fp->_fileno);
 }
 
 // main.c 文件 》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
 #include "myStdio.h"
 
 int main(){
 _FILE* pf = _Open("log.txt", "w");
 if(pf == NULL){
 return 1;
 }
 
 const char* msg = "Hello ShaXiang! ";
 int cnt = 10;
 while(1)
 {
 _Fwrite(msg, strlen(msg), pf);
 sleep(1); 
 if(cnt == 0)
 break;
 
 cnt--;
 }
 
 _Fclose(pf);
 
 return 0;
 }

## 【9】文件系统 ##

如果一个文件没有被打开，操作系统OS如何管理呢？

没有被打开的文件只能静静的在磁盘上存放，存盘上会有大量的文件，也是必须要被静态管理起来的，方便我们随机打开它！

*  磁盘的物理结构：

我们目前是很少见到磁盘了，磁盘是我们计算机中唯一的一个机械结构，硬盘是一个机械结构 + 外设 = 硬盘访问会很慢(相对与CPU)！，企业端磁盘依旧是存储的主流。

![4fc61ff5c2f54775811b987830058f3f.png][]

*  磁盘的物理存储：

![98ba74a44fd14086b871f19b149c177a.png][]

磁盘在寻址的时候，基本单位不是Bit，也不是Byte，是扇区(512Byte)。

那么如何在磁盘中，定位任何一个扇区呢？限定为在哪一个磁道，在定位磁头(定义盘面)，最后在定位哪一个扇区。磁盘中定位任何一个扇区，采用硬件基本的定位方式：CHS定位法！

*  磁盘的逻辑存储：

磁盘物理上是圆形的，我们把它想想为线性结构。

![2edea6e222c14063bf97f5c8f650c2fb.png][]

虽然对应的磁盘的访问的基本单位是512字节，但是依旧是很小的，OS内的文件系统定制的进行多个扇区读取，1KB、2KB、4KB为基本单位、你哪怕指向读取/修改1bit，也必须将4KBload到内存，进行读取或者修改，如果必要，在写回磁盘。

局部性原理：

内存是被划分成为了4kb大小的空间 -----> 页框

磁盘中的文件尤其是可执行文件 -----> 按照4kb大小划分好的块 ------> 页帧

![01499921f26d4cfd8c440bcdbf3c213a.png][]

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节点表:存放文件属性 如 文件大小，所有者，最近修改时间等
 *  数据区：存放文件内容

将属性和数据分开存放的想法看起来很简单，但实际上是如何工作的呢？

我们通过touch一个新文件来看看如何工作。

touch file.txt
    ls -i file.txt
    // 打印结果：791061 file.txt

查找一个文件的时候，同一使用的是inode编号！

但是我们在日常用的不是inode编号，我们用的是文件名啊，目录也是文件，目录的数据块存放的是啥呢？ ---- 放的是当前目录下的文件名和inode的映射关系！

## 【10】软硬连接 ##

### 【10.1】硬链接 ###

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

创建硬链接：

[shaxiang@VM-8-14-centos lesson]$ ls
    file.txt  soft_file.link
    [shaxiang@VM-8-14-centos lesson]$ ln file.txt hard_file.txt                                // 创建硬链接
    [shaxiang@VM-8-14-centos lesson]$ ls
    file.txt  hard_file.txt  soft_file.link                                                    // hard_file.txt 是 file.txt的硬链接
    [shaxiang@VM-8-14-centos lesson]$ ll
    total 0
    -rw-rw-r-- 2 shaxiang shaxiang 0 May 28 22:21 file.txt
    -rw-rw-r-- 2 shaxiang shaxiang 0 May 28 22:21 hard_file.txt
    lrwxrwxrwx 1 shaxiang shaxiang 8 May 29 23:40 soft_file.link -> file.txt
    
     // unlink hard_file.txt 删除连接文件

[shaxiang@VM-8-14-centos lesson]$ ll -li                                                    // 查看inode指令
    total 0
    791061 -rw-rw-r-- 2 shaxiang shaxiang 0 May 28 22:21 file.txt
    791061 -rw-rw-r-- 2 shaxiang shaxiang 0 May 28 22:21 hard_file.txt
    791045 lrwxrwxrwx 1 shaxiang shaxiang 8 May 29 23:40 soft_file.link -> file.txt
    // 观察inode的值，发现软连接的inode和源文件的inode不同，硬链接的inode值与源文件inode相同.

![fb943559b1f44d68876ec0293fa3fbeb.png][]

软硬连接的区别：是否具有独立的inode的区别，软连接具有独立的inode，可以被看做独立文件看待，硬链接没有独立的inode。

实际上，建立硬链接，根本没有创建新的文件，因为没有给硬链接分配独立的inode，既然没有创建文件，那么一定没有自己的属性集合和内容集合，用的是别的文件的inode和内容。创建硬链接本质就是在指定的目录下，新增文件名和inode编号的映射关系！

关于硬链接提出什么是文件的引用计数，下图观察现象：

![1a0d20f695254d4a8c3edea65174bb5b.png][]

从这一现象，我们得知一个文件要在引用计数为0的时候，这个文件才算是真正的被删除了。

### 【10.2】软链接 ###

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

创建软连接：

[shaxiang@VM-8-14-centos lesson]$ ls
    file.txt
    [shaxiang@VM-8-14-centos lesson]$ ln -s file.txt soft_file.link                        // 创建软连接
    [shaxiang@VM-8-14-centos lesson]$ ls
    file.txt  soft_file.link                                                               // soft_file.link 是 file.txt 的软件连            
    [shaxiang@VM-8-14-centos lesson]$ ll                                                   // 观察
    total 0
    -rw-rw-r-- 1 shaxiang shaxiang 0 May 28 22:21 file.txt
    lrwxrwxrwx 1 shaxiang shaxiang 8 May 29 23:40 soft_file.link -> file.txt
    
     // unlink soft_file.link 删除连接文件

![37676c0eb31449a6a45afef5b714598b.png][]

源文件被删除，软连接就打不开了，由此可见，然链接不是依靠inode识别文件的，它是保存了连接文件的路径，接下来做一个实验，我们看一下：

![13d03abaf4004ae5ac6051d52c5c1d7e.png][]

扩展：

Access 最后访问时间。

Modify 文件内容最后修改时间

Change 属性最后修改时间。

## 【11】动静态库 ##

*  静态库（.a）：程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库。
 *  动态库（.so）：程序在运行的时候才去链接动态库的代码，多个程序共享使用库的代码。
 *  一个与动态库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机器码。
 *  在可执行文件开始运行以前，外部函数的机器码由操作系统从磁盘上的该动态库中复制到内存中，这个过程称为动态链接（dynamic linking）。
 *  动态库可以在多个程序间共享，所以动态链接使得可执行文件更小，节省了磁盘空间。操作系统采用虚拟内存机制允许物理内存中的一份动态库被要用到该库的所有进程共用，节省了内存和磁盘空间。

### 【11.1】静态库 ###

生成静态库     》》》》     新命令学习
    [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 指定库名
    测试目标文件生成后，静态库删掉，程序照样可以运行。

#### 【11.1.1】库文件作为发布者 ####

尝试将所有的 “ \*.o ” 文件打一个包，给提供库文件即可，库文件就是多个 “ \*.o ” 打包成一个库，从而生成动态链接和静态链接库。

// my_Add.h
 #include <stdio.h>
 int Add(int a, int b);
 // my_Add.c
 
 #include "my_Add.h"
 int Add(int a, int b){
 printf("enter Add Func:%d + %d = ?\n", a, b);
 return a + b;
 }
 
 // my_Sub.h
 #include <stdio.h>
 int Sub(int a, int b);
 
 // my_Sub.c
 #include "my_Sub.h"
 int Sub(int a, int b){
 printf("enter Add Func:%d + %d = ?\n", a, b);
 return a - b;
 }
 
 // my_Main.c
 #include "my_Add.h"
 #include "my_Sub.h"
 int main(){
 printf("result = %d\n", Add(2, 3));
 printf("result = %d\n", Sub(2, 3));
 }

编写Makefile创建形成.o文件和库文件的依赖关系

libMyMath.a:my_Add.o my_Sub.o
        # ar是gnu归档工具，rc表示(replace and create)(归档)
        ar -rc $@ $^
    my_Add.o:my_Add.c
        gcc -c my_Add.c
    my_Sub.o:my_Sub.c
        gcc -c my_Sub.c
    
    .PHONY:clean
    clean:
        rm -f *.o libMyMath
        
    》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》  
      
    libMyMath.a:my_Add.o my_Sub.o
    # ar是gnu归档工具，rc表示(replace and create)(归档)
        ar -rc $@ $^
    my_Add.o:my_Add.c
        gcc -c my_Add.c
    my_Sub.o:my_Sub.c
        gcc -c my_Sub.c
    
    # 自动化打包 
    .PHONY:output
    output:
        mkdir -p mylib/include
        mkdir -p mylib/lib
        cp -f *.a mylib/lib 
        cp -f *.h mylib/include
    
    # 自动化清除
    .PHONY:clean
    clean:
        rm -f *.o libMyMath

交付库需要将库文件.a.so + 匹配的头文件给别人,作为发布者需要打包

// 打包成压缩文件
    [shaxiang@VM-8-14-centos lesson]$ tar czf mylib.tgz mylib

到现在位置，库文件已经打包好了。

#### 【11.1.2】库文件作为使用者 ####

方式一使用gcc选项进行编译:

将下载好的压缩包进行解压

[shaxiang@VM-8-14-centos execute]$ tar xzf mylib.tgz                                     // 解压下载好的库文件包
    [shaxiang@VM-8-14-centos execute]$ ls
    mylib  mylib.tgz  my_Main.c
    [shaxiang@VM-8-14-centos execute]$ gcc -o myMath my_Main.c -I ./mylib/include -L ./mylib/lib -l MyMath        // 编译：
    [shaxiang@VM-8-14-centos execute]$ ll                    // -I 包含头文件的位置   -L 包含源文件(库文件)的位置      
    total 24
    drwxrwxr-x 4 shaxiang shaxiang 4096 May 31 15:49 mylib
    -rw-rw-r-- 1 shaxiang shaxiang  921 May 31 15:51 mylib.tgz
    -rw-rw-r-- 1 shaxiang shaxiang  135 May 31 16:02 my_Main.c
    -rwxrwxr-x 1 shaxiang shaxiang 8480 May 31 16:03 myMath        // 可执行程序被编译出来了
    
     // 可执行程序默认是动态库连接(建议行为)，对于特定的一个库，究竟是动态，还是静态，取决于你提供的是动态库还是静态库。
    [shaxiang@VM-8-14-centos execute]$ ldd myMath 
        linux-vdso.so.1 =>  (0x00007ffd199cc000)
        libc.so.6 => /lib64/libc.so.6 (0x00007fb0e25f5000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fb0e29c3000)
    [shaxiang@VM-8-14-centos execute]$

方式二将库文件安装到系统库文件夹中:

// 拷贝头文件
    [shaxiang@VM-8-14-centos execute]$ sudo cp ./mylib/include/* /usr/include/
    [shaxiang@VM-8-14-centos execute]$ ls /usr/include/my_*
    /usr/include/my_Add.h  /usr/include/my_Sub.h
    
    // 拷贝库文件
    [shaxiang@VM-8-14-centos execute]$ ls /lib64/libM*
    /lib64/libMyMath.a
    
     // 在进行编译
     [shaxiang@VM-8-14-centos execute]$ gcc -o myMath my_Main.c -l MyMath
    [shaxiang@VM-8-14-centos execute]$ ls
    mylib  mylib.tgz  my_Main.c  myMath

### 【11.2】动态库 ###

#### 【11.1.1】库文件作为发布者 ####

代码和上面一样

[shaxiang@VM-8-14-centos lesson]$ ls
    Makefile  my_Add.c  my_Add.h  my_Main.c  my_Sub.c  my_Sub.h
    
    // fPIC：产生位置无关码(position independent code)
    [shaxiang@VM-8-14-centos lesson]$ gcc -c -fPIC my_Add.c
    [shaxiang@VM-8-14-centos lesson]$ gcc -c -fPIC my_Sub.c
    
    // shared: 表示生成共享库格式
    [shaxiang@VM-8-14-centos lesson]$ gcc -shared -o libMyMath.so my_Add.o my_Sub.o 
    [shaxiang@VM-8-14-centos lesson]$ ls
    libMyMath.so  Makefile  my_Add.c  my_Add.h  my_Add.o  my_Main.c  my_Sub.c  my_Sub.h  my_Sub.o    // .so文件就是编译出来动态库.
    
     // 查看动态库格式
     [shaxiang@VM-8-14-centos lesson]$ file libMyMath.so 
    libMyMath.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=19b15cb7d1686fe51d50d79fbc3927a3bfa77005, not stripped

这里手动创建mylib目录

[shaxiang@VM-8-14-centos lesson]$ mkdir -p mylib/include
    [shaxiang@VM-8-14-centos lesson]$ mkdir -p mylib/lib
    [shaxiang@VM-8-14-centos lesson]$ cp libMyMath.so mylib/lib/
    [shaxiang@VM-8-14-centos lesson]$ cp my_Add.h my_Sub.h mylib/include/
    
    [shaxiang@VM-8-14-centos lesson]$ tree mylib/
    mylib/
    |-- include
    |   |-- my_Add.h
    |   `-- my_Sub.h
    `-- lib
        `-- libMyMath.so
    
    2 directories, 3 files
    
    // 将库文件进行打包

#### 【11.2.2】库文件作为使用者 ####

将下载好的压缩包进行解压

[shaxiang@VM-8-14-centos execute]$ tar xzf mylib.tgz                                     // 解压下载好的库文件包
    [shaxiang@VM-8-14-centos execute]$ ls
    mylib  mylib.tgz  my_Main.c
    
    [shaxiang@VM-8-14-centos execute]$ gcc -o myMath my_Main.c -I mylib/include/ -L mylib/lib/ -l MyMath
    [shaxiang@VM-8-14-centos execute]$ ldd myMath 
        linux-vdso.so.1 =>  (0x00007ffc2e516000)
        libMyMath.so => not found                                    // 未找到指明的链接库
        libc.so.6 => /lib64/libc.so.6 (0x00007f72ccc41000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f72cd00f000)
    
    [shaxiang@VM-8-14-centos execute]$ ./myMath 
    ./myMath: error while loading shared libraries: libMyMath.so: cannot open shared object file: No such file or directory
    // 运行不了？
    // 已经告诉了库文件、路径和库名称，当前编译是告诉gcc，当把程序编译完了，和gcc还有关系吗？ 没有关系，程序运行起来，OS和shell也是需要知道库在哪里。

方式一：通过更改LD\_LIBRARY\_PATH的方式

[shaxiang@VM-8-14-centos execute]$ pwd
    /home/shaxiang/lesson/execute/mylib/lib
    
    [shaxiang@VM-8-14-centos execute]$ echo $LD_LIBRARY_PATH                 // 先查看环境变量
    :/home/shaxiang/.VimForCpp/vim/bundle/YCM.so/el7.x86_64
    
    [shaxiang@VM-8-14-centos execute]$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/shaxiang/lesson/execute/mylib/lib
      // 将当前路径导入环境变量
    [shaxiang@VM-8-14-centos execute]$ echo $LD_LIBRARY_PATH                 // 再次查看环境变量
    :/home/shaxiang/.VimForCpp/vim/bundle/YCM.so/el7.x86_64:/home/shaxiang/lesson/execute/mylib/lib
    
    // 再次查看链接库
    [shaxiang@VM-8-14-centos execute]$ ls
    mylib  mylib.tgz  my_Main.c  myMath
    [shaxiang@VM-8-14-centos execute]$ ldd myMath 
        linux-vdso.so.1 =>  (0x00007ffd437f1000)
        libMyMath.so => /home/shaxiang/lesson/execute/mylib/lib/libMyMath.so (0x00007fdee156f000)    // 找到链接库了
        libc.so.6 => /lib64/libc.so.6 (0x00007fdee11a1000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fdee1771000)
    
    // 代码也可以正常运行了
    [shaxiang@VM-8-14-centos execute]$ ./myMath 
    enter Add Func:2 + 3 = ?
    result = 5
    enter Add Func:2 + 3 = ?
    result = -1

方式二：将库文件安装到系统库文件夹中:

*  将 libMyMath.so 拷贝到 /lib64/ 奴鲁下
 *  将my\_Add.h my\_Sub.h 拷贝到 /usr/include/ 目录下。

方式三：配置文件方案

[shaxiang@VM-8-14-centos ld.so.conf.d]$ cd /etc/ld.so.conf.d/                        // 进入系统配置文件下
    [shaxiang@VM-8-14-centos ld.so.conf.d]$ ll
    total 16
    -rw-r--r-- 1 root root 26 Jan 26 00:49 bind-export-x86_64.conf
    -rw-r--r-- 1 root root 19 Aug  9  2019 dyninst-x86_64.conf
    -r--r--r-- 1 root root 63 Jun 28  2022 kernel-3.10.0-1160.71.1.el7.x86_64.conf
    -rw-r--r-- 1 root root 17 Oct  2  2020 mariadb-x86_64.conf

在改路径里面创建.conf后缀的文件，将/home/shaxiang/lesson/execute/mylib/lib路径拷贝进去并且保存，在执行指令**ldconfig**这样就可以了.

![0bb3f97ae7474f5ea7127448407951e2.png][]

// 这样程序就可以执行了，并且重新打开shell也是效的.
    [shaxiang@VM-8-14-centos execute]$ ldd myMath                                                         // 查看依赖关系
        linux-vdso.so.1 =>  (0x00007fff8374d000)
        libMyMath.so => /home/shaxiang/lesson/execute/mylib/lib/libMyMath.so (0x00007f6219f83000)        // 有连接文件了
        libc.so.6 => /lib64/libc.so.6 (0x00007f6219bb5000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f621a185000)
    
    [shaxiang@VM-8-14-centos execute]$ ls
    mylib  mylib.tgz  my_Main.c  myMath
    [shaxiang@VM-8-14-centos execute]$ ./myMath 
    enter Add Func:2 + 3 = ?
    result = 5
    enter Add Func:2 + 3 = ?
    result = -1

方式四：通过软连接的方式

[shaxiang@VM-8-14-centos execute]$ ln -s ~/lesson/execute/mylib/lib/libMyMath.so libMyMath.so            // 创建动态库软连接
    [shaxiang@VM-8-14-centos execute]$ ll
    total 24
    lrwxrwxrwx 1 shaxiang shaxiang   52 May 31 22:39 libMyMath.so -> /home/shaxiang/lesson/execute/mylib/lib/libMyMath.so    // 软连接标志
    drwxrwxr-x 4 shaxiang shaxiang 4096 May 31 21:32 mylib
    -rw-rw-r-- 1 shaxiang shaxiang 2490 May 31 21:38 mylib.tgz
    -rw-rw-r-- 1 shaxiang shaxiang  136 May 31 16:34 my_Main.c
    -rwxrwxr-x 1 shaxiang shaxiang 8432 May 31 21:41 myMath
    
     // 这样就可以执行代码了
     [shaxiang@VM-8-14-centos execute]$ ./myMath 
    enter Add Func:2 + 3 = ?
    result = 5
    enter Add Func:2 + 3 = ?
    result = -1
    
    》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》 也可以将软连接建立到系统下的/lib64路径下
    [shaxiang@VM-8-14-centos execute]$ unlink libMyMath.so                                     // 删除连接文件                 
    [shaxiang@VM-8-14-centos execute]$ sudo ln -s ~/lesson/execute/mylib/lib/libMyMath.so /lib64/libMyMath.so    // 创建在系统的库文件目录下

## 【12】使用外部库 ##

系统中其实有很多库，它们通常由一组互相关联的用来完成某项常见工作的函数构成。比如用来处理屏幕显示情况的函数（ncursh1es库）

#include <math.h>
 #include <stdio.h>
 int main(void)
 {
 double x = pow(2.0, 3.0);
 printf("The cubed is %f\n", x);
 return 0;
 }
 gcc -Wall calc.c -o calc -lm
 // -lm表示要链接libm.so或者libm.a库文件

库文件名称和引入库的名称：如：libc.so -> c库，去掉前缀lib，去掉后缀.so,.a

[261370ce1a3d4351832510fba05d9a1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/6e0a776a396641a886869463d22b6a84.png
[8790fa4dcfe2436086f6d7d03c6b2fc1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f0f0affc17ba4906a133f07999509031.png
[9756839f8e7842ecb86e2e99d88e4b4b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d40bfb3498a542e0b3592885abf81ac3.png
[4fc61ff5c2f54775811b987830058f3f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0a2832792f0a4dbdadf26dfd655f0f86.png
[98ba74a44fd14086b871f19b149c177a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/4608a149c9b54f77bfa00d8a6ec5143f.png
[2edea6e222c14063bf97f5c8f650c2fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/a9de1898b487453182fdb4e61a369aa1.png
[01499921f26d4cfd8c440bcdbf3c213a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e4eaa245bce748aaa18613b64f33fb49.png
[fb943559b1f44d68876ec0293fa3fbeb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/98a1413b1c454bb0a1fb033f3f32c261.png
[1a0d20f695254d4a8c3edea65174bb5b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/68f183231c424e0c93ad481e27a32cfe.png
[37676c0eb31449a6a45afef5b714598b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f58cf004ab924c80a9594e7b875ff804.png
[13d03abaf4004ae5ac6051d52c5c1d7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/483f2d659f524791bd9aa065e3b78048.png
[0bb3f97ae7474f5ea7127448407951e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d75f96c22c8d4cf39a47af10d5526100.png