Linux 系统编程：封装基础文件操作库与理解标准错误流 stderr

1.3 刷新缓冲区

刷新就是将缓冲区的数据真正写入到文件中。对于行缓冲模式，遇到换行符或调用 fflush 时会触发。

void my_fflush(myFILE* fp) {
    write(fp->fileno, fp->cache, fp->pos);
    fp->pos = 0;
}

1.4 写文件

写入不是直接写磁盘，而是拷贝到内存缓冲区。只有当缓冲区满或满足刷新条件时才调用底层 write。

ssize_t my_fwrite(myFILE* fp, const char* data, int len) {
    memcpy(fp->cache + fp->pos, data, len);
    fp->pos += len;

    // 刷新方式为行刷新且缓冲区遇到\n就刷新缓冲区
    if ((fp->flags & FLUSH_LINE) && fp->cache[fp->pos - 1] == '\n') {
        my_fflush(fp);
    }
    return len;
}

注：实际工程中需要考虑扩容与越界问题，此处为演示原理从简处理。

1.5 关闭文件

关闭前必须确保数据已落盘，即先刷新缓冲区，再关闭文件描述符并释放内存。

void my_fclose(myFILE* fp) {
    my_fflush(fp);      // 刷新缓冲区
    close(fp->fileno);  // 关闭文件
    free(fp);           // 释放空间
}

1.6 完整代码示例

为了方便阅读，我们将头文件和实现分开存放。

mystdio.h

#pragma once
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define LINE_SIZE 1024
#define FLUSH_NOW 1
#define FLUSH_LINE 2
#define FLUSH_FULL 4

typedef struct _myFILE {
    unsigned int flags;
    int fileno;
    char cache[LINE_SIZE];
    int cap;
    int pos;
} myFILE;

myFILE* my_fopen(const char* path, const char* flag);
void my_fflush(myFILE* fp);
ssize_t my_fwrite(myFILE* fp, const char* data, int len);
void my_fclose(myFILE* fp);

mystdio.c

#include "mystdio.h"

myFILE* my_fopen(const char* path, const char* flag) {
    int flag1 = 0;
    int iscreate = 0;
    mode_t mode = 0666;

    if (strcmp(flag, "r") == 0) {
        flag1 = O_RDONLY;
    } else if (strcmp(flag, "w") == 0) {
        flag1 = (O_WRONLY | O_CREAT | O_TRUNC);
        iscreate = 1;
    } else if (strcmp(flag, "a") == 0) {
        flag1 = (O_WRONLY | O_CREAT | O_APPEND);
        iscreate = 1;
    }

    int fd = 0;
    if (iscreate)
        fd = open(path, flag1, mode);
    else
        fd = open(path, flag1);

    if (fd < 0) return NULL;

    myFILE* fp = (myFILE*)malloc(sizeof(myFILE));
    if (fp == NULL) return NULL;

    fp->fileno = fd;
    fp->flags = FLUSH_LINE;
    fp->cap = LINE_SIZE;
    fp->pos = 0;
    return fp;
}

void my_fflush(myFILE* fp) {
    write(fp->fileno, fp->cache, fp->pos);
    fp->pos = 0;
}

ssize_t my_fwrite(myFILE* fp, const char* data, int len) {
    memcpy(fp->cache + fp->pos, data, len);
    fp->pos += len;
    if ((fp->flags & FLUSH_LINE) && fp->cache[fp->pos - 1] == '\n') {
        my_fflush(fp);
    }
    return len;
}

void my_fclose(myFILE* fp) {
    my_fflush(fp);
    close(fp->fileno);
    free(fp);
}

testfile.c (测试用例)

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

#define FILENAME "log.txt"

int main() {
    myFILE* fp = my_fopen(FILENAME, "w");
    if (fp == NULL) return 1;

    const char* str = "hello linux";
    int cnt = 10;
    char buff[128];

    while (cnt) {
        sprintf(buff, "%s - %d", str, cnt);
        my_fwrite(fp, buff, strlen(buff));
        cnt--;
        sleep(1);
        my_fflush(fp);
    }
    my_fclose(fp);
    return 0;
}

运行上述程序会生成 log.txt，内容如下：

2. 标准错误流 stderr

2.1 C 语言演示

在 C 中，printf 对应标准输出（stdout），perror 或 fprintf(stderr, ...) 对应标准错误流（stderr）。

#include <stdio.h>

int main() {
    perror("error:");
    fprintf(stdout, "hello fprintf stdout\n");
    fprintf(stderr, "hello fprintf stderr\n");
    return 0;
}

运行结果可以看到，部分数据可能未立即显示，这是因为标准输出通常是行缓冲或全缓冲的，而标准错误流通常是无缓冲的，会立即输出到终端。

为什么有了标准输出还要有标准错误？

因为程序运行时难免出错。标准输出用于正常信息，标准错误用于错误信息。这样我们可以将两者分离，方便监控程序状态而不干扰正常日志。

重定向演示

1. 将数据存入不同文件 将 1 号 fd（stdout）重定向到 ok.txt，2 号 fd（stderr）重定向到 err.txt。

   ./a.out 1>ok.txt 2>err.txt
   cat ok.txt  # 仅含正常输出
   cat err.txt # 仅含错误信息
   

   

2. 将数据存入同一个文件 将 2 号 fd 重定向到 1 号 fd 的目标。

   ./a.out 1>all.txt 2>&1
   cat all.txt
   

   

总结

• perror("open") 本质是向 2 号 fd（stderr）打印。
• printf("") 本质是向 1 号 fd（stdout）打印。

2.2 C++ 代码演示

C++ 中对应的是 std::cout 和 std::cerr。

#include <iostream>

int main() {
    std::cout << "hello cout" << std::endl;
    std::cerr << "hello cerr" << std::endl;
    return 0;
}

命令行重定向逻辑相同：

g++ test_stderr.cpp
./a.out > log.txt
# 此时只有 cout 的内容进入 log.txt，cerr 依然输出到屏幕