【I/O编程】UNIX文件基础

IO编程的本质是通过 API 操作 文件。

什么是 IO

• I - Input 输入
• O - Output 输出

这里的输入和输出都是站在应用（运行中的程序）的角度。外部特指文件。

这里的文件是泛指，并不是只表示存在存盘中的常规文件。还有设备、套接字、管道、链接等等。在 Linux 系统中 “一切皆文件”，目的是为了统一接口，简化编程。简单点说：

输入/输出编程 :让你将输入/输出功能 作用在 文件 上 ----文件(7种)
---------------------> 对文件进行 IO 操作 ---->将某些代码数据 保留在 文件 上
好处:
1> 将某些代码数据 保留在 文件 上 -----> 关于这一点请查阅文章《将数据保留（文件持久化）》
2> 丰富你访问底层的手段
3> 可以通过代码打开一些特殊文件 (管道/套接字/字符设备等等)

文件是什么

	文件：操作系统中一种二进制/相关数据有序的集合文件名：这个数据集合的名称Linux---有哪些文件类型? 共计为 7大类-	普通文件:C程序/可执行文件d   目录     ---> 文件夹c 	字符设备  ---> 驱动使用b   块设备    ---> 驱动使用s 	套接字    ---> 网络编程使用p   管道      ---> 多进程线程使用l   软链接    ---> 快捷方式

标准 IO 和系统 IO

这里展示了三种内核访问方式：Shell 命令访问内核、系统 API 访问内核 和 C 库函数访问内核。

1. Shell 命令访问内核

• Shell 是操作系统的命令行接口，用户通过输入命令（如 ls、cat、cp 等）间接与内核交互。
• Shell 命令通过调用操作系统提供的系统 API，与内核交互完成任务。例如，ls 命令通过调用系统 API 获取目录列表。

工作流程（结合图示）

1. 用户输入 Shell 命令（如 ls）。
2. Shell 将命令解释为系统调用，例如 open()、read() 等。
3. 系统调用接口（API）将请求传递给操作系统内核。
4. 内核通过驱动程序访问硬件设备（如磁盘），获取数据。
5. 内核将数据返回给 Shell，Shell 将结果显示给用户。

适合直接操作文件或目录；用户无需编程即可操作内核（高层次封装）；主要适合简单的文件管理操作，例如查看文件、复制文件等。

2. 系统 API 访问内核

• 系统 API（如 open()、read()、write()）是操作系统提供的接口，用于程序直接与内核交互。
• 程序员通过调用这些 API，可以访问文件系统、硬件设备等底层资源。

工作流程（结合图示）

1. 应用程序调用系统 API（例如 open() 打开文件、read() 读取文件内容、write() 写入文件）。
2. 系统 API 调用操作系统的内核功能，完成对设备或文件的操作。
3. 内核通过驱动程序与硬件设备交互（如读取磁盘数据）。
4. 操作系统将结果返回给应用程序。

优势尤其明显：直接访问内核，开发者通过系统 API 与内核交互；并且提供了高效的文件操作能力，适合对性能要求较高的场景；比 Shell 命令更加灵活，但需要更丰富编程知识。

3. C 库函数访问内核（标准 I/O）

• C 标准库（如 stdio.h 提供的函数 fopen()、fclose()、fwrite() 等）对系统 API 进行了封装，简化了文件操作。
• 应用程序通过调用 C 库函数间接访问内核。例如，fopen() 实际上会调用系统 API open()。

工作流程（结合图示）

1. 应用程序调用 C 标准库函数（如 fopen()）。
2. 标准库函数将调用转换为系统 API 调用（如从 fopen() 转换为 open()）。
3. 系统 API 通过内核与硬件设备交互（如文件读取、写入）。
4. 内核将结果返回给标准库函数，应用程序通过标准库函数获取结果。

C 库函数访问内核实现了更高层次的封装：C 库函数将系统调用封装为易用的接口，简化了开发；具备跨平台性：C 标准库屏蔽了操作系统差异，程序更容易移植；适合一般开发：更方便、易于维护，但性能可能略低于直接使用系统 API。

• Shell 命令层：
  • 用户通过命令（如 ls）访问内核。
  • 图中未直接显示 Shell 命令路径，但 Shell 命令最终通过系统 API 调用内核。
• 系统 API 层：
  • 图中展示了系统 API，如 open()、read()、close() 等。
  • 应用程序直接调用这些 API，与内核交互。
• C 库函数层：
  • 标准 C 库（如 fopen()）封装了底层 API 调用，提供了易用的接口。
  • 图中显示了 C 库函数调用系统 API 的过程（如 fopen() 调用 open()）。
• 内核和设备驱动层：
  • 如图所示，内核通过驱动程序与硬件设备交互的过程（如文件存储在磁盘上，通过驱动读取数据）。

不同访问方式在代码上的差异：

Shell 命令访问
通过 Shell 命令直接操作文件，无需编写程序。用户通过命令行与内核交互。

示例：任务是读取文件内容并将其打印到屏幕。

# 创建一个文件并写入内容
echo "Hello, this is a test file." > test.txt# 通过 Shell 命令读取文件内容并打印
cat test.txt

输出：

Hello, this is a test file.
# 优点：简单、直接，无需编程。
# 缺点：灵活性差，无法嵌入复杂的逻辑。

系统 API 访问
通过操作系统提供的系统调用（如 open()、read()）直接访问内核。

示例：使用 C 语言中的系统调用接口读取文件内容。

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>int main() {// 打开文件int fd = open("test.txt", O_RDONLY);if (fd < 0) {perror("Error opening file");return 1;}// 读取文件内容char buffer[1024];ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);if (bytes_read < 0) {perror("Error reading file");close(fd);return 1;}// 确保字符串以 '\0' 结尾buffer[bytes_read] = '\0';// 打印文件内容printf("File content:\n%s\n", buffer);// 关闭文件close(fd);return 0;
}

输出：

File content:
Hello, this is a test file.# 优点：
#   提供对文件操作的精细控制。
#   性能高，适合对系统资源的直接访问。
# 缺点：
#   开发复杂度较高，需要手动管理资源（如文件描述符的关闭等）。

C 库函数访问
通过 C 标准库函数（如 fopen()、fgets()）封装系统调用，简化文件操作。

示例：使用 C 标准库函数实现文件读取。

#include <stdio.h>int main() {// 打开文件FILE *file = fopen("test.txt", "r");if (file == NULL) {perror("Error opening file");return 1;}// 读取文件内容并打印char buffer[1024];while (fgets(buffer, sizeof(buffer), file) != NULL) {printf("%s", buffer);}// 关闭文件fclose(file);return 0;
}

输出：

Hello, this is a test file.# 优点：
#   使用方便，屏蔽了底层系统调用的细节。
#   提供了一些高级功能（如缓冲）。
# 缺点：
#   性能略低于直接调用系统 API。

访问方式	代码复杂度	性能	应用场景
Shell 命令访问	低	较低	简单的文件操作任务，如查看、编辑文件内容
系统 API 访问	高	高（直接访问内核）	性能要求高的场景，如大型文件读写或底层系统编程
C 库函数访问	中	中（有缓冲优化）	通用场景，如日志文件处理、常规文件读写

复杂场景三者的差别：
任务：将文件内容逐行读取，并将每行的长度打印出来。

1. Shell 命令实现：

while read line; doecho "Length: ${#line}"
done < test.txt

2. 系统 API 实现：

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>int main() {int fd = open("test.txt", O_RDONLY);if (fd < 0) {perror("Error opening file");return 1;}char buffer[1024];ssize_t bytes_read;while ((bytes_read = read(fd, buffer, sizeof(buffer) - 1)) > 0) {buffer[bytes_read] = '\0';char *line = strtok(buffer, "\n");while (line != NULL) {printf("Length: %ld\n", strlen(line));line = strtok(NULL, "\n");}}close(fd);return 0;
}

3. C 库函数实现：

#include <stdio.h>
#include <string.h>int main() {FILE *file = fopen("test.txt", "r");if (file == NULL) {perror("Error opening file");return 1;}char buffer[1024];while (fgets(buffer, sizeof(buffer), file) != NULL) {buffer[strcspn(buffer, "\n")] = '\0';  // 去掉换行符printf("Length: %ld\n", strlen(buffer));}fclose(file);return 0;
}

在实际开发中，根据任务复杂度和性能需求选择合适的访问方式即可。例如：

• 简单任务：用 Shell 命令。
• 高性能需求：用系统 API。
• 通用场景：用 C 标准库函数。

系统调用(文件IO)

省流版（简单理解）：文件IO更贴切底层，有系统地方就有文件IO

	用户空间进程访问内核的接口 把用户从底层的硬件编程中解放出来 极大的提高了系统的安全性 使用户程序具有可移植性 是操作系统的一部分 

系统调用接口是内核的组成部分，不管你是否调用这些接口，它都存在于内核中。调用它时不需要加载，直接跳转执行。

库函数(标准IO)

省流版（简单理解）：标准IO更依赖封装的C库函数库，应用面相对没有文件IO

	库函数为了实现某个功能而封装起来的API集合提供统一的编程接口，更加便于应用程序的移植是语言或者应用程序的一部

库函数是应用的一部分，调用它时需要加载到进行中，然后才跳转执行，程序结束时会卸载。

访问区别：

1> 文件指针 ---> FILE *  --->文件流/流指针FILE ---> 是一个结构体别名FILE：利用拥有的成员都属于系统底层成员//stdio.htypedef struct _iobuf{char*  _ptr;        //文件输入的下一个位置int    _cnt;        //当前缓冲区的相对位置char*  _base;       //文件初始位置int    _flag;       //文件标志 int    _file;       //文件有效性    ------**** 文件管理块 FCBint    _charbuf;    //缓冲区是否可读取int    _bufsiz;     //缓冲区字节数char*  _tmpfname;   //临时文件名} FILE;2> 文件描述符 ----- *:贯穿了整个应用层顺序分配的非负整数内核用以标识一个特定进程正在访问的文件其他资源(socket、pipe等)的访问标识系统调用（系统IO）使用 "文件描述符" 来唯一标识进程所打开的文件（包含常规文件、目录、块设备文件、字符设备文件、管道、符号链接、套接字等）。

FILE 流

使用非负整数表示（0，1，2，…），类型为 int。
每个 shell（进程）默认会打开三个文件描述符：标准输入/标准输出/标准错误输出

1. STDIN_FILENO - 0 - 标准输入
2. STDOUT_FILENO - 1- 标准输出
3. STDERR_FILENO - 2 - 标准出错

以上三个文件描述符在进程中可以直接使用，无须额外打开。另外，这三个标准文件很特殊 —> 既是已存在的文件，也是文件指针同时还是文件描述符。

每个 shell（进程）默认打开的三个文件描述符所对应的 FILE 流：文件指针		文件描述符标准输入      	stdin 			0标准输出      	stdout			1 标准错误输出   	stderr          2在 /usr/include/stdio.h 头文件中声明了以下全局流：/* Standard streams.  */extern struct _IO_FILE *stdin;          /* Standard input stream.  */extern struct _IO_FILE *stdout;         /* Standard output stream.  */extern struct _IO_FILE *stderr;         /* Standard error output stream.  *//* C89/C99 say they're macros.  Make them happy.  */#define stdin stdin#define stdout stdout#define stderr stderr

其他情况下：文件指针 和 文件描述符 操作 则是完全独立的。

• 文件指针：标准IO
• 文件描述符：文件IO
• 文件I/O —> 不用缓存的I/O
  • 通过文件描述符进行访问：open()/read()/write()/lseek()/close()…
• 标准I/O
  • 通过 FILE* 进行访问：printf()/fprintf()/fopen()/fread()/fwrite()/fseek()/fclose()…

出错处理

/usr/include/errno.h 中定义了错误代码。

#include <errno.h>

真正定义这些错误代码的文件是：/usr/include/asm-generic/errno-base.h

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _ASM_GENERIC_ERRNO_BASE_H
#define _ASM_GENERIC_ERRNO_BASE_H#define EPERM            1      /* Operation not permitted */
#define ENOENT           2      /* No such file or directory */
#define ESRCH            3      /* No such process */
#define EINTR            4      /* Interrupted system call */
#define EIO              5      /* I/O error */
#define ENXIO            6      /* No such device or address */
#define E2BIG            7      /* Argument list too long */
#define ENOEXEC          8      /* Exec format error */
#define EBADF            9      /* Bad file number */
#define ECHILD          10      /* No child processes */
#define EAGAIN          11      /* Try again */
#define ENOMEM          12      /* Out of memory */
#define EACCES          13      /* Permission denied */
#define EFAULT          14      /* Bad address */
#define ENOTBLK         15      /* Block device required */
#define EBUSY           16      /* Device or resource busy */
#define EEXIST          17      /* File exists */
#define EXDEV           18      /* Cross-device link */
#define ENODEV          19      /* No such device */
#define ENOTDIR         20      /* Not a directory */
#define EISDIR          21      /* Is a directory */
#define EINVAL          22      /* Invalid argument */
#define ENFILE          23      /* File table overflow */
#define EMFILE          24      /* Too many open files */
#define ENOTTY          25      /* Not a typewriter */
#define ETXTBSY         26      /* Text file busy */
#define EFBIG           27      /* File too large */
#define ENOSPC          28      /* No space left on device */
#define ESPIPE          29      /* Illegal seek */
#define EROFS           30      /* Read-only file system */
#define EMLINK          31      /* Too many links */
#define EPIPE           32      /* Broken pipe */
#define EDOM            33      /* Math argument out of domain of func */
#define ERANGE          34      /* Math result not representable */#endif

另外还有一个文件：/usr/include/asm-generic/errno.h

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _ASM_GENERIC_ERRNO_H
#define _ASM_GENERIC_ERRNO_H#include <asm-generic/errno-base.h>#define EDEADLK         35      /* Resource deadlock would occur */
#define ENAMETOOLONG    36      /* File name too long */
#define ENOLCK          37      /* No record locks available *//** This error code is special: arch syscall entry code will return* -ENOSYS if users try to call a syscall that doesn't exist.  To keep* failures of syscalls that really do exist distinguishable from* failures due to attempts to use a nonexistent syscall, syscall* implementations should refrain from returning -ENOSYS.*/
#define ENOSYS          38      /* Invalid system call number */#define ENOTEMPTY       39      /* Directory not empty */
#define ELOOP           40      /* Too many symbolic links encountered */
#define EWOULDBLOCK     EAGAIN  /* Operation would block */
#define ENOMSG          42      /* No message of desired type */
#define EIDRM           43      /* Identifier removed */
#define ECHRNG          44      /* Channel number out of range */
#define EL2NSYNC        45      /* Level 2 not synchronized */
#define EL3HLT          46      /* Level 3 halted */
#define EL3RST          47      /* Level 3 reset */
#define ELNRNG          48      /* Link number out of range */
#define EUNATCH         49      /* Protocol driver not attached */
#define ENOCSI          50      /* No CSI structure available */
#define EL2HLT          51      /* Level 2 halted */
#define EBADE           52      /* Invalid exchange */
#define EBADR           53      /* Invalid request descriptor */
#define EXFULL          54      /* Exchange full */
#define ENOANO          55      /* No anode */
#define EBADRQC         56      /* Invalid request code */
#define EBADSLT         57      /* Invalid slot */#define EDEADLOCK       EDEADLK#define EBFONT          59      /* Bad font file format */
#define ENOSTR          60      /* Device not a stream */
#define ENODATA         61      /* No data available */
#define ETIME           62      /* Timer expired */
#define ENOSR           63      /* Out of streams resources */
#define ENONET          64      /* Machine is not on the network */
#define ENOPKG          65      /* Package not installed */
#define EREMOTE         66      /* Object is remote */
#define ENOLINK         67      /* Link has been severed */
#define EADV            68      /* Advertise error */
#define ESRMNT          69      /* Srmount error */
#define ECOMM           70      /* Communication error on send */
#define EPROTO          71      /* Protocol error */
#define EMULTIHOP       72      /* Multihop attempted */
#define EDOTDOT         73      /* RFS specific error */
#define EBADMSG         74      /* Not a data message */
#define EOVERFLOW       75      /* Value too large for defined data type */
#define ENOTUNIQ        76      /* Name not unique on network */
#define EBADFD          77      /* File descriptor in bad state */
#define EREMCHG         78      /* Remote address changed */
#define ELIBACC         79      /* Can not access a needed shared library */
#define ELIBBAD         80      /* Accessing a corrupted shared library */
#define ELIBSCN         81      /* .lib section in a.out corrupted */
#define ELIBMAX         82      /* Attempting to link in too many shared libraries */
#define ELIBEXEC        83      /* Cannot exec a shared library directly */
#define EILSEQ          84      /* Illegal byte sequence */
#define ERESTART        85      /* Interrupted system call should be restarted */
#define ESTRPIPE        86      /* Streams pipe error */
#define EUSERS          87      /* Too many users */
#define ENOTSOCK        88      /* Socket operation on non-socket */
#define EDESTADDRREQ    89      /* Destination address required */
#define EMSGSIZE        90      /* Message too long */
#define EPROTOTYPE      91      /* Protocol wrong type for socket */
#define ENOPROTOOPT     92      /* Protocol not available */
#define EPROTONOSUPPORT 93      /* Protocol not supported */
#define ESOCKTNOSUPPORT 94      /* Socket type not supported */
#define EOPNOTSUPP      95      /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT    96      /* Protocol family not supported */
#define EAFNOSUPPORT    97      /* Address family not supported by protocol */
#define EADDRINUSE      98      /* Address already in use */
#define EADDRNOTAVAIL   99      /* Cannot assign requested address */
#define ENETDOWN        100     /* Network is down */
#define ENETUNREACH     101     /* Network is unreachable */
#define ENETRESET       102     /* Network dropped connection because of reset */
#define ECONNABORTED    103     /* Software caused connection abort */
#define ECONNRESET      104     /* Connection reset by peer */
#define ENOBUFS         105     /* No buffer space available */
#define EISCONN         106     /* Transport endpoint is already connected */
#define ENOTCONN        107     /* Transport endpoint is not connected */
#define ESHUTDOWN       108     /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS    109     /* Too many references: cannot splice */
#define ETIMEDOUT       110     /* Connection timed out */
#define ECONNREFUSED    111     /* Connection refused */
#define EHOSTDOWN       112     /* Host is down */
#define EHOSTUNREACH    113     /* No route to host */
#define EALREADY        114     /* Operation already in progress */
#define EINPROGRESS     115     /* Operation now in progress */
#define ESTALE          116     /* Stale file handle */
#define EUCLEAN         117     /* Structure needs cleaning */
#define ENOTNAM         118     /* Not a XENIX named type file */
#define ENAVAIL         119     /* No XENIX semaphores available */
#define EISNAM          120     /* Is a named type file */
#define EREMOTEIO       121     /* Remote I/O error */
#define EDQUOT          122     /* Quota exceeded */#define ENOMEDIUM       123     /* No medium found */
#define EMEDIUMTYPE     124     /* Wrong medium type */
#define ECANCELED       125     /* Operation Canceled */
#define ENOKEY          126     /* Required key not available */
#define EKEYEXPIRED     127     /* Key has expired */
#define EKEYREVOKED     128     /* Key has been revoked */
#define EKEYREJECTED    129     /* Key was rejected by service *//* for robust mutexes */
#define EOWNERDEAD      130     /* Owner died */
#define ENOTRECOVERABLE 131     /* State not recoverable */#define ERFKILL         132     /* Operation not possible due to RF-kill */#define EHWPOISON       133     /* Memory page has hardware error */#endif

全局错误码errno

      在errno.h中定义，全局可见错误值定义为“EXXX”形式，如EACCESS想阅读全局错误码: 1> /usr/include/asm-generic/errno-base.h 2> /usr/include/asm-generic/errno.h 处理规则如果没有出错，则 errno 值不会被一个例程清除，即只有出错时，才需要检查 errno 值任何函数都不会将 errno 值设置为 0，errno.h 中定义了所有常数都不为 0错误信息输出strerror() - 映射errno对应的错误信息  ---> 有：BUG：有的人Linux能用，有的人不能用；而且只会告诉你错了什么，但不会告诉你具体哪里错了。perror() – 输出用户信息及errno对应的错误信息		      		

if(？？==错误返回){perror("自定义错误标志");return;
}
例如: 
int temp=scanf("%d",&a); //一定要注意:scanf的错误返回，你一定要知道
if(temp==0){perror("嘿嘿，此处报错咯~");
}

strerror 函数

#include <string.h>
char *strerror(int errnum);// 将 errnum 翻译为对应错误的解释字符串，并返回字符串指针
// 当传递无效错误号 nnn 时返回 Unknown error nnn

perror 函数

#include <stdio.h>
void perror(const char *s);// 将 s 后加一个 : 号加空格（即 ": "），并且将 errno 对应的描述字符串连接在后面，打印输出

示例代码：

#include <errno.h>
#include <string.h>
#include <stdio.h>int main(void)
{FILE *fp;// 打印 EINVAL 错误号对应的错误描述printf("EINVAL - %s\n", strerror(EINVAL));// 打印无效的错误号 150 对应的描述printf("150 - %s\n", strerror(150));// 以只读的方式打开 ./abc.txt，如果文件不存在则会打开失败fp = fopen("./abc.txt", "r");// 直接打印当前 errno 的值所对应的描述printf("errno = %d, %s\n", errno, strerror(errno));if (!fp) {// 打印错误描述（常用）perror("打开文件 ./abc.txt 失败");return -1;}// 关闭文件流fclose(fp);return 0;
}

以上。仅供学习与分享交流，请勿用于商业用途！转载需提前说明。

我是一个十分热爱技术的程序员，希望这篇文章能够对您有帮助，也希望认识更多热爱程序开发的小伙伴。
感谢！