文件 I/O 的深度解析与 A+B 问题的工程级实现

#include <fstream>
#include <iostream>
#include <stdexcept>
#include <system_error>

int main() {
    // 1. 构造流对象时启用手动异常掩码（将 failbit 和 badbit 转为异常）
    std::ifstream fin;
    fin.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    
    try {
        // 2. 打开输入文件（二进制模式，避免文本模式下的换行符过滤）
        fin.open("aplusb.in", std::ios::in | std::ios::binary);
        
        // 3. 验证打开状态（尽管 exceptions 会抛异常，显式检查增加可读性）
        if (!fin.is_open()) {
            throw std::system_error(errno, std::generic_category(), 
                                    "无法打开输入文件 aplusb.in");
        }
        
        // 4. 获取流关联的 streambuf 并查看其内部缓冲区大小（实现定义）
        std::streambuf* buf = fin.rdbuf();
        std::streamsize original_bufsize = buf->in_avail(); // 通常为 0 或实现值
        
        // 5. 手动为输入流分配自定义缓冲区（页面大小 4096 字节，减少系统调用）
        char input_buffer[4096];
        buf->pubsetbuf(input_buffer, sizeof(input_buffer));
        
        // 6. 读取两个整数：使用 std::num_get  facet 进行本地化解析（默认 C locale）
        long long a = 0, b = 0;
        fin >> a >> b;
        
        // 7. 检查是否因 EOF 导致读取不完整
        if (fin.eof() && (fin.fail() && !fin.bad())) {
            throw std::runtime_error("输入文件提前结束或格式错误");
        }
        
        // 8. 计算和并构造输出字符串（避免临时 std::string 多次分配）
        long long sum = a + b;
        std::string output = std::to_string(sum);
        
        // 9. 关闭输入流（显式调用 close 可以提前释放资源，析构时也会自动调用）
        fin.close();
        
        // ========== 输出阶段 ==========
        std::ofstream fout;
        fout.exceptions(std::ofstream::failbit | std::ofstream::badbit);
        fout.open("aplusb.out", std::ios::out | std::ios::binary | std::ios::trunc);
        
        // 10. 为输出流设置更大的缓冲区（8192 字节，匹配典型磁盘块大小）
        char output_buffer[8192];
        fout.rdbuf()->pubsetbuf(output_buffer, sizeof(output_buffer));
        
        // 11. 写入数据并强制刷新（确保数据落盘，避免丢失）
        fout.write(output.data(), output.size());
        fout << std::flush;  // 调用 sync() -> fsync() 系统调用
        
        // 12. 关闭前检查是否发生溢出错误
        if (fout.fail()) {
            throw std::system_error(errno, std::generic_category(), 
                                    "写入输出文件失败");
        }
        fout.close();
        
    } catch (const std::ios_base::failure& ex) {
        // 捕获来自异常掩码的错误
        std::cerr << "流 I/O 异常: " << ex.what() 
                  << " (错误码: " << ex.code() << ")\n";
        return EXIT_FAILURE;
    } catch (const std::exception& ex) {
        std::cerr << "通用异常: " << ex.what() << '\n';
        return EXIT_FAILURE;
    }
    
    return EXIT_SUCCESS;
}

import os
import sys
import errno

def robust_aplusb():
    input_path = "aplusb.in"
    output_path = "aplusb.out"
    
    # 1. 使用 os.open 获取原始文件描述符（O_RDONLY 只读，0o644 默认权限）
    try:
        fd_in = os.open(input_path, os.O_RDONLY | os.O_BINARY, 0o644)
    except OSError as e:
        sys.stderr.write(f"打开输入文件失败: {e.strerror} (errno={e.errno})\n")
        return 1
    
    # 2. 通过文件描述符创建缓冲对象（4096 字节缓冲区）
    #    os.read() 每次最多读取指定字节数，需循环读取直到遇到换行符
    buffer = bytearray()
    chunk_size = 4096
    while True:
        try:
            chunk = os.read(fd_in, chunk_size)
        except OSError as e:
            sys.stderr.write(f"读取错误: {e.strerror}\n")
            os.close(fd_in)
            return 1
        if not chunk:
            break
        buffer.extend(chunk)
        # 简易处理：如果缓冲区末尾是换行符（假设输入在一行内），可提前结束
        if buffer.endswith(b'\n'):
            break
    
    os.close(fd_in)
    
    # 3. 解析字节流为整数（假设空白字符分隔）
    try:
        data = buffer.decode('utf-8').strip().split()
        a = int(data[0])
        b = int(data[1])
    except (UnicodeDecodeError, IndexError, ValueError) as e:
        sys.stderr.write(f"解析输入失败: {e}\n")
        return 1
    
    total = a + b
    output_bytes = str(total).encode('utf-8')
    
    # 4. 写入输出文件（O_WRONLY | O_CREAT | O_TRUNC，权限 0o644）
    try:
        fd_out = os.open(output_path, 
                         os.O_WRONLY | os.O_CREAT | os.O_TRUNC | os.O_BINARY, 
                         0o644)
    except OSError as e:
        sys.stderr.write(f"创建输出文件失败: {e.strerror}\n")
        return 1
    
    # 5. 使用 os.write 确保全部写入（处理短写情况）
    written = 0
    while written < len(output_bytes):
        try:
            ret = os.write(fd_out, output_bytes[written:])
            if ret == 0:
                raise OSError("write returned 0, 可能磁盘已满")
            written += ret
        except OSError as e:
            sys.stderr.write(f"写入错误: {e.strerror}\n")
            os.close(fd_out)
            return 1
    
    # 6. 强制同步到磁盘（调用 fsync）
    try:
        os.fsync(fd_out)
    except OSError:
        pass  # 某些文件系统不支持 fsync，忽略
    
    os.close(fd_out)
    return 0

if __name__ == "__main__":
    sys.exit(robust_aplusb())