一、六个常量：是什么、用在哪

前四个是"访问方式"，第五个是"要不要清空"，第六个是"用什么格式"。 它们互不冲突，所以能组合。

二、最容易混的三对，一次分清

第一对：ios::app vs ios::ate（差别在"以后"）

一句话记住：app 是"只能往后写"，ate 是"先站到最后，然后随便你"。

第二对：ios::trunc vs ios::app（差别在"旧内容"）

这两个是本节最需要记住的一对——因为它们决定"原来那个文件还在不在"。

第三对：文本模式 vs ios::binary（差别在"怎么解释字节"）

• 不给 binary = 文本模式：Windows 上写 \n 会自动变成 \r\n，读的时候又会变回来；
• 给了 binary = 二进制模式：一个字节就是一个字节，不做任何转换。

结论：处理"给程序看的数据"（结构体、图片、exe）必须加 binary，否则文件内容会被悄悄改写（15.3.4 详讲）。

三、决策表：我想干什么 → 用什么打开方式

这张表建议直接记住。

注意：ios::trunc 和 ios::app 不要同时写。 一个说"清空"、一个说"接着写"，同时出现时结果由实现（编译器）决定，标准没规定。别制造这种歧义。

四、本节第一号事故：ofstream 的默认方式带 trunc

ofstream out("important.txt");     // ★ 这一行跑过去，important.txt 就空了

为什么？ 因为 ofstream 的默认方式里含 trunc（15.2.2 会列全表）。

于是这三行的效果，往往与新手预期相差十万八千里：

ofstream out("log.txt");                    // ❌ 清空！日志全没了
ofstream out("log.txt", ios::app);          // ✅ 追加
ofstream out("log.txt", ios::out | ios::app);   // ✅ 同上，写全了更清楚

建议：写文件时，习惯性地把模式写出来。

ofstream out("log.txt", ios::app);          // 一眼能看出"我在追加"

代码是给人看的——多写五个字符，省下的是"半年后回来一看，这文件到底清不清空"的疑惑。

五、动手 Demo：三种方式，三种命运

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

// 把整个文件内容打出来
void dump(const string &fname) {
    ifstream in(fname);
    if (!in) { cout << "  (" << fname << " 打不开)" << endl; return; }
    string line;
    bool any = false;
    while (getline(in, line)) { cout << line << " | "; any = true; }
    if (!any) cout << "(空)";
    cout << endl;
    in.close();
}

int main() {
    // ── ① trunc：每次打开都清空 ──────────────
    { ofstream o("m_trunc.txt", ios::out | ios::trunc); o << "A" << endl; }
    cout << "① trunc 第一次: "; dump("m_trunc.txt");

    { ofstream o("m_trunc.txt", ios::out | ios::trunc); o << "B" << endl; }
    cout << "① trunc 第二次: "; dump("m_trunc.txt");

    // ── ② app：接着往后写 ────────────────────
    { ofstream o("m_app.txt", ios::out | ios::app); o << "A" << endl; }
    { ofstream o("m_app.txt", ios::out | ios::app); o << "B" << endl; }
    cout << "② app  两次后 : "; dump("m_app.txt");

    // ── ③ ate：开局站末尾，但还能回头改 ───────
    { ofstream o("m_ate.txt"); o << "12345" << endl; }
    fstream f("m_ate.txt", ios::in | ios::out | ios::ate);
    if (!f) { cout << "③ 打开失败" << endl; return 1; }
    cout << "③ ate 打开后写位置: " << (long long)f.tellp() << "（在末尾）" << endl;
    f.seekp(0, ios::beg);          // ★ ate 允许回头
    f << "XY";                     // 覆盖开头两个字符
    f.close();
    cout << "③ seekp(0) 写入 XY 后: "; dump("m_ate.txt");
    return 0;
}

看到什么算成功：

① trunc 第一次: A | 
① trunc 第二次: B | 
② app  两次后 : A | B | 
③ ate 打开后写位置: 6（在末尾）
③ seekp(0) 写入 XY 后: XY345 | 

数字怎么来的：

• ③ 的文件内容是 "12345\n" = 6 字节，所以打开后写位置在 6（末尾）；
• 用 seekp(0) 回到开头，写 "XY" 覆盖了前两个字符 → "XY345\n" → 读到 XY345。

读结果——三句话：

1. ① 证明 trunc 每次都清空：第二次跑完，A 不见了，只剩 B。
2. ② 证明 app 会保留：A 和 B 都在。
3. ③ 证明 ate 与 app 的本质差别：ate 打开后虽然站在末尾，但 seekp 能把它拉回开头。换成 app 试试？（见下面的 30 秒实验）

六、30 秒实验

1. 把 ③ 的 ios::ate 换成 ios::app，再跑 → 文件里还是 12345（XY 没写进去，或者写到了末尾）。因为 app 会把写位置强行拉回末尾 ——这就是 app 与 ate 的分水岭。
2. 把 ① 里的 ios::trunc 删掉（只留 ios::out），再跑 → 结果一样（还是只剩 B）。因为 ofstream 的默认模式里就含 trunc（15.2.2）。这就是那个"看不见的 trunc"。
3. 把 ① 里的 ios::out | ios::trunc 改成 ios::in | ios::out（用 fstream 对象） → A 和 B 会同时存在（因为 in 抑制了默认的清空）。体会"模式一变，命运就变"。

七、常见误区

1. "ios::out 就是打开来写，不会动旧内容" ——会清空（ofstream 默认含 trunc）。要保留就必须显式 app。
2. "app 和 ate 都表示末尾，随便用一个" ——差别很大：app 之后写永远在末尾，ate 之后还能 seek 到别处。
3. "trunc 和 app 一起写没关系，反正都要末尾" ——不要一起写，行为由实现决定（标准没规定）。想要追加就只写 app。
4. "写二进制文件只要内容是二进制就行，不用加 binary" ——必须加。不加就是文本模式，Windows 上 \n 会被自动变成 \r\n，文件就坏了（15.3.4）。
5. "读文件也可以随便配 trunc" ——别配。ios::in | ios::trunc 是"打开就清空、然后再读" ——读一个已经被你清空的文件，这几乎从来不是你想要的。
6. "打开方式可以运行时决定" ——可以（它是一个整数），但可读性会变差。如果非要动态决定，至少写清楚注释。

• ☐ 下一节（15.2.2 默认打开方式）

相关笔记

• 文件的打开 —— 上一节：open 的用法与检查
• 默认打开方式 —— 下一节：省略第二个参数时会发生什么
• ios类中的枚举常量 —— 这些常量的出处与"位标志位"原理
• 文件的追加 —— app / ate 的再展开
• 枚举类型的声明 —— 2 的幂做标志位
• 🔷 C++基础 · 索引 —— 全课路线图