第44讲：标准IO编程

用户程序调用 write(fd, buf, 2)   ← 只写2个字节
    ↓
用户态 → 内核态切换               ← 每次切换开销很大
    ↓
内核执行系统调用
    ↓
内核态 → 用户态切换
    ↓
返回用户程序

用户程序
    ↓  fwrite()/fread()
┌─────────────────────┐
│     IO缓冲区          │  ← 用户空间（stdio库）
│  (攒够数据才一次提交)  │
└─────────┬───────────┘
          ↓  一次批量系统调用
┌─────────────────────┐
│   Page Cache（页缓存） │  ← 内核空间
└─────────┬───────────┘
          ↓
┌─────────────────────┐
│       磁盘           │
└─────────────────────┘

#include <stdio.h>

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

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

/* 模式 "r" -- 只读，文件必须存在 */
FILE *fp_r = fopen("existing.txt", "r");
if (fp_r == NULL) {
    fprintf(stderr, "fopen r failed: %s\n", strerror(errno));
    return -1;
}
/* ... 读取操作 ... */
fclose(fp_r);

/* 模式 "w" -- 只写，创建或清空 */
FILE *fp_w = fopen("output.txt", "w");
if (fp_w == NULL) {
    fprintf(stderr, "fopen w failed: %s\n", strerror(errno));
    return -1;
}
fprintf(fp_w, "Hello World\n");
fclose(fp_w);

/* 模式 "a" -- 追加写 */
FILE *fp_a = fopen("log.txt", "a");
if (fp_a == NULL) {
    perror("fopen a");
    return -1;
}
fprintf(fp_a, "[%s] Log entry\n", __TIME__);
fclose(fp_a);

/* 模式 "r+" -- 读写，文件必须存在 */
FILE *fp_rp = fopen("data.bin", "r+");
if (fp_rp) {
    /* 可读写已有文件 */
    fclose(fp_rp);
}

/* 模式 "w+" -- 读写，创建或清空 */
FILE *fp_wp = fopen("temp.txt", "w+");
if (fp_wp) {
    fprintf(fp_wp, "Write first\n");
    rewind(fp_wp);              /* 回到开头才能读 */
    char buf[128];
    fgets(buf, sizeof(buf), fp_wp);
    printf("Read back: %s", buf);
    fclose(fp_wp);
}

/* 模式 "a+" -- 追加读写 */
FILE *fp_ap = fopen("journal.log", "a+");
if (fp_ap) {
    /* 可以读取已有内容（从开头） */
    char line[256];
    while (fgets(line, sizeof(line), fp_ap))
        printf("Existing: %s", line);
    /* 写入总是追加到末尾 */
    fprintf(fp_ap, "Appended line\n");
    fclose(fp_ap);
}

#include <stdio.h>

int fclose(FILE *stream);

FILE *fp = fopen("data.txt", "w");
if (fp == NULL) {
    perror("fopen");
    return 1;
}
/* ... 读写操作 ... */
if (fclose(fp) == EOF) {
    perror("fclose");
    return 1;
}

#include <stdio.h>

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

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

/* 读取结构体数组 */
typedef struct {
    int id;
    char name[32];
    double score;
} Student;

int read_students(const char *filename) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("fopen");
        return -1;
    }

    Student students[100];
    size_t items_read;
    size_t total = 0;

    /* 循环读取，每次读一个结构体 */
    while ((items_read = fread(&students[total],
                                sizeof(Student), 1, fp)) == 1) {
        printf("Student %d: %s, score=%.1f\n",
               students[total].id,
               students[total].name,
               students[total].score);
        total++;
        if (total >= 100) break;
    }

    /* 区分是到达文件末尾还是发生错误 */
    if (feof(fp)) {
        printf("Reached end of file, total=%zu records\n", total);
    } else if (ferror(fp)) {
        fprintf(stderr, "Read error: %s\n", strerror(errno));
        fclose(fp);
        return -1;
    }

    fclose(fp);
    return 0;
}

/* 读取整个文件到内存 */
char *read_entire_file(const char *filename, size_t *out_size) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) return NULL;

    /* 获取文件大小 */
    fseek(fp, 0, SEEK_END);
    long fsize = ftell(fp);
    rewind(fp);

    char *buf = malloc(fsize + 1);
    if (buf == NULL) {
        fclose(fp);
        return NULL;
    }

    size_t bytes_read = fread(buf, 1, fsize, fp);
    buf[bytes_read] = '\0';
    *out_size = bytes_read;

    fclose(fp);
    return buf;
}

#include <stdio.h>

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

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

typedef struct {
    int id;
    char name[32];
    double score;
} Student;

int save_students(const char *filename, Student *arr, size_t count) {
    FILE *fp = fopen(filename, "w");
    if (fp == NULL) {
        perror("fopen");
        return -1;
    }

    /* 一次写入整个数组 */
    size_t written = fwrite(arr, sizeof(Student), count, fp);
    if (written != count) {
        fprintf(stderr, "fwrite: only wrote %zu/%zu items\n",
                written, count);
        fclose(fp);
        return -1;
    }

    printf("Successfully wrote %zu records\n", written);
    fclose(fp);
    return 0;
}

/* 使用示例 */
int main(void) {
    Student class[] = {
        {1, "Alice",  92.5},
        {2, "Bob",    85.0},
        {3, "Charlie", 78.3},
    };
    size_t n = sizeof(class) / sizeof(class[0]);
    save_students("students.bin", class, n);
    return 0;
}

#include <stdio.h>

int fseek(FILE *stream, long offset, int whence);

long ftell(FILE *stream);

void rewind(FILE *stream);

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("test.txt", "w+");
    if (fp == NULL) return 1;

    /* 写入数据 */
    fprintf(fp, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

    /* fseek 移动到第5个字节 */
    fseek(fp, 5, SEEK_SET);
    long pos = ftell(fp);
    printf("Position after fseek(5, SEEK_SET): %ld\n", pos);  /* 5 */

    /* 从当前位置跳过3个字节 */
    fseek(fp, 3, SEEK_CUR);
    pos = ftell(fp);
    printf("Position after fseek(3, SEEK_CUR): %ld\n", pos);  /* 8 */

    /* 从末尾往前10个字节 */
    fseek(fp, -10, SEEK_END);
    pos = ftell(fp);
    printf("Position after fseek(-10, SEEK_END): %ld\n", pos); /* 16 */

    /* rewind 回到开头 */
    rewind(fp);
    pos = ftell(fp);
    printf("Position after rewind(): %ld\n", pos);            /* 0 */

    fclose(fp);
    return 0;
}

long get_file_size(const char *filename) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) return -1;
    fseek(fp, 0, SEEK_END);   /* 移到文件末尾 */
    long size = ftell(fp);    /* 获取偏移量 = 文件大小 */
    fclose(fp);
    return size;
}

用户程序 → fwrite() → IO缓冲区 → fflush() → Page Cache → sync() → 磁盘
                                     ↑                    ↑
                              强制刷新IO缓冲区       强制刷新页缓存
                              到 Page Cache           到磁盘

#include <stdio.h>

int fflush(FILE *stream);

#include <stdio.h>
#include <unistd.h>

int main(void) {
    /* 示例1：进度条需要立即刷新 */
    printf("Processing");
    for (int i = 0; i < 5; i++) {
        printf(".");
        fflush(stdout);          /* 不加这行，5个点会一起出现 */
        sleep(1);
    }
    printf(" Done!\n");

    /* 示例2：日志文件写入后立即刷新 */
    FILE *log = fopen("app.log", "a");
    if (log) {
        fprintf(log, "[INFO] Application started\n");
        fflush(log);             /* 确保日志立即落盘（到Page Cache） */
        /* ... 其他操作 ... */
        fclose(log);             /* fclose 也会自动 fflush */
    }

    /* 示例3：刷新所有输出流 */
    fflush(NULL);

    return 0;
}

#include <stdio.h>

int setvbuf(FILE *stream, char *buf, int mode, size_t size);

void setbuf(FILE *stream, char *buf);

#include <stdio.h>
#include <unistd.h>

int main(void) {
    FILE *fp;
    char mybuf[1024];

    /* 示例1：设置全缓冲，缓冲区大小8192字节 */
    fp = fopen("fullbuf.txt", "w");
    setvbuf(fp, NULL, _IOFBF, 8192);
    for (int i = 0; i < 10000; i++) {
        fprintf(fp, "Line %d\n", i);
        /* 数据先进入缓冲区，满了才 write() */
    }
    fclose(fp);

    /* 示例2：设置行缓冲（即使是普通文件也按行刷新） */
    fp = fopen("linebuf.txt", "w");
    setvbuf(fp, NULL, _IOLBF, 1024);
    fprintf(fp, "This will be written immediately\n");  /* 换行触发刷新 */
    sleep(1);
    fprintf(fp, "This is still in buffer");             /* 没换行，暂不刷新 */
    sleep(1);
    fprintf(fp, "...now flushed\n");                    /* 换行触发刷新 */
    fclose(fp);

    /* 示例3：无缓冲模式（每字节立即写入） */
    fp = fopen("nobuf.txt", "w");
    setvbuf(fp, NULL, _IONBF, 0);
    fputc('A', fp);  /* 立即系统调用 */
    fputc('B', fp);  /* 立即系统调用 */
    fclose(fp);

    /* 示例4：使用自定义缓冲区 */
    fp = fopen("custombuf.txt", "w");
    setvbuf(fp, mybuf, _IOFBF, sizeof(mybuf));
    fprintf(fp, "Using custom buffer of 1024 bytes\n");
    fclose(fp);  /* mybuf 的生命周期必须覆盖整个文件操作期！ */

    return 0;
}

fd = open("file.txt", O_WRONLY | O_APPEND);

fd = open("file.txt", O_RDWR | O_DIRECT);

fd = open("file.txt", O_WRONLY | O_SYNC);

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

#define BUF_SIZE 4096

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <src> <dst>\n", argv[0]);
        return 1;
    }

    int src_fd = open(argv[1], O_RDONLY);
    if (src_fd < 0) {
        perror("open src");
        return 1;
    }

    int dst_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (dst_fd < 0) {
        perror("open dst");
        close(src_fd);
        return 1;
    }

    char buf[BUF_SIZE];
    ssize_t nread, nwrite;
    while ((nread = read(src_fd, buf, BUF_SIZE)) > 0) {
        nwrite = write(dst_fd, buf, nread);
        if (nwrite != nread) {
            perror("write");
            close(src_fd);
            close(dst_fd);
            return 1;
        }
    }

    if (nread < 0) {
        perror("read");
    }

    close(src_fd);
    close(dst_fd);
    return (nread < 0) ? 1 : 0;
}

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

#define BUF_SIZE 4096

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <src> <dst>\n", argv[0]);
        return 1;
    }

    FILE *src = fopen(argv[1], "r");
    if (src == NULL) {
        perror("fopen src");
        return 1;
    }

    FILE *dst = fopen(argv[2], "w");
    if (dst == NULL) {
        perror("fopen dst");
        fclose(src);
        return 1;
    }

    char buf[BUF_SIZE];
    size_t nread;
    while ((nread = fread(buf, 1, BUF_SIZE, src)) > 0) {
        size_t nwrite = fwrite(buf, 1, nread, dst);
        if (nwrite != nread) {
            perror("fwrite");
            fclose(src);
            fclose(dst);
            return 1;
        }
    }

    if (ferror(src)) {
        perror("fread");
    }

    fclose(src);
    fclose(dst);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

#define FILE_SIZE (100 * 1024 * 1024)  /* 100MB */
#define DATA_CHUNK 1024                 /* 每次写 1KB */

void test_write(const char *filename, size_t buf_size, int use_stdio) {
    char data[DATA_CHUNK];
    memset(data, 'X', DATA_CHUNK);

    clock_t start = clock();

    if (use_stdio) {
        FILE *fp = fopen(filename, "w");
        if (fp == NULL) { perror("fopen"); return; }

        /* 设置自定义缓冲区大小 */
        char *iobuf = malloc(buf_size);
        setvbuf(fp, iobuf, _IOFBF, buf_size);

        size_t total = 0;
        while (total < FILE_SIZE) {
            fwrite(data, 1, DATA_CHUNK, fp);
            total += DATA_CHUNK;
        }
        fclose(fp);
        free(iobuf);  /* 注意：必须先 fclose 再 free */
    } else {
        int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
        if (fd < 0) { perror("open"); return; }

        size_t total = 0;
        while (total < FILE_SIZE) {
            write(fd, data, DATA_CHUNK);
            total += DATA_CHUNK;
        }
        close(fd);
    }

    clock_t end = clock();
    double elapsed = (double)(end - start) / CLOCKS_PER_SEC;
    printf("  Buffer=%5zu bytes, %s, Time=%.3f sec\n",
           buf_size, use_stdio ? "stdio" : "sys_io", elapsed);
}

int main(void) {
    printf("=== Write 100MB Performance Test ===\n\n");

    /* 系统IO：无用户空间缓冲，每次1KB都要系统调用 */
    test_write("sys_test.bin", 0, 0);

    /* 标准IO：不同缓冲区大小 */
    size_t buf_sizes[] = {512, 1024, 4096, 8192, 16384, 65536};
    for (int i = 0; i < 6; i++) {
        test_write("stdio_test.bin", buf_sizes[i], 1);
    }

    printf("\nConclusion: Larger stdio buffer = fewer syscalls = better performance.\n");
    return 0;
}

gcc -o perf_test perf_test.c
./perf_test

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

/* 这个程序演示：逐字节写入时，标准IO和系统IO的系统调用次数差异 */
int main(void) {
    /* 方式1：系统IO逐字节写入 -- 1024次系统调用 */
    {
        int fd = open("sys_byte.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
        for (int i = 0; i < 1024; i++) {
            write(fd, "X", 1);  /* 每次1次系统调用 */
        }
        close(fd);
    }

    /* 方式2：标准IO逐字节写入 -- 可能只有1次系统调用 */
    {
        FILE *fp = fopen("stdio_byte.txt", "w");
        for (int i = 0; i < 1024; i++) {
            fputc('X', fp);  /* 先进入缓冲区 */
        }
        fclose(fp);  /* 关闭时一次性 write() */
    }

    printf("Compare: sys_byte.txt vs stdio_byte.txt\n");
    printf("sys_byte: ~1024 syscalls\n");
    printf("stdio_byte: 1 syscall (buffered)\n");
    return 0;
}

#include <stdio.h>

int feof(FILE *stream);     /* 是否到达文件末尾 */
int ferror(FILE *stream);   /* 是否发生读写错误 */
void clearerr(FILE *stream); /* 清除错误标志和EOF标志 */

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

int read_all_lines(const char *filename) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        fprintf(stderr, "fopen '%s': %s\n", filename, strerror(errno));
        return -1;
    }

    char line[256];
    int line_num = 0;

    while (1) {
        if (fgets(line, sizeof(line), fp) == NULL) {
            /* fgets 返回 NULL 有两种可能 */
            if (feof(fp)) {
                /* 正常到达文件末尾 */
                printf("End of file reached after %d lines.\n", line_num);
                break;
            } else if (ferror(fp)) {
                /* 发生了错误 */
                fprintf(stderr, "Read error on line %d: %s\n",
                        line_num, strerror(errno));
                fclose(fp);
                return -1;
            }
            /* 理论上不会到这里 */
            break;
        }
        line_num++;
        printf("Line %d: %s", line_num, line);
    }

    fclose(fp);
    return 0;
}

/* clearerr 使用场景：从错误中恢复 */
int recoverable_read(FILE *fp, char *buf, size_t size) {
    size_t n = fread(buf, 1, size, fp);
    if (n < size && ferror(fp)) {
        fprintf(stderr, "Read error, attempting recovery...\n");
        clearerr(fp);  /* 清除错误标志 */
        /* 可以尝试继续读取 */
        return 0;
    }
    return (int)n;
}

#include <stdio.h>

FILE *tmpfile(void);

#include <stdio.h>

int main(void) {
    FILE *tmp = tmpfile();
    if (tmp == NULL) {
        perror("tmpfile");
        return 1;
    }

    fprintf(tmp, "Temporary data here\n");
    rewind(tmp);

    char buf[128];
    fgets(buf, sizeof(buf), tmp);
    printf("Read from tmp: %s", buf);

    /* 无需手动删除，fclose 或程序退出时自动清理 */
    fclose(tmp);
    return 0;
}

FILE *freopen(const char *pathname, const char *mode, FILE *stream);

#include <stdio.h>

int main(void) {
    /* 将 stdout 重定向到文件 */
    if (freopen("output.txt", "w", stdout) == NULL) {
        perror("freopen");
        return 1;
    }

    /* 之后的 printf 都会写入 output.txt */
    printf("This goes to the file, not the terminal.\n");
    printf("So does this line.\n");

    fclose(stdout);
    return 0;
}

#include <stdio.h>

int fgetpos(FILE *stream, fpos_t *pos);
int fsetpos(FILE *stream, const fpos_t *pos);

#include <stdio.h>

int fileno(FILE *stream);

FILE *fp = fopen("data.txt", "w");
int fd = fileno(fp);
/* 使用 fd 调用 fstat、fcntl、fsync 等系统调用 */
fsync(fd);
fclose(fp);

#include <stdio.h>
#include <pthread.h>

/* 线程不安全：两个线程写同一个文件（输可能交错） */
void *write_thread(void *arg) {
    FILE *fp = (FILE *)arg;
    /* 锁保护单次调用，但不保护多次调用的原子性 */
    fprintf(fp, "Thread %ld: Line 1\n", (long)pthread_self());
    fprintf(fp, "Thread %ld: Line 2\n", (long)pthread_self());
    /* 两行之间可能被另一个线程插入 */
    return NULL;
}

/* 解决方案1：使用 flockfile/ftrylockfile/funlockfile */
void *write_thread_safe(void *arg) {
    FILE *fp = (FILE *)arg;
    flockfile(fp);  /* 手动加锁 */
    fprintf(fp, "Thread %ld: Line 1\n", (long)pthread_self());
    fprintf(fp, "Thread %ld: Line 2\n", (long)pthread_self());
    funlockfile(fp); /* 手动解锁 */
    return NULL;
}

/* 解决方案2：每个线程打开独立的 FILE *（推荐） */

#include <stdio.h>

void flockfile(FILE *stream);     /* 加锁 */
int  ftrylockfile(FILE *stream);  /* 尝试加锁，不阻塞 */
void funlockfile(FILE *stream);   /* 解锁 */

fwrite() → IO缓冲区 → fflush() → Page Cache → sync() → 磁盘

全缓冲（_IOFBF）：缓冲区满才刷新 → 普通文件默认
行缓冲（_IOLBF）：遇到 \n 或缓冲区满 → 终端默认
无缓冲（_IONBF）：立即刷新 → stderr 默认