C++中的freopen的用法实例详解

前言

freopen 是 C 标准库（<cstdio> / <stdio.h>）里一个很小但极实用的函数。它的作用一句话讲完：

把一个已经打开的流（stream）重新绑定到另一个文件上。

最典型的用途，是在算法竞赛 / 本地调试 场景里，把标准输入 stdin 重定向到 in.txt，把标准输出 stdout 重定向到 out.txt ------ 这样你在本地测试时不用每次手动粘贴输入，提交时把两行 freopen 注释掉即可。

但正因为"用起来很简单"，很多人只会照抄模板，不理解它内部发生了什么。于是就踩出一类非常隐蔽的坑：

• 为什么 freopen 之后 cin 还能用，但输出顺序乱了？
• 为什么关掉 sync_with_stdio 之后，freopen 配 cout 还能工作，配 printf 反而失败？
• 为什么在 Windows 上重定向到控制台要用 "CON" 而不是 "/dev/tty"？
• 为什么 freopen 写在了 scanf 之后就不生效了？

本文把 freopen 的语义、正确用法、跨平台差异和真实坑点讲清楚。

---

一、函数原型与语义

#include <cstdio>



FILE* freopen(const char* filename,

              const char* mode,

              FILE* stream);

参数	含义
filename	目标文件路径；传 nullptr 表示改变 stream 的模式而不换文件
mode	打开模式，与 fopen 相同："r" / "w" / "a" / "rb" / "wb" / "r+" 等
stream	要重新绑定的流，通常是 stdin / stdout / stderr
返回值	成功返回 stream 本身；失败返回 NULL（原流会被关闭）

1.1 它到底做了什么

freopen 的执行过程可以拆成四步：

2. 关闭 stream 当前绑定的文件（如果已打开）
4. 忽略流当前的错误状态和 EOF 状态 （相当于 clearerr）
6. 按 mode 打开 filename
8. 把 stream 重新绑定到这个新的文件句柄上

第 2 步很关键：freopen 会顺带清掉流的错误位 。所以它不仅换文件，还相当于做了一次 clearerr(stream)。

第 4 步更关键：流对象本身没有变 （还是那个 stdin 指针），变的是它背后连着的文件。这正是为什么 freopen 之后你不用改任何后续代码 ------ scanf、cin、getchar 全都自动跟着走。

1.2 与 fopen 的对比

对比项	fopen	freopen
返回	新的 FILE*	传入的那个 stream
是否关闭原流	无关	是
是否清状态位	无关	是
用途	自建流	重定向既有流
典型场景	打开配置文件	重定向 stdin / stdout

---

二、最基本用法：重定向标准输入输出

2.1 经典模板

#include <cstdio>



int main() {

    // 把 stdin 重定向到 in.txt，从文件读

    freopen("in.txt", "r", stdin);



    // 把 stdout 重定向到 out.txt，往文件写

    freopen("out.txt", "w", stdout);



    int a, b;

    while (scanf("%d %d", &a, &b) == 2) {

        printf("%d\n", a + b);

    }



    return 0;

}

配合的 in.txt：

1 2

10 20

100 200

运行之后，控制台什么都不显示，out.txt 里是：

3

30

300

这就是它的全部魅力 ：main 里的代码是纯粹的"读 stdin、写 stdout"，和文件一点关系都没有。提交到 OJ 时把两行 freopen 注释掉，代码原封不动就能跑。

2.2 用 cin / cout 一样有效

freopen 操作的是 C 层面的 stdin / stdout。而 C++ 的 std::cin / std::cout 默认是和它们同步的 （sync_with_stdio(true)），所以 freopen 对 cin / cout 同样生效。

#include <cstdio>

#include <iostream>



int main() {

    freopen("in.txt", "r", stdin);

    freopen("out.txt", "w", stdout);



    int a, b;

    while (std::cin >> a >> b) {        // ✅ cin 也读的是 in.txt

        std::cout << a + b << '\n';     // ✅ cout 也写到 out.txt

    }

}

前提是"默认同步" ------ 这一点后面会变成一个大坑。

2.3 用条件编译控制调试/提交

比"手动注释"更优雅的做法是用宏：

#include <cstdio>

#include <iostream>



int main() {

#ifdef LOCAL

    freopen("in.txt",  "r", stdin);

    freopen("out.txt", "w", stdout);

#endif



    int n;

    std::cin >> n;

    std::cout << n * 2 << '\n';

}

编译时加宏即可切换：

# 本地调试：启用重定向

g++ -std=c++17 -DLOCAL -O2 sol.cpp -o sol



# 提交版本：不定义 LOCAL

g++ -std=c++17 -O2 sol.cpp -o sol

这样永远不用改代码 ，也就不会出现"忘记注释掉 freopen 导致 WA"的经典悲剧。

---

三、进阶用法

3.1 只重定向一个流

int main() {

    // 只把输出写进文件，输入仍来自键盘

    freopen("out.txt", "w", stdout);



    int x;

    scanf("%d", &x);

    printf("%d\n", x * x);

}

3.2 恢复回控制台

freopen 之后原来的 stdin / stdout 已经关闭了，想"切回来"需要重新绑定到控制台设备：

#include <cstdio>



int main() {

    freopen("out.txt", "w", stdout);

    printf("这行写进文件\n");



    // 恢复标准输出到控制台

#ifdef _WIN32

    freopen("CON", "w", stdout);        // Windows：CON 是控制台设备

#else

    freopen("/dev/tty", "w", stdout);   // Linux：/dev/tty 是当前终端

#endif



    printf("这行显示在控制台\n");

}

注意 ：/dev/tty 只在有控制终端 时可用；如果程序被 nohup 或通过管道运行，会返回 NULL。所以恢复操作一定要检查返回值。

if (!freopen("/dev/tty", "w", stdout)) {

    // 恢复失败，退回 stderr（stderr 通常没被重定向）

    fprintf(stderr, "无法恢复控制台输出\n");

}

3.3 stderr 不受影响

一个常被忽略的事实：freopen("out.txt", "w", stdout) 不会影响 stderr。

freopen("out.txt", "w", stdout);

printf("进文件\n");

fprintf(stderr, "仍在控制台 ------ 调试信息就该走 stderr\n");

这正是"把调试信息写 stderr、把结果写 stdout"这条建议的来源：重定向 stdout 时 stderr 还能在屏幕上给你反馈。

3.4 二进制模式

在 Windows 上，文本模式会做 \r\n ↔ \n 转换。读写二进制数据必须显式指定 "b"：

freopen("data.bin", "rb", stdin);      // 二进制读

freopen("data.bin", "wb", stdout);     // 二进制写

Linux / macOS 上 "b" 无实际作用（为了兼容而保留），但写上不会错，跨平台代码应当始终加。

3.5 检查是否成功

freopen 失败时返回 NULL，并且原流已被关闭。这时候继续读会彻底崩溃或读到垃圾：

#include <cstdio>



int main() {

    if (!freopen("in.txt", "r", stdin)) {

        fprintf(stderr, "无法打开 in.txt，程序退出\n");

        return 1;

    }



    int n;

    scanf("%d", &n);

    printf("%d\n", n);

}

注意 ：由于失败时 stdin 已被关闭，此时不要 再试图从 stdin 读；应该直接打印错误到 stderr 并退出。

---

四、完整实战：带调试开关的解题模板

#include <cstdio>

#include <cstdlib>

#include <cstring>



// 定义 DEBUG_IO 即可启用文件重定向

#ifdef DEBUG_IO

static bool setup_io() {

    if (!freopen("in.txt", "r", stdin)) {

        fprintf(stderr, "打开 in.txt 失败\n");

        return false;

    }

    if (!freopen("out.txt", "w", stdout)) {

        fprintf(stderr, "打开 out.txt 失败\n");

        return false;

    }

    return true;

}

#else

static bool setup_io() { return true; }

#endif



int main() {

    if (!setup_io()) return 1;



    // ---------- 以下是纯粹的算法逻辑 ----------

    int T;

    if (scanf("%d", &T) != 1) {

        fprintf(stderr, "读取 T 失败\n");

        return 1;

    }



    while (T--) {

        int n;

        if (scanf("%d", &n) != 1) break;



        long long sum = 0;

        for (int i = 0; i < n; ++i) {

            int x;

            scanf("%d", &x);

            sum += x;

        }

        printf("%lld\n", sum);

    }



    return 0;

}

in.txt：

3

3 1 2 3

2 10 20

4 1 1 1 1

out.txt：

6

30

4

编译与运行：

# 调试版（文件 IO）

g++ -std=c++17 -DDEBUG_IO -O2 sol.cpp -o sol_dbg

./sol_dbg



# 提交版（标准 IO）

g++ -std=c++17 -O2 sol.cpp -o sol

echo "1

2 5 7" | ./sol

---

常见坑点

坑 1：freopen 放在第一次读写之后

❌ 错误写法：

int main() {

    int x;

    scanf("%d", &x);              // 已经从键盘读过了

    freopen("in.txt", "r", stdin); // 太晚了

    scanf("%d", &x);              // 读的是 in.txt，但前一次已经消费了输入

}

freopen 必须在任何对该流的读写之前调用。因为第一步是关闭原文件，如果之前已经预读了数据进缓冲区，那部分数据就丢了。

✅ 正确写法：main 的第一件事 就是 freopen。

int main() {

    freopen("in.txt", "r", stdin);

    // ... 之后才开始读写

}

坑 2：关闭同步后 freopen 配 printf 失效

这是最隐蔽的一个坑。

#include <cstdio>

#include <iostream>



int main() {

    std::ios::sync_with_stdio(false);   // 解除 C/C++ IO 同步

    std::cin.tie(nullptr);



    freopen("out.txt", "w", stdout);    // ❌ 可能不生效

    printf("hello\n");                  // 输出到哪？未定义



    std::cout << "world\n";

}

原因 ：sync_with_stdio(false) 的语义是"让 C++ 流使用自己独立的缓冲区 ，不再和 C 流共享"。此时 cout 有自己的 streambuf，它在调用 sync_with_stdio(false) 的那一刻就已经绑定好了 stdout 的底层缓冲 。之后再 freopen 换掉 stdout 的文件句柄，cout 的缓冲链路并不会跟着更新 ------ 行为变得不可预测。

✅ 正确写法：先 freopen，再关同步。

int main() {

    freopen("in.txt",  "r", stdin);

    freopen("out.txt", "w", stdout);



    std::ios::sync_with_stdio(false);   // ✅ 顺序反过来

    std::cin.tie(nullptr);



    std::cout << "world\n";             // 正常写进 out.txt

}

但如果要混用 printf，就干脆不要关同步：

int main() {

    freopen("in.txt",  "r", stdin);

    freopen("out.txt", "w", stdout);

    // 不调用 sync_with_stdio(false)，C/C++ IO 混用才安全



    printf("C 风格\n");

    std::cout << "C++ 风格\n";

}

坑 3：freopen 后忘了 flush 导致丢输出

❌ 错误写法：

int main() {

    freopen("out.txt", "w", stdout);



    printf("done\n");

    std::_Exit(0);        // ❌ 直接终止进程，缓冲区里的数据没写盘

}

_Exit / abort / 崩溃都会跳过流的正常关闭流程，缓冲区内容全部丢失 ，out.txt 是空的。

✅ 正确写法：

int main() {

    freopen("out.txt", "w", stdout);

    printf("done\n");

    fflush(stdout);       // 显式刷出

    return 0;             // 正常返回，运行时自动关闭所有流

}

坑 4：认为 freopen 返回的和传入的是同一个指针就能忽略返回值

freopen("in.txt", "r", stdin);   // ❌ 返回值没检查

int x;

scanf("%d", &x);                 // in.txt 不存在时，stdin 已被关闭，行为未定义

"返回同一个指针"是成功时的行为 。失败时返回 NULL，而且原流已经关闭。所以：

✅ 正确写法：

if (!freopen("in.txt", "r", stdin)) {

    fprintf(stderr, "打开 in.txt 失败\n");

    return 1;

}

坑 5：Windows 上用 "/dev/tty" 恢复控制台

❌ 错误写法：

freopen("/dev/tty", "w", stdout);    // Windows 上路径不存在，返回 NULL

✅ 正确写法：

#ifdef _WIN32

    freopen("CON", "w", stdout);     // Windows 的控制台设备名

    freopen("CON", "r", stdin);

#else

    freopen("/dev/tty", "w", stdout);

#endif

Windows 的设备名保留字还有 CONIN$ / CONOUT$，效果类似。注意 "CON" 在被重定向运行（如通过管道）时也可能失败。

坑 6：重定向 stdin 后仍在用 cin 读交互式输入

freopen("in.txt", "r", stdin);

int n;

std::cin >> n;                     // 从 in.txt 读，这没问题

std::cout << "确认? ";

std::string ans;

std::getline(std::cin, ans);       // ❌ 读的还是 in.txt，不是键盘

freopen 是全局 的：stdin 被换了，cin 也跟着换。想保留"部分交互"，就不要重定向 stdin ，改用显式的 ifstream：

#include <fstream>

std::ifstream fin("in.txt");

int n;

fin >> n;                          // 只有 fin 读文件

std::string ans;

std::getline(std::cin, ans);       // cin 仍从键盘读

这是更推荐的做法 ：需要精细控制时用 ifstream，需要"整体替换"时才用 freopen。

坑 7：freopen 的 mode 传错导致文件被清空

freopen("data.txt", "w", stdout);   // ⚠️ "w" 会先截断文件

如果 data.txt 里原本有重要数据，"w" 会立即清空它 。想保留请用 "a"（追加）：

freopen("log.txt", "a", stdout);    // 追加，不破坏原内容

fopen / freopen 的 "r" 要求文件必须存在，否则返回 NULL；"w" / "a" 会自动创建文件。这个差异经常被忽略。

坑 8：多线程环境下用 freopen

freopen 修改的是进程级的全局流。在多线程程序里调用它，会影响所有线程，而且和正在读写该流的线程构成数据竞争。

规则 ：freopen 只在单线程、程序启动阶段 使用。多线程场景请改用 ifstream / ofstream，每个线程用自己的流对象。

---

五、freopen vs 其他重定向方式

方式	作用范围	可恢复	适用场景
freopen	重定向整个 stdin/stdout	需重新 freopen	竞赛、单文件调试
ifstream / ofstream	仅该对象	天然不涉及	多文件、精细控制
Shell 重定向 > out.txt	进程级	由 shell 负责	命令行工具
rdbuf() 替换	cout 单独重定向	可换回	临时静默某个输出

最后一种值得一提 ------ 用 cout 的 rdbuf 可以做到"只重定向 C++ 流、不碰 C 流"：

#include <iostream>

#include <fstream>

#include <streambuf>



int main() {

    std::ofstream ofs("out.txt");

    std::streambuf* old = std::cout.rdbuf(ofs.rdbuf());   // 保存旧的



    std::cout << "进文件\n";

    printf("仍走 stdout，进控制台\n");                     // C 流没被动过



    std::cout.rdbuf(old);                                 // 恢复

    std::cout << "回到控制台\n";

}

这个技巧在"临时把 cout 静音"时特别有用。

---

总结

要点	结论
本质	关闭旧文件 → 清状态位 → 打开新文件 → 重绑流
时机	必须在任何读写之前 ，且是 main 的第一件事
返回值	失败返回 NULL，且原流已被关闭，必须检查
与 sync_with_stdio	先 freopen，再关同步 ；混用 printf 就别关
恢复控制台	Windows 用 "CON"，Linux 用 "/dev/tty"
stderr	不受 freopen(stdout) 影响，适合放调试信息
模式	二进制加 "b"；"w" 会截断文件，追加用 "a"
替代方案	精细控制用 ifstream / ofstream 或 rdbuf()

最后给一条实践建议：用条件编译（#ifdef LOCAL）包住 freopen，而不是每次手动注释。 手动注释迟早会忘，而"忘记删 freopen 导致提交后 WA"几乎是每个竞赛选手都经历过的经典事故。把这件事交给宏，让代码结构替你保平安。