一、三种打开方式，三种"写位置"命运

这是本节的核心对照表：

从表里能读出三句关键结论：

1. app 是"强制"的 ——它的语义是"以后所有写都追加"，所以你手动 seekp 也无效；
2. ate 只是"开局站到末尾" ——之后再挪照样能写；
3. in | out 打开已有文件时，写位置在开头 ——直接写就会覆盖开头的内容（这是最容易被忽略的一条）。

二、两条实现"追加"的路

路一：打开时就用 app（推荐，最省心）

ofstream log("app.log", ios::app);
if (!log) { /* 处理失败 */ }
log << "一条新的记录" << endl;         // 自动写到末尾
log.close();

优点：一句话表达清楚意图，再也不用管位置。 适合：日志、累积记录、追加导出 ——这也是 app 存在的意义。

路二：打开后手动 seekp 到末尾（更灵活）

fstream f("data.txt", ios::in | ios::out);      // 可读可写，不清空
if (!f) { /* 处理失败 */ }
f.seekp(0, ios::end);                           // ★ 把写位置搬到末尾
f << "追加的内容" << endl;
f.close();

优点：搬完之后还能再 seekp 到别处（比如"追加完一条，再回头改前面的某个字段"）。 缺点：多一步，容易忘 ——忘了 seekp 就从开头覆盖了。

两条路的取舍

三、为什么"日志文件"必须用 app

日志的三个特点，正好是 app 的三个卖点：

1. 只往后加，从不回头改 → 正好符合 app 的"强制末尾"；
2. 文件常常已经存在（昨天、前天的日志都还在）→ app 不会清空（换默认 ofstream 就把历史日志全毁了）；
3. 程序可能被强制结束 → 即使那样，已经写进去的部分也还在（app 每次都定位到末尾，不会覆盖）。

一句话：

写日志，永远 ofstream log("x.log", ios::app); 这一行如果你写成了 ofstream log("x.log"); ——跑第一次就把日志清空了。

四、动手 Demo：五种情形，一眼看清

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

void show(const string &tag, const string &f) {
    ifstream in(f);
    cout << tag << " [" << f << "] ";
    string line;
    while (getline(in, line)) cout << line << " / ";
    cout << endl;
    in.close();
}

int main() {
    // ══ ① app：两次打开都在末尾追加 ══
    { ofstream o("m_app.txt", ios::app); o << "A" << endl; }
    { ofstream o("m_app.txt", ios::app); o << "B" << endl; }
    show("① app 追加两次      :", "m_app.txt");

    // ══ ② 默认 out|trunc：每次打开都清空 ══
    { ofstream o("m_out.txt", ios::out); o << "A" << endl; }
    { ofstream o("m_out.txt");           o << "B" << endl; }   // ★ 默认含 trunc
    show("② 默认 out 覆盖两次 :", "m_out.txt");

    // ══ ③ in|out 直接写：从开头覆盖 ══
    { ofstream o("m_seek.txt"); o << "A" << endl; }
    {
        fstream f("m_seek.txt", ios::in | ios::out);   // 不清空，但位置在开头
        f << "X" << endl;                              // ★ 覆盖掉原来的 A
        f.close();
    }
    show("③ in|out 直接写     :", "m_seek.txt");

    // ══ ④ in|out + seekp 末尾：正确的手动追加 ══
    { ofstream o("m_seek2.txt"); o << "A" << endl; }
    {
        fstream f("m_seek2.txt", ios::in | ios::out);
        f.seekp(0, ios::end);                          // ★ 先搬到末尾
        f << "B" << endl;
        f.close();
    }
    show("④ in|out + seekp 末尾:", "m_seek2.txt");

    // ══ ⑤ app 模式下，seekp 也拉不回来 ══
    { ofstream o("m_app2.txt"); o << "AAAAA" << endl; }
    {
        ofstream o("m_app2.txt", ios::app);
        o.seekp(0, ios::beg);                          // 想回到开头
        o << "X" << endl;                              // ★ 实际还是写在末尾
        o.close();
    }
    show("⑤ app 里 seekp 无效 :", "m_app2.txt");
    return 0;
}

看到什么算成功：

① app 追加两次      : [m_app.txt] A / B / 
② 默认 out 覆盖两次 : [m_out.txt] B / 
③ in|out 直接写     : [m_seek.txt] X / 
④ in|out + seekp 末尾: [m_seek2.txt] A / B / 
⑤ app 里 seekp 无效 : [m_app2.txt] AAAAA / X / 

读结果——五行，五个结论：

这一张输出，就把"追加"的全部要点讲完了。

五、30 秒实验

1. 把 ① 的 ios::app 删掉（变成默认 ofstream），再跑 → 只剩 B。这就是"忘了写 app 的代价"。
2. 在 ⑤ 里把 ios::app 换成 ios::ate，再跑 → X 会覆盖开头（因为 ate 只负责"开局末尾"，之后 seekp(0) 真的能回到开头）——结果变成 XAAAA。这就是 app 与 ate 的分水岭。
3. 把 ③ 改成 fstream f("m_seek.txt", ios::in | ios::out | ios::app); → X 落在末尾，A 保住了。这就是"既想读写、又想追加"的写法。

六、常见误区

1. "想追加就写 ios::out" ——out 会清空（ofstream 默认含 trunc）。追加必须 app（或手动 seekp 到末尾）。
2. "app 和 ate 都是末尾，写 ate 更灵活" ——看需求：纯追加用 app（更安全，不会被误 seek 破坏）；要"末尾 + 回头改"用 ate。
3. "用 in | out 打开就能追加" ——不能。写位置在开头，直接写会覆盖。 要追加必须 seekp(0, ios::end)。
4. "seekp 之后就一直有效" ——在 app 模式下 seekp 对写操作无效（每次写前都会被拉回末尾）。要自由定位就别用 app。
5. "追加的内容会另起一行" ——不会。文件没有"行"的概念，只有字节。你上次写的内容如果没有以换行结尾，新内容会直接接在它后面（AAAAA 后面接 X 就是 AAAAAX）。要换行就自己写 \n 或 endl。
6. "写完不关也没事，反正下次还会追加" ——有事：这次的数据可能还在缓冲区，而且文件可能被系统标记为"正在使用"。追加完就 close()。

• ☐ 下一节（15.4.3 文件结尾的判断）

相关笔记

• 文件错误与状态 —— 上一节：状态位与 clear()
• 文件结尾的判断 —— 下一节：eof() 怎么用才对
• 打开方式 —— app / ate / trunc 的第一次登场
• 默认打开方式 —— 默认含 trunc 的由来
• 文件指针移动操作 —— seekp 的用法
• 🔷 C++基础 · 索引 —— 全课路线图