#include <iostream>
using namespace std;

int main()
{
	cout << "Hello";		// 存在缓冲区，暂时不会马上输出
	cout << " World\n";		// 遇到换行符，flush，全部一起输出
	return 0;
}

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

int main()
{
    printf("打印到屏幕（终端）前先睡5秒...\n");
    sleep(5);  // 打印了才 sleep，说明是“行缓冲”
    return 0;
}

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

int main()
{
    printf("准备输出...\n");
    sleep(5);
    printf("Hello, File!\n");
    // fflush(stdout);  // 去掉这行试试！
}

// 运行方式：./a.out > test.txt

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

int main()
{
    printf("日志输出：程序开始执行...\n");         // 重定向后不会立刻写入文件（全缓冲）
    sleep(10);                                   // 程序“暂停”10 秒，但日志还未写入
    printf("日志输出：程序即将退出。\n");
    return 0;
}
// 注意：查看重定向文件时：在程序运行期间它是空的，只有等程序结束后才出现内容。

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

int main()
{
    printf("日志输出：程序开始执行...\n");
    fflush(stdout);                        // 手动刷新，确保写入文件
    sleep(10);
    printf("日志输出：程序即将退出。\n");
    fflush(stdout);                        // 最好在关键日志后都刷新一次
    return 0;
}

#include <stdio.h>

int main()
{
    printf("准备执行崩溃逻辑...\n");
    int* p = NULL;
    *p = 42;              // 故意造成段错误，程序崩溃
    return 0;
}

#include <stdio.h>

int main()
{
    printf("准备执行崩溃逻辑...\n");
    fflush(stdout);       // 手动刷新，日志及时写入
    int* p = NULL;
    *p = 42;
    return 0;
}

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

int main()
{
    setvbuf(stdout, NULL, _IONBF, 0);   // 设置 stdout 为无缓冲模式
    printf("程序正在执行...\n");          // 会立刻写入
    sleep(10);
    printf("程序执行结束。\n");
    return 0;
}

// 头文件
//#pragma once                              // 可选，防止头文件重复包含
#ifndef __MYSTDIO_H__                       // 防止头文件重复包含（include guard）
#define __MYSTDIO_H__

#include <string.h>                         // 用于处理字符串函数，strcmp(), memcpy()

#define SIZE 1024                           // 缓冲区大小：1KB

// 缓冲刷新策略（flush strategy）标志
#define FLUSH_NOW 1                         // 每次写入立即刷新（立即写入文件）
#define FLUSH_LINE 2                        // 按行刷新（检测到换行符时刷新）
#define FLUSH_ALL 4                         // 缓冲区满了才刷新（默认）

// 自定义文件结构体，模拟 FILE 类型
typedef struct IO_FILE
{
    int fileno;                             // 文件描述符
    int flag;                               // 刷新策略
    //char inbuffer[SIZE];                  // 输入缓冲区（未实现）
    //int in_pos;                           // 输入缓冲位置指针
    char outbuffer[SIZE];                   // 输出缓冲区（output buffer）
    int out_pos;                            // 当前写入缓冲区的位置
}_FILE;

// 函数声明部分
_FILE* _fopen(const char* filename, const char* flag);          // 打开文件（模拟 fopen）
int _fwrite(_FILE* fp, const char* s, int len);                 // 写入字符串到缓冲区（模拟 fwrite）
void _fclose(_FILE* fp);                                        // 关闭文件（模拟 fclose）

#endif

// 函数文件
#include "mystdio.h"
#include <sys/types.h>                                  // 基本系统数据类型定义 size_t
#include <sys/stat.h>                                   // 文件权限模式常量 S_IRWXU、S_IRWXG、S_IRWXO
#include <fcntl.h>                                      // 文件控制选项 O_CREAT、O_WRONLY、O_APPEND、O_RDONLY
#include <stdlib.h>                                     // malloc()、free()
#include <unistd.h>                                     // read()、write()、close()
#include <assert.h>                                     // assert() 断言检查

#define FILE_MODE 0666                                  // 默认文件权限 rw-rw-rw-

// 打开文件：支持 "w"（写入）、"a"（追加）、"r"（只读）
_FILE* _fopen(const char* filename, const char* flag)
{
    assert(filename);                                   // 确保文件名不为空
    assert(flag);                                       // 确保模式不为空

    int f = 0;                                          // 打开文件使用的标志位（flags）
    int fd = -1;                                        // 文件描述符初始化为非法值

    if (strcmp(flag, "w") == 0)
    {
        f = (O_CREAT | O_WRONLY | O_TRUNC);             // 创建+只写+截断旧内容
        fd = open(filename, f, FILE_MODE);
    }
    else if (strcmp(flag, "a") == 0)
    {
        f = (O_CREAT | O_WRONLY | O_APPEND);            // 创建+只写+追加写入
        fd = open(filename, f, FILE_MODE);
    }
    else if (strcmp(flag, "r") == 0)
    {
        f = O_RDONLY;                                   // 只读模式
        fd = open(filename, f);
    }
    else
    {
        return NULL;                                    // 不支持的模式，返回空指针
    }

    if (fd == -1)
    {
        return NULL;                                    // 打开失败
    }

    _FILE* fp = (_FILE*)malloc(sizeof(_FILE));          // 为 _FILE 结构体分配内存
    if (fp == NULL)
    {
        return NULL;                                    // 内存分配失败
    }

    fp->fileno = fd;                                    // 设置文件描述符
    //fp->flag = FLUSH_LINE;                            // 可选行刷新模式
    fp->flag = FLUSH_ALL;                               // 默认采用缓存满再写入
    fp->out_pos = 0;                                    // 输出缓冲区指针置 0

    return fp;
}

int _fwrite(_FILE* fp, const char* s, int len)          // 写入函数：将字符串写入到自定义缓冲区中
{
    // 将数据从字符串拷贝到输出缓冲区（假设缓冲足够）
    memcpy(&fp->outbuffer[fp->out_pos], s, len);        // 无边界检测（简化实现）
    fp->out_pos += len;

    if (fp->flag & FLUSH_NOW)                           // 判断刷新策略
    {
        write(fp->fileno, fp->outbuffer, fp->out_pos);  // 立即写入所有缓冲数据到文件
        fp->out_pos = 0;
    }
    else if (fp->flag & FLUSH_LINE)                     // 按行刷新
    {
        if (fp->outbuffer[fp->out_pos - 1] == '\n')     // 如果最后一个字符是换行符，则刷新
        {
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;
        }
    }
    else if (fp->flag & FLUSH_ALL)                      // 按缓存满刷新
    {
        if (fp->out_pos == SIZE)                        // 缓冲区满时刷新（一次写入 SIZE 字节）
        {
            write(fp->fileno, fp->outbuffer, fp->out_pos);
            fp->out_pos = 0;
        }
    }

    return len;                                         // 返回写入的长度
}

// 手动刷新函数（模拟 fflush）
void _fflush(_FILE* fp)
{
    if (fp->out_pos > 0)
    {
        write(fp->fileno, fp->outbuffer, fp->out_pos);  // 写入缓冲数据
        fp->out_pos = 0;
    }
}

// 关闭文件（释放资源）
void _fclose(_FILE* fp)
{
    if (fp == NULL) return;
    _fflush(fp);                                        // 关闭前确保缓冲区已写入
    close(fp->fileno);                                  // 关闭文件描述符
    free(fp);                                           // 释放分配的内存
}

// 测试文件
#include "mystdio.h"
#include <unistd.h>                         // 用于 sleep() 函数

#define myfile "test.txt"                   // 要写入的测试文件名称

int main()
{
    // 打开文件，以追加模式 ("a") 打开
    _FILE* fp = _fopen(myfile, "a");
    if (fp == NULL)
    {
        return 1;                           // 打开失败则退出
    }

    const char* msg = "hello world\n";      // 写入的字符串内容
    int cnt = 10;                           // 循环次数

    while (cnt)
    {
        _fwrite(fp, msg, strlen(msg));      // 每次写入一行
        // _fflush(fp);                     // 如需每次立即写入可手动刷新
        sleep(1);                           // 每 1 秒写一次
        cnt--;
    }

    _fclose(fp);                            // 写入完毕后关闭文件，释放资源

    return 0;
}