C语言 I/O

July 30, 2023

C 标准库文件操作

这里只写一下窄字符文件读写，其余参见：https://zh.cppreference.com/w/c/io

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

void my_print_ftell(FILE *stream);

int main()
{
    FILE *fp;
    // "r"：只读，文件必须已存在
    // "w"：只写，如果文件不存在则创建，如果文件已存在则把文件长度截断（Truncate）为 0 字节再重新写，也就是替换掉原来的文件内容
    // "a"：只能在文件末尾追加数据，如果文件不存在则创建
    // "r+"：允许读和写，文件必须已存在
    // "w+"：允许读和写，如果文件不存在则创建，如果文件已存在则把文件长度截断为 0 字节再重新写
    // "a+"：允许读和追加数据，如果文件不存在则创建
    if ((fp = fopen("./not_exist.txt", "r")) == NULL)
    {
        perror("Open './not_exist.txt'");
        fprintf(stderr, "%s\n", strerror(errno)); // No such file or directory
    }

    fp = fopen("./todo.txt", "w+");
    fputs("this is line one\n", fp);

    // SEEK_SET：从文件开头移动 offset 个字节
    // SEEK_CUR：从当前位置移动 offset 个字节
    // SEEK_END：从文件末尾移动 offset 个字节
    if (fseek(fp, 2, SEEK_SET) != 0)
        perror("fseek()");

    fputc('a', fp); // 2
    fputc('t', fp); // 3

    my_print_ftell(fp);
    rewind(fp);

    int size = 100;
    char *str = malloc(100 * sizeof(char));
    fgets(str, size, fp); // 扫描直至首个 '\n' 字符，str 会包含换行符
    fprintf(stdout, "%s", str);

    my_print_ftell(fp);
    rewind(fp);

    char *buf = malloc(100 * sizeof(char));
    fread(buf, sizeof(char), size, fp); // fread/fwrite 读写字符串应当是跨平台的，但读写其它二进制结构时则需要考虑是否跨平台了
    fprintf(stdout, "%s", buf);

    my_print_ftell(fp);
    fclose(fp);
}

void my_print_ftell(FILE *stream)
{
    long ftold;
    if ((ftold = ftell(stream)) == -1)
    {
        perror("ftell()");
    }
    else
    {
        printf("ftold=%ld\n", ftold); // 4
    }
}

C 标准库的 I/O 缓冲区有三种类型：全缓冲、行缓冲和无缓冲。当用户程序调用库函数做写操作时，不同类型的缓冲区具有不同的特性。

全缓冲：如果缓冲区写满了就写回内核。常规文件通常是全缓冲的。
行缓冲：如果用户程序写的数据中有换行符就把这一行写回内核，或者如果缓冲区写满了就写回内核。标准输入和标准输出对应终端设备时通常是行缓冲的。
无缓冲：用户程序每次调库函数做写操作都要通过系统调用写回内核。标准错误输出通常是无缓冲的，这样用户程序产生的错误信息可以尽快输出到设备。

调用 int fflush(FILE *stream); 可强制刷新 flush 缓冲，确保数据写回内核
成功返回 0，失败返回 EOF。传入空指针 fflush(NULL) 可对所有打开文件的 I/O 缓冲区做 Flush 操作

系统调用，Unbuffered I/O

系统调用是无（用户态）缓冲 I/O （C 标准库在用户态自动维护缓冲区，系统调用时内核可自己维护缓冲）
标准库 I/O 操作的对象是 FILE* 结构体指针，而 linux 系统调用则使用文件描述符（int）

stdin stdout stderr 的文件描述符分别为：

#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2

参考：open(2)

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

int make_fd_readonly(int fd);

int main()
{
    // O_RDONLY 只读打开
    // O_WRONLY 只写打开
    // O_RDWR 可读可写打开
    int fd = open("./todo.txt", O_RDWR | O_CREAT | O_TRUNC, S_IRWXU);

    ssize_t write_count = write(fd, "hello", sizeof("hello") - 1); // 减一防止写入 '\0'

    off_t currpos = lseek(fd, 1 - (long)(sizeof("hello")), SEEK_CUR); // 负数，向前移动 5 字节

    int len = 100;
    size_t size = sizeof(char) * len;
    char *buf = malloc(size);
    ssize_t ssize = read(fd, buf, size);

    if (ssize == -1)
    {
        perror("open()");
        exit(EXIT_FAILURE);
    }

    printf("read %ld bytes = %s\n", ssize, buf);

    int flags = fcntl(STDIN_FILENO, F_GETFL);
    printf("stdin's flags = %d mode=%d\n", flags, flags & O_ACCMODE);

    if (make_fd_readonly(fd) == -1)
        exit(1);
    write(fd, "x", 1);
    perror("O_RDONLY"); // Success, 还是可写，不影响实际的文件权限
}

int make_fd_readonly(int fd)
{
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1)
    {
        // 处理错误
        return -1;
    }

    flags |= O_RDONLY; // 设置只读标志

    if (fcntl(fd, F_SETFL, flags) == -1)
    {
        // 处理错误
        return -1;
    }

    return 0;
}

ioctl() 向设备发控制和配置命令
mmap() 将文件映射到内存

文件系统

以下摘录自 LinuxC 一站式编程

stat(2) 函数读取文件的 inode，然后把 inode 中的各种文件属性填入一个 struct stat 结构体传出给调用者（跟随符号链接）。

lstat(2) 同 stat(2)，但对于符号链接，返回其本身的 inode。

fstat(2) 函数传入一个已打开的文件描述符，传出 inode 信息。

access(2) 函数检查执行当前进程的用户是否有权限访问某个文件，传入文件路径和要执行的访问操作（读/写/执行），
access 函数取出文件 inode 中的 st_mode 字段，比较一下访问权限，然后返回 0 表示允许访问，返回 -1 表示错误或不允许访问。

chmod(2) 和 fchmod(2) 函数改变文件的访问权限，也就是修改 inode 中的 st_mode 字段。
这两个函数的区别类似于 stat/fstat。

chown(2)/fchown(2)/lchown(2) 改变文件的所有者和组，也就是修改 inode 中的 User 和 Group 字段，
只有 root 用户才能正确调用这几个函数，这几个函数之间的区别类似于 stat/fstat/lstat。

utime(2) 函数改变文件的访问时间和修改时间，也就是修改 inode 中的 atime 和 mtime 字段。

truncate(2) 和 ftruncate(2) 函数把文件截断到某个长度，如果新的长度比原来的长度短，则后面的数据被截掉了，
如果新的长度比原来的长度长，则后面多出来的部分用 0 填充，这需要修改 inode 中的 Blocks 索引项以及块位图中相应的 bit。
这两个函数的区别类似于 stat/fstat。

link(2) 函数创建硬链接，其原理是在目录的数据块中添加一条新记录，其中的 inode 号字段和原文件相同。
symlink(2) 函数创建一个符号链接，这需要创建一个新的 inode，其中 st_mode 字段的文件类型是符号链接，
原文件的路径保存在 inode 中或者分配一个数据块来保存。

unlink(2) 函数删除一个链接。如果是符号链接则释放这个符号链接的 inode 和数据块，清除 inode 位图和块位图中相应的位。
如果是硬链接则从目录的数据块中清除一条文件名记录，如果当前文件的硬链接数已经是 1 了还要删除它，
就同时释放它的 inode 和数据块，清除 inode 位图和块位图中相应的位，这样就真的删除文件了。

rename(2) 函数改变文件名，需要修改目录数据块中的文件名记录，如果原文件名和新文件名不在一个目录下，
则需要从原目录数据块中清除一条记录然后添加到新目录的数据块中。
注：在不同的分区之间移动文件就必须复制和删除 inode 和数据块

readlink(2) 函数读取一个符号链接所指向的目标路径，其原理是从符号链接的 inode 或数据块中读出保存的数据，这就是目标路径。

mkdir(2) 函数创建新的目录，要做的操作是在它的父目录数据块中添加一条记录，然后分配新的 inode 和数据块，
新 inode 的 st_mode 字段的文件类型是目录，在新数据块中填两个记录，分别是 . 和 ..，
由于 .. 表示父目录，因此父目录的硬链接数要加 1。

rmdir(2) 函数删除一个目录，这个目录必须是空的（只包含 . 和 ..）才能删除，要做的操作是
释放它的 inode 和数据块，清除 inode 位图和块位图中相应的位，清除父目录数据块中的记录，父目录的硬链接数要减 1。

// 遍历目录演示
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <dirent.h>
#include <stdio.h>
#include <errno.h>

#define MAX_PATH 1024

int main()
{
    if (mkdir("./todo", 0777) == 0)
    {
        printf("成功创建目录：./todo\n");
    }
    else
    {
        const char *dirPath = "./todo";
        switch (errno)
        {
        case EACCES:
            printf("权限不足，无法创建目录：%s\n", dirPath);
            break;
        case EEXIST:
            printf("目录已存在：%s\n", dirPath);
            break;
        case ENAMETOOLONG:
            printf("路径名太长：%s\n", dirPath);
            break;
        case ENOENT:
            printf("路径中的一个目录不存在：%s\n", dirPath);
            break;
        case ENOTDIR:
            printf("路径中的一个组件不是目录：%s\n", dirPath);
            break;
        default:
            printf("无法创建目录：%s，错误码：%d\n", dirPath, errno);
            break;
        }
    }

    // 创建一个文件，仅供测试
    fputs("hello, world!", fopen("./todo/test.txt", "w+"));

    // 打开目录
    DIR *dir = opendir("./todo");
    // 遍历目录
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL)
    {
        // 获取文件路径
        char file_path[MAX_PATH];
        snprintf(file_path, MAX_PATH, "./todo/%s", entry->d_name);
        // 获取文件/目录信息
        struct stat file_info;
        stat(file_path, &file_info);
        // 打印
        printf("%-10ld ", file_info.st_size);
        printf((S_ISDIR(file_info.st_mode)) ? "d" : "-");
        printf((file_info.st_mode & S_IRUSR) ? "r" : "-");
        printf((file_info.st_mode & S_IWUSR) ? "w" : "-");
        printf((file_info.st_mode & S_IXUSR) ? "x" : "-");
        printf((file_info.st_mode & S_IRGRP) ? "r" : "-");
        printf((file_info.st_mode & S_IWGRP) ? "w" : "-");
        printf((file_info.st_mode & S_IXGRP) ? "x" : "-");
        printf((file_info.st_mode & S_IROTH) ? "r" : "-");
        printf((file_info.st_mode & S_IWOTH) ? "w" : "-");
        printf((file_info.st_mode & S_IXOTH) ? "x" : "-");
        printf("  %-25s\n", entry->d_name);
        fflush(stdout);
    }
    closedir(dir);
}

复制文件描述符 dup() dup2()

复制文件描述符：不新建 file 结构体，而是其引用计数增加
显然，close() 系统调用使引用计数减一，并当计数归零时真正关闭文件

https://dashdash.io/2/dup

/**
 * 创建文件描述符 oldfd 的副本，返回值是该进程未使用的最小文件描述符
 */
int dup(int oldfd);

/**
 * 与 dup 相同，但返回的是 newfd 指定的文件描述符，若该文件描述符已打开，则在重用之前静默关闭
 */
int dup2(int oldfd, int newfd);

/**
 * 与 dup2 相同，但可使用标志位指定 O_CLOEXEC 来强制为新文件描述符设置关闭执行标志
 */
int dup3(int oldfd, int newfd, int flags);

←Back to home

This work is licensed under CC BY-NC-SA 4.0