一、先看清 eof() 到底是什么意思

eof() 为真，表示：

"上一次读操作，是因为碰到了文件末尾而停下的。"

关键在"上一次"这三个字 ——它是"已经发生过的事"的记录，不是"接下来会怎样"的预测。

所以下面这两种想法都是错的：

那"我到底还有没有内容可读"该问谁？ ——只有"试着读一次"才知道（这正是"把读操作当条件"的全部理由）。

二、错误写法长什么样，为什么会多一次

例一：getline 版本（出现一个空行）

// ❌ 错误写法
string line;
while (!in.eof()) {
    getline(in, line);
    cout << line << endl;
}

纸面演算（文件内容是 "A\nB\nC\n" ——三行，末尾有换行）：

结果：输出 4 行，第 4 行是空的。

为什么第 4 轮还能进来？ 因为第 3 轮 getline 是"读到 \n 就停"，它并没有"碰到文件末尾" ——所以 eof() 还是 false。

要等到第 4 轮真去读了、撞上末尾，eof() 才置位 ——可是那时已经晚了，循环体已经跑过一轮了。

例二：>> 版本（重复最后一个值）

// ❌ 错误写法
int x;
while (!in.eof()) {
    in >> x;
    cout << x << endl;
}

文件内容是 "10 20 30 "（末尾有空格）：

结果：数字被重复输出一次。 ——而且因为它"看起来像正常数据"，比空行更危险。

顺带说一句：这个 Bug 的表现会随"文件末尾有没有换行/空格"而变化 ——有时多一行、有时不多。 这种"时对时错"正是它最讨厌的地方：你在测试机上跑是对的，换一个文件就错。

三、正确写法：把"读操作"放进条件

// ✅ 逐行
string line;
while (getline(in, line)) { ... }

// ✅ 逐词
string word;
while (in >> word) { ... }

// ✅ 逐字符
char ch;
while (in.get(ch)) { ... }

// ✅ 二进制
Record r;
while (in.read((char *)&r, sizeof(r))) { ... }

为什么这样就对？ 因为这些读操作返回的是"流对象"，而流对象能当布尔值用：

"这次读成功了" → 真；"这次读失败了（到末尾 / 格式错 / 出毛病）" → 假。

于是"读"和"判断"合并成一步，不可能出现"判断过了才发现读不到"的情况。

一句话：

不要问"还有没有"，直接"读一次"，读到了就干活、读不到就走人。 这就是流的设计给你准备好的正确姿势。

四、那 eof() 还有用吗？有——用来"事后归因"

正确用法：循环结束后，判断"刚才为什么停"。

int x, sum = 0, n = 0;
while (in >> x) {              // 读一次、判一次
    sum += x;
    n++;
}

// 循环为什么结束的？
if (in.eof()) {
    cout << "正常读完，共 " << n << " 个数，和 = " << sum << endl;
} else if (in.fail()) {
    cout << "读到格式不对的内容，在第 " << (n + 1) << " 个位置停下" << endl;
} else if (in.bad()) {
    cout << "发生严重错误" << endl;
}

这段代码体现了 eof() 的正确用法：

• 它是"事后报告" ——先读，读不动了，再问"是因为什么停的"；
• 它能区分"读完"和"读错" ——而这正是 fail() 单独做不到的事（15.4.1 的表里，这两种情况 fail() 都是 1）。

还有一个"事前预判"的工具：peek()

如果你真的想"先看一眼有没有下一个字符、再决定做不做"，用 peek()：

if (in.peek() == EOF) {
    cout << "已经到末尾了" << endl;
} else {
    cout << "下一个字符是 " << (char)in.peek() << endl;
}

peek() 的特点：

• 看一眼"下一个字符"，但不取走（读位置不动）；
• 返回 int（不是 char）——所以和 EOF 比较是安全的（这也是为什么它不返回 char：char 有可能会被当成 EOF）。

用 peek() 写"读到末尾"的判断（这是"事前判断"的正规写法）：

while (in.peek() != EOF) {       // ★ 先看一眼
    getline(in, line);
    ...
}

但它也有个前提：peek() 之后你还是得真的读一次 ——而且"看一眼"和"读一次"之间流的状态不能变。 所以实际工程里，"把读操作当条件"仍然是首选。

五、动手 Demo：错误与正确并列

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {
    // ── 准备两个文件 ──
    {
        ofstream o("eof_lines.txt");
        o << "A" << endl << "B" << endl << "C" << endl;      // 三行，末尾有换行
        o.close();

        ofstream o2("eof_nums.txt");
        o2 << "10 20 30 ";                                    // 末尾有空格
        o2.close();
    }

    // ══ ① 错误写法（getline 版）：多一个空行 ══
    cout << "① 错误：while (!in.eof()) + getline" << endl;
    {
        ifstream in("eof_lines.txt");
        string line;
        int n = 0;
        while (!in.eof()) {
            getline(in, line);
            cout << "   " << ++n << ": [" << line << "]" << endl;
        }
        in.close();
    }

    // ══ ② 正确写法：一行不多、一行不少 ══
    cout << "② 正确：while (getline(in, line))" << endl;
    {
        ifstream in("eof_lines.txt");
        string line;
        int n = 0;
        while (getline(in, line))
            cout << "   " << ++n << ": [" << line << "]" << endl;
        in.close();
    }

    // ══ ③ 错误写法（>> 版）：最后一个数被重复 ══
    cout << "③ 错误：while (!in.eof()) + in >> x" << endl;
    {
        ifstream in("eof_nums.txt");
        int x = -1, n = 0;
        while (!in.eof()) {
            in >> x;
            cout << "   " << ++n << ": x=" << x << endl;
        }
        in.close();
    }

    // ══ ④ 正确写法 + 事后归因 ══
    cout << "④ 正确：while (in >> x) + 事后判断原因" << endl;
    {
        ifstream in("eof_nums.txt");
        int x, sum = 0, n = 0;
        while (in >> x) { sum += x; n++; }
        cout << "   共 " << n << " 个数，和 = " << sum << endl;
        if      (in.eof())  cout << "   结束原因：正常读完" << endl;
        else if (in.fail()) cout << "   结束原因：格式不对" << endl;
        in.close();
    }
    return 0;
}

看到什么算成功：

① 错误：while (!in.eof()) + getline
   1: [A]
   2: [B]
   3: [C]
   4: []
② 正确：while (getline(in, line))
   1: [A]
   2: [B]
   3: [C]
③ 错误：while (!in.eof()) + in >> x
   1: x=10
   2: x=20
   3: x=30
   4: x=30
④ 正确：while (in >> x) + 事后判断原因
   共 3 个数，和 = 60
   结束原因：正常读完

数字怎么来的：

• ① 第 4 轮的 [] 是那次"读到末尾的失败"造成的空行；
• ③ 第 4 行的 x=30 是"读失败后 x 保持原值"造成的重复；
• ④ 的 和 = 10 + 20 + 30 = 60，共 3 个数 ——一行不多、一行不少。

读结果：

1. ①③ 是"多一次"的两种长相：一个是空行，一个是重复值。 共同点：都是"先判断、后读"造成的。
2. ②④ 是同一份数据的正确读法 ——代码还更短。
3. ④ 的"事后归因"段落展示了 eof() 的正确位置：放在循环之后。在那里，eof() 的含义清清楚楚——"循环是因为碰到末尾才结束的"。

六、30 秒实验

1. 把 eof_lines.txt 的最后那个换行删掉（写入 "A\nB\nC"），再跑 ① → 输出可能变成 3 行（不多空行了）。这就是"这个 Bug 时对时错"的实证 ——它依于文件末尾有没有换行。
2. 把 ② 的 while (getline(in, line)) 换成 while (in) → 在这个例子上结果一样（因为 in 当条件就是 !fail()）。体会"in 和读操作都能当条件"。
3. 在 ④ 的文件里加一行 abc（"10 20 30 abc "），再跑 → 和为 60、个数 3，结束原因是"格式不对"（不是"正常读完"）。这就是"事后归因"的价值 ——光看 fail() 分不出这两种情况。

七、常见误区

1. "while (!in.eof()) 是判断'还没读完'的标准写法" ——它是经典错误。eof() 是"已经碰到末尾"的记录，进循环时它还来不及置位，于是多跑一轮。
2. "那就在循环体最后判断 eof()" ——同样别扭（你还得处理"这一轮的数据是否有效"）。直接 while (读操作) 最干净。
3. "peek() 取走了那个字符" ——没有，它只是"看一眼"，读位置不动。看完还得自己读。
4. "peek() 返回 char" ——返回 int，这样才和 EOF 比较安全（char 可能装不下 EOF 这个值）。
5. "eof() 一旦为真就永远为真" ——在你 clear() 之前，确实是这样（15.4.1）。所以读完之后想重读，clear() 和 seekg 一个都不能少。
6. "反正最后多一行空行，无所谓" ——如果那一行要被解析成数据，就是灾难："多一条空记录"、"总和算错"、"统计多一个" ——这类错误不报错、还很难查。

• ☐ 下一节（15.4.4 在指定位置读/写文件）

相关笔记

• 文件的追加 —— 上一节：app / ate 与写位置
• 在指定位置读-写文件 —— 下一节：随机访问
• 文件错误与状态 —— 读完为什么同时点亮两盏灯
• 读取文本文件 —— 三种读法与"读操作当条件"
• 文件指针移动操作 —— clear() + seekg(0) 重读
• 🔷 C++基础 · 索引 —— 全课路线图