C++ 文件读写实战：ofstream 默认清空文件、getline 与 ＞＞ 混用的坑

文件 I/O 是那种「语法五分钟、踩坑三年」的东西。ofstream 的默认模式里藏着 trunc，第二次打开同一个路径就把上次的内容清空了；in >> id 之后接 std::getline 只会拿到一个空串，因为换行符还留在缓冲区里；而 std::ofstream 默认不抛异常，磁盘满、目录不存在、权限不够，它都只是默默把 failbit 置上，程序继续跑得欢。这篇把打开模式、状态位、RAII 和四类典型读取方式一次讲透，并且每个示例都用临时文件、跑完就删，保证可重复运行。

1. 引子：一个「写成功」但其实什么都没写的程序

先看这个很多人第一次写文件时都写过的版本：

// 反例，不要这么写：既不检查打开是否成功，也不检查写入是否成功
// std::ofstream out("/root/no_permission/app.log");
// out << "重要日志\\n";
// out.close(); // 没有任何返回值可查，失败了也不知道

这段代码的问题有三个，而且都在编译期完全看不出来：目录不存在时 open 失败，out 处于 fail 状态，后面每一句 << 都不起作用；close() 的失败也是静默的（它不抛异常）；至于手写 close()，其实大多数时候根本不需要：析构会帮你做。要弄清楚哪些事该交给人、哪些交给 RAII，先把三个流类和它们的打开模式摆平。

2. ifstream / ofstream / fstream 与打开模式

三个类都是 std::basic_ios 的孙子辈，区别只在于默认打开模式：

每个模式位的含义，以及常见组合：

常见的按位或组合速查：

官方文档：std::basic_ifstream、std::basic_filebuf::open 的模式表

3. 第一个坑：ofstream 的默认模式会清空文件

std::ofstream out(path); 这一句里的默认模式是 out | trunc，所以只要路径存在，内容立刻没了。改成追加必须显式写 app：

// file_trunc.cpp — 编译: g++ -std=c++17 -Wall -O2 file_trunc.cpp -o demo
#include <cstdio>
#include <fstream>
#include <iostream>
#include <string>

constexpr const char* kPath = "miao_tmp_trunc.txt";

std::string slurp(const char* p) {
std::ifstream in(p);
std::string all;
std::string line;
while (std::getline(in, line)) { all += line; all += '|'; }
return all;
}

int main() {
{
std::ofstream out(kPath); // 默认 out|trunc
out << "first\\n";
}
std::cout << "写入一次后: " << slurp(kPath) << '\\n';

{
std::ofstream out(kPath); // 又截断一次，旧内容没了
out << "second\\n";
}
std::cout << "再写一次后: " << slurp(kPath) << '\\n';

{
std::ofstream out(kPath, std::ios::out | std::ios::app); // 追加
out << "third\\n";
}
std::cout << "app 追加后: " << slurp(kPath) << '\\n';

std::remove(kPath);
}

写入一次后: first|
再写一次后: second|
app 追加后: second|third|

注意每段写文件都包在 {} 里。这不是为了好看：离开作用域时 ofstream 析构，缓冲区会被 flush 并关闭文件，所以下一段的 ifstream 一定能读到完整内容。这就是第 5 节要讲的 RAII。

4. 第二个坑：>> 和 getline 对「空白」的理解不同

operator>> 按空白字符（空格、制表、换行都算）切分并跳过前导空白；std::getline 读到换行符为止并吃掉那个换行。两者一起用就出问题：

// file_getline.cpp — 编译: g++ -std=c++17 -Wall -O2 file_getline.cpp -o demo
#include <cstdio>
#include <fstream>
#include <iostream>
#include <limits>
#include <string>

constexpr const char* kNumPath = "miao_tmp_num.txt";
constexpr const char* kWordPath = "miao_tmp_word.txt";

int main() {
{ std::ofstream f(kNumPath); f << "42\\nmiao\\n"; }
{ std::ofstream f(kWordPath); f << "hello world\\n"; }

{
std::ifstream in(kWordPath);
std::string a, b;
in >> a >> b; // 遇到空白就断
std::cout << ">> 分词 : " << a << " | " << b << '\\n';
}
{
std::ifstream in(kNumPath);
int id = 0;
in >> id; // 读走 42，停在该行的换行符前
std::string line;
std::getline(in, line); // 只拿到一个空串
std::cout << "踩坑 : id=" << id << " line=[" << line << "]\\n";
}
{
std::ifstream in(kNumPath);
int id = 0;
in >> id;
in.ignore(std::numeric_limits<std::streamsize>::max(), '\\n'); // 吃掉行尾
std::string line;
std::getline(in, line);
std::cout << "正确姿势 : id=" << id << " line=[" << line << "]\\n";
}
std::remove(kNumPath);
std::remove(kWordPath);
}

>> 分词 : hello | world
踩坑 : id=42 line=[]
正确姿势 : id=42 line=[miao]

修法就是在 >> 之后补一次 ignore：把当前行剩下的字符（直到换行符）全丢掉。另一种同样常见的写法是全程只用 getline，拿到整行之后再用 std::istringstream 去切分：这也是《C++ stringstream 实用指南：分词解析、类型互转与 clear/str 的区别》要展开的套路，好处是「行」和「字段」两个层级分得清清楚楚，不会再出现半个换行符卡在缓冲区里的情况。

5. RAII：析构自动 flush + close，但「写成功」要自己查

文件流是标准库里的 RAII 典范：std::basic_filebuf 的析构函数会关闭文件，而 std::ofstream 的析构会先 flush 输出缓冲区。所以不需要手写 close()，而且在异常路径上也安全：

ofstream 的生命周期（对象即资源）

std::ofstream out{path}; <- 构造：打开文件，失败则置 failbit（不抛）
|
| out << "…" << 42; <- 写入：先攒在内存缓冲区里
| out << "…" << 43;
|
+— 作用域结束 / 异常抛出 —+
|
v
析构：flush 缓冲区 -> 关闭文件描述符
顺序保证：栈展开时也会执行（这就是 RAII 的价值）

手写 close() 的唯一收益是「能提前知道关闭有没有失败」，
工程里更常见的做法是写完立刻检查流状态，而不是依赖 close()。

坑在于**「析构一定会执行」不等于「一定写成功」**。析构不做任何报错，磁盘满、管道关闭、配额超限都在这里被无声吞掉。所以正确姿势是「写完就查」：

// 片段：写完立刻查一次，把错误挡在还能处理的时刻
std::ofstream out(path, std::ios::out | std::ios::trunc);
if (!out) { throw std::runtime_error("打开文件失败"); }
out << "width=" << width << '\\n';
out.flush(); // 主动推进底层，让错误现在就暴露
if (!out) { throw std::runtime_error("写入文件失败"); }
// 之后交给析构关闭，不需要手动 close()

if (!out) 用的是 std::basic_ios::operator bool，等价于 !out.fail()。这一点在下一节会看到它的完整含义。

6. 状态位的语义：good / eof / fail / bad

四个状态位都在 std::ios_base 里，任何一个流对象都能查：

四个状态位（iostate）与它们的关系

一切正常 格式化操作失败
+———–+ 操作失败 +—————————+
| goodbit | ————–> | failbit |
| good()=T | <————– | fail()=true |
+———–+ clear() | (类型不匹配 / 打开失败) |
| +—————————+
| 读到文件末尾 ^
v | 底层设备出错
+———–+ clear() +—————————+
| eofbit | | badbit |
| eof()=T | | bad()=true |
+———–+ | (流已不可用，别再用它) |
+—————————+

三句判据：
good() <=> state == 0 最严格，一点问题都不能有
fail() <=> failbit | badbit 「这次操作没成功」，这才是主判据
!stream <=> fail() 所以 while (in >> x) 能同时挡住
文件读完（eofbit+failbit）和格式错误

有一个流传很广的错误写法是 while (!in.eof()) { getline(in, line); … }：它总会多处理一次最后一行，因为 eof() 只有在「已经尝试读过并撞上末尾」之后才为真。正确的循环条件是直接用 getline 的返回值（这篇所有示例都是这么写的）。下面这个程序把状态位的实际取值跑出来：

// file_state.cpp — 编译: g++ -std=c++17 -Wall -O2 file_state.cpp -o demo
#include <fstream>
#include <iostream>
#include <string>

constexpr const char* kMissing = "miao_tmp_no_such_file.txt";

int main() {
std::cout << std::boolalpha;

std::ifstream lenient(kMissing); // 文件不存在
std::cout << "默认: is_open=" << lenient.is_open() << " fail=" << lenient.fail()
<< " bad=" << lenient.bad() << " eof=" << lenient.eof()
<< " good=" << lenient.good() << '\\n';
std::string line;
const bool got = static_cast<bool>(std::getline(lenient, line));
std::cout << "getline 返回 " << got << "，line=[" << line << "]\\n";
std::cout << "之后再查: eof=" << lenient.eof() << " fail=" << lenient.fail() << '\\n';

try {
std::ifstream strict;
strict.exceptions(std::ios::failbit | std::ios::badbit); // 打开失败要抛
strict.open(kMissing);
} catch (const std::ios_base::failure& e) {
std::cout << "捕获异常: " << e.what() << '\\n';
}
std::remove(kMissing);
}

默认: is_open=false fail=true bad=false eof=false good=false
getline 返回 false，line=[]
之后再查: eof=false fail=true
捕获异常: basic_ios::clear: iostream error

输出把两件事钉死了：文件打不开时是 failbit 而不是 eofbit（eof=false），并且 getline 返回 false 时不会去动 line（保持空串）。所以「读失败但用了脏数据」这种 bug，只要检查返回值就能拦住。第二段演示 exceptions()：打开它会把这些状态位变成异常，失败当场抛，不用等到下一次检查。

那到底该用哪种？看场景：

官方文档：std::basic_ios::rdstate 与状态位、std::basic_ios::exceptions

7. 二进制读写：write / read 与 reinterpret_cast

文本模式适合人看，二进制模式适合把内存里的数据整块搬走。write / read 的签名都只认 char 指针，所以必须换一次「视角」：

std::vector<int> data{1, 2, 3, 2147483647} 的 16 个字节（小端机）

01 00 00 00 | 02 00 00 00 | 03 00 00 00 | FF FF FF 7F
|– int 1 –|– int 2 –|– int 3 –|– int 2147483647 -|
^
data.data() 就是这段连续内存的首字节地址

为什么要 reinterpret_cast<const char*>：
write() 的形参类型是 const char*，而你手上是 int*
标准规定 char / unsigned char / std::byte 可以「别名」任何对象，
所以用 char* 去读这段字节是合法的；reinterpret_cast 表达的正是
「不改变位模式，只换个类型去看它」—— 它不做任何数值转换
这是 reinterpret_cast 少有的正当场景之一（不是类型转换，是重新解释）

// file_binary.cpp — 编译: g++ -std=c++17 -Wall -O2 file_binary.cpp -o demo
#include <cstdio>
#include <fstream>
#include <iostream>
#include <vector>

constexpr const char* kBinPath = "miao_tmp_bin.dat";

int main() {
const std::vector<int> data{1, 2, 3, 2147483647};
{
std::ofstream out(kBinPath, std::ios::out | std::ios::binary | std::ios::trunc);
out.write(reinterpret_cast<const char*>(data.data()),
static_cast<std::streamsize>(data.size() * sizeof(int)));
}
std::ifstream probe(kBinPath, std::ios::in | std::ios::binary | std::ios::ate);
std::cout << "文件字节数: " << probe.tellg() << '\\n';

std::ifstream in(kBinPath, std::ios::in | std::ios::binary);
std::vector<int> back(data.size(), 0);
in.read(reinterpret_cast<char*>(back.data()),
static_cast<std::streamsize>(back.size() * sizeof(int)));
std::cout << "读入字节数: " << in.gcount() << '\\n';
std::cout << "读到内容 : ";
for (const int v : back) { std::cout << v << ' '; }
std::cout << '\\n';
std::remove(kBinPath);
}

文件字节数: 16
读入字节数: 16
读到内容 : 1 2 3 2147483647

三个细节：std::ios::ate 让文件一打开就定位到末尾，所以 tellg() 直接就是文件大小，不用 seek 两次；read 之后用 gcount() 看实际读到了多少字节，短读（文件被截断）时它小于请求值，这是判断「读全了没」的标准手段；最后，二进制跨平台只保证同一平台同一次编译之间可读，字节序和 sizeof(int) 一变就废，真要长期存储得用固定宽度类型（std::int32_t）并约定字节序。

官方文档：std::basic_ostream::write、std::basic_istream::read

8. 用 <filesystem> 做路径与文件判断（C++17）

在打开文件之前先问一句「它在不在、是不是普通文件」，比打开失败再猜要直白得多。<filesystem> 从 C++17 起进标准库，gcc 9 之后不需要额外链接 -lstdc++fs：

// file_fs.cpp — 编译: g++ -std=c++17 -Wall -O2 file_fs.cpp -o demo
#include <filesystem>
#include <fstream>
#include <iostream>

namespace fs = std::filesystem;

int main() {
const fs::path p = "miao_tmp_fs_probe.txt";
{
std::ofstream f(p);
f << "xy\\n";
}
std::cout << std::boolalpha;
std::cout << "exists : " << fs::exists(p) << '\\n';
std::cout << "regular : " << fs::is_regular_file(p) << '\\n';
std::cout << "extension : " << p.extension().string() << '\\n';
std::cout << "stem : " << p.stem().string() << '\\n';
std::cout << "file_size : " << fs::file_size(p) << '\\n';
std::cout << "remove 返回 : " << fs::remove(p) << '\\n';
std::cout << "删后 exists : " << fs::exists(p) << '\\n';
}

exists : true
regular : true
extension : .txt
stem : miao_tmp_fs_probe
file_size : 3
remove 返回 : true
删后 exists : false

要注意 fs::exists(p) 这类查询默认不抛异常，返回 false 就代表「不存在或者查不了」；想让它抛，得传 std::error_code 的重载或者用 fs::directory_entry。另外 fs::remove 返回 bool（是否真的删掉了），删不存在的文件是 false 而不是错误。

官方文档：std::filesystem

9. 完整示例：写配置 → 读回来 → 校验

把这篇所有要点串成一个能整体跑的程序：ofstream 覆盖写、写完检查状态、ifstream 逐行 getline、键值对解析、失败时用 std::optional 表达「没有值」而不是靠哨兵值。

// file_config.cpp — 编译: g++ -std=c++17 -Wall -O2 file_config.cpp -o demo
#include <cstdio>
#include <fstream>
#include <iostream>
#include <optional>
#include <string>

constexpr const char* kConfigPath = "miao_tmp_app.conf";

struct Config {
int width = 0;
int height = 0;
std::string name;
};

bool save(const Config& c, const char* path) {
std::ofstream out(path, std::ios::out | std::ios::trunc);
if (!out) { return false; }
out << "width=" << c.width << '\\n'
<< "height=" << c.height << '\\n'
<< "name=" << c.name << '\\n';
out.flush();
return static_cast<bool>(out); // 写完立刻查，不靠析构
}

std::optional<Config> load(const char* path) {
std::ifstream in(path);
if (!in) { return std::nullopt; } // 文件打不开：明确表达「没有值」
Config c;
std::string line;
while (std::getline(in, line)) {
const std::size_t pos = line.find('=');
if (pos == std::string::npos) { continue; } // 空行、注释行直接跳过
const std::string key = line.substr(0, pos);
const std::string val = line.substr(pos + 1);
if (key == "width") { c.width = std::stoi(val); }
if (key == "height") { c.height = std::stoi(val); }
if (key == "name") { c.name = val; }
}
return c;
}

int main() {
const Config written{1920, 1080, "miao"};
if (!save(written, kConfigPath)) {
std::cerr << "写配置失败\\n";
return 1;
}

std::ifstream show(kConfigPath);
std::string line;
while (std::getline(show, line)) { std::cout << "文件内容| " << line << '\\n'; }

const std::optional<Config> back = load(kConfigPath);
if (!back) {
std::cerr << "读配置失败\\n";
return 1;
}
const bool same = back->width == written.width
&& back->height == written.height
&& back->name == written.name;
std::cout << "读回 width=" << back->width
<< " height=" << back->height
<< " name=" << back->name << '\\n';
std::cout << "与写入一致: " << (same ? "true" : "false") << '\\n';
std::remove(kConfigPath);
}

文件内容| width=1920
文件内容| height=1080
文件内容| name=miao
读回 width=1920 height=1080 name=miao
与写入一致: true

这个程序在任何目录、跑多少次结果都一样：文件名固定但每次都从 trunc 开始，结束时自己 remove 掉，不依赖上一次运行的残留。

10. 延伸阅读

• std::basic_filebuf::open 的模式表 —— 打开模式的权威定义，app 隐含 out 之类的细节都写在这里。
• std::basic_ifstream —— 构造函数与 open 的默认模式。
• std::basic_ios::rdstate —— 状态位与 good/fail/eof/bad 的对应关系。
• std::basic_istream::getline —— 为什么它和 >> 对空白的处理不同。
• std::filesystem —— 路径拼接、文件判断、目录遍历都在这儿。

本知识库内的相关篇目：

• 《C++ stringstream 实用指南：分词解析、类型互转与 clear/str 的区别》 —— stringstream 是标准库里的「内存 IO」三件套
• 《C++ iostream 格式化输出：setw 一次性、fixed 持久，两个坑一次分清》 —— iomanip 的操纵符真正难的不是记名字，而是分清谁只影响下一个输出项、谁会一直留在流的状态里。
• 《printf 与 cout 的性能差异与混用陷阱：sync_with_stdio 到底是什么》 —— printf 与 cout 的性能差异与混用陷阱，同体系里最该一起看的另一篇。

11. 一句话总结

ofstream 默认会清空文件、>> 和 getline 混用要补一次 ignore、流不抛异常所以必须自己查状态：记住这三条，再让 RAII 去管关闭，文件读写就不会有意外了。