指令后面接上 ，然后我们再加上个%20-l 选项，就能把进程信息尽收眼底：

我们重点关注  和 ， 后面链接指向的是可执行程序%20mytest，即 路径%20+%20程序名。

而  (current%20working%20directory)，即%20当前工作目录，记录着当前进程所处的路径！

每个进程都有一个工作路径，所以我们上一节实现的简单 %20程序可以用%20chdir 更改路径。

创建文件时，如果文件在当前目录下不存在，fopen 会默认在当前路径下自动创建文件。

 默认创建在当前路径，和源代码、可执行程序在同一个路径下，因为这取决于 ：

cwd%20->%20/home/foxny/lesson18

 我们可以来验证一下，使用 chdir 接口更改一下：

#include <stdio.h>#include <unistd.h>int main(void){    /* 主动更改当前进程的 cwd */    chdir("home/foxny/code");    FILE* pf = fopen("log.txt", "w"); // 写入    if (pf == NULL) {        perror("fopen");        return 1;    }    /* 获取进程 pid */    printf("Mypid: %d/n", getpid());    /* 打开文件后，等一等，方便查询 */    while (1) {        sleep(1);    }    const char* msg = "牛魔酬宾!";    int count = 1;    while (count <= 10) {        fprintf(pf, "%s: %d/n", msg, count++);    }    fclose(pf);}

此时 log.txt 应该不在默认路径 /home/foxny/lesson18 下了，而是在 /home/foxny/code下。

我们再次通过 $ls proc 指令查看信息明细时，

 所以，当前路径更准确的说法应该是：在当前进程所处的工作路径。

" 当前路径指的是在当前进程所处的工作路径 "

只不过默认情况下 (默认路径) ，一个进程的工作路径在它当前所处的路径而已，这是可以改的。

所以我们在写文件操作代码时，不带路径默认是源代码所在的路径，注意是默认！而已！

0x02 文件操作模式（File Operation Mode）

 由文件操作符 (mode) 参数来指定，常用的模式包括：

r：只读模式，打开一个已存在的文本文件，允许读取文件。r+：读写模式，打开一个已存在的文本文件，允许读写文件。w：只写模式，打开一个文本文件并清除其内容，如果文件不存在，则创建一个新文件。w+：读写模式，打开一个文本文件并清除其内容，如果文件不存在，则创建一个新文件。a：追加模式，打开一个文本文件并将数据追加到文件末尾，如果文件不存在，则创建一个新文件。a+：读写模式，打开一个文本文件并将数据追加到文件末尾，如果文件不存在，则创建一个新文件。

* 有些我们已经在 C 语言专栏中详细介绍过了，如果对该知识点不熟可以复习一下。
🔗 复习链接：https://foxny.blog.csdn.net/article/details/119715195

 这里我们重点讲一下 a 和 a+

a 对应的是 appending 的首字母，意为 "追加" 。属于写入操作，不会覆盖源文件内容。

💬 代码演示：测试追加效果

#include <stdio.h>int main() {   FILE* pf = pf = fopen("test.txt", "a");   // 写入数据到文件   fprintf(pf, "Hello, World!/n");   fclose(pf);   return 0;}

🚩 运行结果如下：

每次运行都会在 test.txt 里追加，我们多试几次看看：

a(append) 追加写入，可以不断地将文件中新增内容。（这让我联想到了追加重定向）

不同于 w，当我们以 w 方式打开文件准备写入的时候，其实文件已经先被清空了。

0x03 文件的读取（File Read）

 文件的读取在 C 专栏中我们也详细讲过了，这里我们只做一个简单的回顾。

我们复习一下文本行输入函数 fgets，它可以从特定的文件流中，以行为单位读取特定的数据：

char* fgets(char* s, int size, FILE* stream);_

💬 代码演示：fgets()

#include <stdio.h>int main(void){    FILE* pf = fopen("log.txt", "r"); // 读    if (pf == NULL) {        perror("fopen");        return 1;    }    char buffer[64];  // 用来存储    while (fgets(buffer, sizeof(buffer), pf) != NULL) {        // 打印读取到的内容        printf("echo: %s", buffer);    }    fclose(pf);}

🚩 运行结果如下：

我们下面再来实现一个类似 $cat 的功能，输入文件名打印对应文件内容。

💬 代码演示：实现一个自己的 cat

#include <stdio.h>/* 读什么就打什么   mycat */int main(int argc, char* argv[]) {    if (argc != 2) {        printf("Usage: %s filename/n", argv[0]);        return 1;    }    FILE* pf = fopen(argv[1], "r");    // 读取    if (pf == NULL) {        perror("fopen");        return 1;    }    char buffer[64];    while (fgets(buffer, sizeof(buffer), pf) != NULL) {        printf("%s", buffer);    }    fclose(pf);}

如果再把可执行程序 mytest 改名成 cat，$mv mytest cat ，

 我们就实现了一个自己的 cat 代码。

Ⅱ. 文件系统接口（Basic File IO）

0x00 引入：系统调用与封装（Syscall and Wrapper）

当我们向文件写入时，最终是不是向磁盘写入？是！磁盘是硬件吗？就是硬件。

当我们像文件写入时，最后是向磁盘写入。磁盘是硬件，那么谁有资格向磁盘写入呢？

 只能是操作系统！

既然是操作系统在写入，那我们自然不能绕开操作系统对磁盘硬件进行访问。

因为操作系统是对软硬件资源进行管理的大手子，你的任何操作都不能越过操作系统！

" OS：给你随便访问，那岂不是显得我很随便？ "

 所有的上层访问文件的操作，都必须贯穿操作系统。

想要被上层使用，必须使用操作系统的相关的 系统调用 (syscall) ！

💭 思考：我们来回顾一下我们学习 C 语言的第一个函数接口：

printf("Hello, World!/n");

如何理解 printf？我们怎么从来没有见过这些系统调用接口呢？

显示器是硬件，我们 printf 的消息打印到了硬件上，是你自己调用的 printf 打印到硬件上的，

但并不是你的程序显示到了显示器上，因为显示器是硬件，它的管理者只能是操作系统，

你不能绕过操作系统，而必须使用对应的接口来访问显示器，我们看到的 printf 一打，

内容就出现在屏幕上，实际上在函数的内部，一定是 调用了系统调用接口 的。

🔺 结论：printf 函数内部一定封装了系统调用接口。

 任何语言都是这样的，用到的接口都是语言提供给你的！正所谓……

" 纵横不出方圆，万变不离其宗！"

所有的语言提供的接口，之所以你没有见到系统调用，因为所有的语言都被系统接口做了 封装。

所以你看不到对应的底层的系统接口的差别。为什么要封装？原生系统接口，使用成本比较高。

系统接口是 OS 提供的，就会带来一个问题：如果使用原生接口，你的代码只能在一个平台上跑。

 直接使用原生系统接口，必然导致语言不具备 跨平台性 (Cross-platform) ！

如果语言直接使用操作系统接口，那么它就不具备跨平台性，可是为什么采用封装就能解决？

封装是如何解决跨平台问题的呢？很简单：

" 穷举所有的底层接口 + 条件编译 "

🔺 结论：我们学习的接口，C 库提供的文件访问接口，系统调用。它们两具有上下层关系，C 底层一定会调用这些系统调用接口。

• 解释：不同的语言，有不同的文件访问接口。
• 系统调用：这就是我什么我们必须学习文件级别的系统接口！

 行文至此，我们已经正式引入了系统调用接口的概念！

0x01 文件打开：open()

打开文件，在 C 语言上是 fopen，在系统层面上是 open。

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);

 我们可以看到，相较于 C 的 fopen 来说，这个接口一上来就显得很不友好。

"这特喵的有三个头文件啊，用个 open 要引三个头文件！"

然而，更恐怖的还在后面，有一大坨繁冗而复杂的东西……

我们看到，这个 open 接口一个是两参数的，一个是三参数的，这个我们放到后面解释。

① open 接口的 pathname 参数表示要打开的文件名，和 C 语言的 fopen 一样，是要带路径的。

② flags 参数是打开文件要传递的选项，即 系统传递标记位，我们下面会重点讲解。

③ mode 参数，就是 "文件操作模式" 了。但在这里：

" 就变得又臭又长，不经让人感叹 fopen 居然是如此的人性化！"

#if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)    #define O_RDONLY     _O_RDONLY    #define O_WRONLY     _O_WRONLY    #define O_RDWR       _O_RDWR    #define O_APPEND     _O_APPEND    #define O_CREAT      _O_CREAT    #define O_TRUNC      _O_TRUNC    #define O_EXCL       _O_EXCL    #define O_TEXT       _O_TEXT    #define O_BINARY     _O_BINARY    #define O_RAW        _O_BINARY    #define O_TEMPORARY  _O_TEMPORARY    #define O_NOINHERIT  _O_NOINHERIT    #define O_SEQUENTIAL _O_SEQUENTIAL    #define O_RANDOM     _O_RANDOM#endif

 真是让人心脏骤停…… 我们慢慢来 ~

❓ 思考：在 Linux 下，C 语言中文件不存在，就直接创建它，创建是不是需要权限？

当然是需要的，我们需要给文件设置初始权限，这个 mode 参数就是干这个活的。

我们再来看看这个接口的返回值，居然是个 int，而不是我们 fopen 的 FILE* 

④ open 的返回值是个 int，返回 -1 表示 error，并设置 errno。

0x01 flags 系统传递标记位

open 接口中的 flags 参数在 OS 底层接口函数中还是很常见的，所以我们要重点讲解。

我们可以输入 man 2 open  看看如何设置 flags 参数，实际上就是设置文件操作模式的。

我们重点关注下面这几个文件操作模式，它们被定义在 <fcntl.h> 头文件中：

如果你是第一次见，可能会感到强烈的 "陌生感"，这个 O 是什么鬼，好像还都是宏！

 O 实际上就是 Open 的意思，它们的用途通过名字不难猜：

•  (open%20read%20only)%20：只读方式打开
•  (open%20write%20only)%20：只写方式打开
•  (open%20read%20write) ：读写方式打开
•  (open%20append)%20：追加方式打开
•  (open%20create)%20：创建%20(若文件不存在就创建)

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

我们称%20flags%20为%20标记位，并且它是个整数类型（C99%20标准之前没有%20bool%20类型) 

标记位实际上我们造就用过了，比如定义%20flag%20变量，设%20flag=0，设%20flag=1，传的都是单个的。

❓%20思考：但如果我想一次传递多个标志位呢？定义多个标记位？flag1,%20flag2,%20flag3...

那我要传%2020%20个呢，定义%2020%20个标记位不成？遇到不确定传几个标志位的情况下，该怎么办？

 我们看看写底层的大佬是如何解决的：

👑 方案：系统传递标记位是通过 位图 来进行传递的。

想必大家已经对位图不陌生了，在前几章我们讲解 waitpid 的 status 参数时就介绍过了：

status 参数也是整型，也是被当作一个 "位图结构" 看待的，这里的 flags 也是如此！

当成位图，就是一串整数 ，如此一来标记的可能性就直接超级加倍了。

0000%200000

我们可以让不同的位表示，是否只读，是否只写，是否读写……%20等等等等：

每个 宏标记一般只需要满足有一个比特位是 1，并且和其它宏对应的值不重叠 即可。

让每一个宏对应不同的比特位，在内部就可以做不同的事情，为了大家能够更好的理解，

下面我们自己设计一个接口，仿照系统传递标记位的做法，通过这种思路去实现一下标记位。

💬 代码演示：我们创建一个 test_flag.c

#include <stdio.h>#define PRINT_A   0x1     // 0000 0001#define PRINT_B   0x2     // 0000 0010#define PRINT_C   0x4     // 0000 0100#define PRINT_D   0x8     // 0000 1000#define PRINT_DFL 0x0// openvoid Show (    int flags  /* 传递标志位 */    ){    if (flags & PRINT_A)     printf("Hello A/n");    if (flags & PRINT_B)     printf("Hello B/n");    if (flags & PRINT_C)     printf("Hello C/n");    if (flags & PRINT_D)     printf("Hello D/n");    if (flags == PRINT_DFL)  printf("Hello Default/n");}int main(void){    /* 我想打谁，只需要传对应的标记位即可 */    printf("# PRINT_DFL: /n");    Show(PRINT_DFL);    printf("# PRINT_A: /n");    Show(PRINT_A);    printf("# PRINT_B: /n");    Show(PRINT_B);    printf("# PRINT_A AND PRINT_B: /n");    Show(PRINT_A | PRINT_B);    printf("# PRINT_C AND PRINT_D: /n");    Show(PRINT_C | PRINT_D);    printf("# PRINT_A AND PRINT_B AND PRINT_C AND PRINT_D: /n");    Show(PRINT_A | PRINT_B | PRINT_C | PRINT_D);    return 0;}

🚩 运行结果：

💡 说明：通过标记位，可以在内部做对应的事情。打印 A 就打印 hello A，打印 A 和 B 就打印 hello A 和 hello B，现在我们再理解别人给我们传递宏标志位的做法。我们每一个宏所对应的值，在二进制位上互相都是不重叠的，一人用一个比特位。我们调用时要同时打印多个就按位或，内部再做条件判断，检测条件是否成立，这即是系统传参的做法。一个系统调用接口可以穿十几乃至三十几个的标志位，基本是够用的。

0x02 open 接口用法演示 

讲完了 flags 标记位，现在我们可以演示 open 接口的用法了。

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

💬 代码演示：是用 open() 打开 log.txt 文件没有就创建。

#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>int main(void){    int fd = open("log.txt", O_WRONLY | O_CREAT);    if (fd < 0) {         // 打开失败        perror("open");         return 1;    }    printf("fd: %d/n", fd);   // 把 fd 打出来看看    return 0;}

💡 代码说明：

① 这里我们选择取名为 fd，而不是我们 fopen 习惯用的 pf/fp，因为 fd 描述文件描述符，这也是我们后面章节要重点讲解的，所以这里取 fd 来接收 open 接口的返回值，也算是预热一下

② 只写是 O_WRONLY，如果没有对应文件就创建，创建时 O_CREAT，这里我们用 | 把二者相关联可以了。

③ open 的返回值是 int，如果返回 -1 则表示 error，所以如果 fd < 0 就说明打开失败了，我们礼貌性的 perror 一下（保持我们 fopen 的习惯，这是好习惯）。

④ 最后，文件打开成功，我们把 fd 的值顺便打印出来看看。

🚩 运行结果如下：

 如果你要创建这个文件，该文件是要受到 %20权限的约束的！

创建一个文件，你需要告诉操作系统默认权限是什么。

当我们要打开一个曾经不存在的文件，不能使用两个参数的%20open，而要使用三个参数的%20open！

也就是带%20mode_t%20mode%20的%20open，这里的%20mode%20代表创建文件的权限：

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

 修改一下我们的代码，使用带 mode 参数的 open：

int main(){    int fd = open("log.txt", O_APPEND | O_CREAT, 0666);  // 八进制表示    if (fd < 0) {        perror("open");        return 1;    }    printf("fd: %d/n", fd);    return 0;}

🚩 运行结果如下：

 * 如果你对这里出现的 "权限八进制表示法" 感到疑惑，可以看权限章节，那一章有讲。
🔗 链接：【看表情包学Linux】权限 - Ⅲ 0x03

因为你要创建的文件，你再怎么🐂🍺，你也要听操作系统的！我们来看看 umask：

你要 666，操作系统不能给你，因为 umask 是 0002，所以最多只能给你 664。

 那好！我今天非要创建 666！神挡杀神，操作系统挡杀操作系统！

" 没关系，我会出手！umask 限制我？我特喵直接改 umask！ "

我们在权限章节介绍过 umask，实际上它也是一个系统级接口。

我们现在就是要 666，我们只需要调用 umask()，然后传 0：umask(0) 

就可以让权限掩码暂时不听按操作系统的默认权限掩码，而用你设置的！

int main(){    umask(0);   // umask现在就为0，听我的，别听操作系统的umask了        // 额... 好吧，okok    int fd = open("log.txt", O_APPEND | O_CREAT, 0666);    if (fd < 0) {        perror("open");        return 1;    }    printf("fd: %d/n", fd);    return 0;}

🚩 运行结果如下：

实际上，umask 命令就是调用这个接口的。

umask 设为 0，可以让我们以确定的权限打开文件，比如服务器要打开一个日志文件，权限就必须要按照它对应的权限设置好，不要采用系统的默认权限，可能会出问题。

0x03 文件关闭：close()

在 C 语言中，关闭文件可以调用 fclose，在系统接口中我们可以调用 close 来关闭：

#include <unistd.h>int close(int fd);

我们输入 man 2 close 查看一下手册：

该接口相对 open 相对来说比较简单，只有一个 fd 参数，我们直接看代码：

#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>  // 需引入头文件int main(void){    umask(0);    int fd = open("log.txt", O_WRONLY | O_CREAT, 0666);        perror("open");         return 1;    }    printf("fd: %d/n", fd);     close(fd);  // 关闭文件    return 0;}

🚩 运行结果如下：

0x04 文件写入：write()

文件打开和文件关闭都有了，我们总要干点事吧？现在我们来做文件写入！

在 C 语言中我们用的是 fprintf, fputs, fwrite 等接口，而在系统中，我们可以调用 write 接口：

#include <unistd.h>ssize_t write(int fd, const void* buf, size_t count);

📚 write 接口有三个参数：

• fd：文件描述符
• buf：要写入的缓冲区的起始地址（如果是字符串，那么就是字符串的起始地址）
• count：要写入的缓冲区的大小

💬 代码演示：向文件写入 5 行信息

#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>  // 需引入头文件int main(void){    umask(0);    int fd = open("log.txt", O_WRONLY | O_CREAT, 0666);    if (fd < 0) {        perror("open");         return 1;    }    printf("fd: %d/n", fd);         // 向文件写入 5 行信息    int cnt = 0;    const char* str = "牛魔酬宾!/n";    while (cnt < 5) {       write(fd, str, strlen(str));       cnt++;    }    close(fd);    return 0;}

🚩 运行结果如下：

⚡ 顺便教一个清空文件的小技巧： > 文件名 ，前面什么都不写，直接重定向 + 文件名：

$ > log.txt

📌 [ 笔者 ]   王亦优📃 [ 更新 ]   2023.3.17❌ [ 勘误 ]   /* 暂无 */📜 [ 声明 ]   由于作者水平有限，本文有错误和不准确之处在所难免，              本人也很想知道这些错误，恳望读者批评指正！