文件及基本读写

约 5135 字大约 17 分钟

2025-06-25

文件的基本概念、文本文件的基本操作

文件操作

在C++信奥赛中，文件操作是处理输入输出的重要技能，尤其当数据量较大或需要持久化存储时。下面详细介绍文件的基本概念及文本文件的操作方法。

一、文件的基本概念

文件的基本概念

1. 什么是文件？

文件是存储在磁盘（如硬盘）中的数据集合，用于长期保存信息。程序运行时的变量数据存放在内存中，程序结束后会消失，而文件数据可永久保存。

2. 文件的分类

文本文件：以字符（如ASCII码）存储，内容可直接被人类阅读（如.txt文件）。例如数字123存储为字符'1'、'2'、'3'。
二进制文件：以字节为单位存储原始数据，不可直接阅读（如图片、可执行文件）。例如数字123存储为二进制01111011。

信奥赛中文本文件更常用，因其便于调试和手动修改。

二、文本文件操作的核心类（`<fstream>`库）

文本文件操作的核心类

C++通过<fstream>库提供文件操作，核心类：

ifstream：输入文件流，用于读取文件。
ofstream：输出文件流，用于写入文件。
fstream：可同时读写文件（少用）。

使用前需包含头文件并打开命名空间：

c++

#include <fstream>  // 包含文件操作类
#include <iostream>
using namespace std;

三、文本文件的写入操作（`ofstream`）

文本文件的写入操作

步骤：打开文件 → 写入数据 → 关闭文件。

1. 打开文件的方式

默认方式：ofstream out("文件名")，若文件不存在则创建，若存在则则清空内容。
追加模式：ofstream out("文件名", ios::app)，在文件末尾追加内容，不覆盖原有数据。

2. 写入示例

c++

// 写入文本文件
void writeFile() {
    // 1. 打开文件（默认则创建，存在则清空）
    ofstream out("data.txt");  // 等价于 ofstream out; out.open("data.txt");
    
    // 检查文件是否打开成功
    if (!out.is_open()) {
        cout << "文件打开失败！" << endl;
        return;
    }
    
    // 2. 写入数据（用法与cout类似）
    out << "Hello, File!" << endl;  // 写入字符串
    out << 123 << " " << 3.14 << endl;  // 写入数字
    out << "姓名 年龄" << endl;
    out << "Alice " << 15 << endl;
    
    // 3. 关闭文件（必须执行，否则数据可能未写入）
    out.close();
}

注意：若文件打开失败（如权限不足），后续操作会出错，务必用is_open()检查。

四、文本文件的读取操作（`ifstream`）

文本文件的读取操作

步骤：打开文件 → 读取数据 → 关闭文件。

1. 读取方式

按数据类型读取：与cin用法相同，用>>运算符，自动跳过空格和换行。
按行读取：用getline()函数读取一整行（包括空格）。
判断文件结束：用eof()函数（文件结束返回true）。

2. 读取示例

c++

// 读取文本文件
void readFile() {
    // 1. 打开文件
    ifstream in("data.txt");
    if (!in.is_open()) {
        cout << "文件打开失败！" << endl;
        return;
    }
    
    // 2. 读取数据
    // 方式1：按类型读取（跳过空格和换行）
    string str;
    int num;
    double d;
    in >> str;  // 读"Hello, File!"
    in >> num >> d;  // 读123和3.14
    cout << "方式1读取：" << str << " " << num << " " << d << endl;
    
    // 方式2：按行读取（需先清空缓冲区残留的换行符）
    in.ignore();  // 忽略之前读取残留的换行符
    string line;
    cout << "\n方式2按行读取：" << endl;
    while (getline(in, line)) {  // 读取一行，直到文件结束
        cout << line << endl;
    }
    
    // 3. 关闭文件
    in.close();
}

输出结果

方式1读取：Hello, File! 123 3.14

方式2按行读取：
姓名 年龄
Alice 15

五、信奥赛：从文件输入，向文件输出

从文件输入，向文件输出

信奥赛中常需从文件读入数据，处理后写入另一个文件，替代控制台输入输出。

示例：统计文件中数字的和

c++

int main() {
    // 1. 打开输入文件和输出文件
    ifstream fin("input.txt");   // 输入文件（存放待求和的数字）
    ofstream fout("output.txt"); // 输出文件（存放结果）
    
    if (!fin || !fout) {
        cout << "文件打开失败！" << endl;
        return 1;
    }
    
    // 2. 读取数字并求和
    int sum = 0, num;
    while (fin >> num) {  // 读取所有数字，直到文件结束
        sum += num;
    }
    
    // 3. 写入结果
    fout << "总和是：" << sum << endl;
    
    // 4. 关闭文件
    fin.close();
    fout.close();
    return 0;
}

使用方法：

创建input.txt，写入数字（如1 2 3 4 5）。
运行程序后，output.txt中会生成总和是：15。

六、避坑指南

避坑指南

文件路径问题：
- 直接写文件名（如"data.txt"）时，文件需与程序在同一目录。
- 也可写绝对路径（如"C:\\test\\data.txt"，注意Windows下用\\）。
忘记关闭文件：
- 文件未关闭时，数据可能留在缓冲区未写入磁盘，导致内容丢失。
- 养成open()后立即close()的习惯。
读取残留换行符：
- 用>>读取后，换行符会留在缓冲区，导致后续getline()读空行。
- 解决：用in.ignore()清空缓冲区。
文件打开失败的原因：
- 路径错误（文件不存在）。
- 权限不足（如只读文件写入）。
- 文件被其他程序占用。

七、实战总结

实战总结

文本文件操作的核心流程：

c++

// 写入
ofstream out("文件名");
if (out.is_open()) {
    out << 数据;
    out.close();
}

// 读取
ifstream in("文件名");
if (in.is_open()) {
    in >> 变量;  // 或 getline(in, 字符串)
    in.close();
}

重要

在信奥赛中，熟练掌握文本文件的读写能高效处理大量测试数据，避免手动输入的繁琐。记住：打开文件后先检查是否成功，操作完成后及时关闭，这是保证程序稳定性的关键。

文本文件类型与二进制文件类型

在C++信奥赛中，文件操作是处理数据输入输出的重要技能。根据存储格式的不同，文件可分为文本文件和二进制文件，两者在存储方式、操作方法和适用场景上有显著区别。下面详细对比并讲解两种文件的操作方式。

一、文本文件与二进制文件的核心区别

特性	文本文件（Text File）	二进制文件（Binary File）
存储方式	以字符编码（如ASCII、UTF-8）存储，每个字符对应一个字节	以数据的原始二进制形式存储，直接反映内存中的表示
可读性	可被人类直接阅读（如用记事本打开）	不可直接阅读（需专用程序解析）
数据转换	写入时需将数据转换为字符序列（如`123`→`'1'+'2'+'3'`）	直接存储内存中的二进制数据（如`123`→`0x7B`）
占用空间	通常较大（如`int`类型的`12345`需5个字节）	较小（`int`类型固定4字节，与数值无关）
操作效率	较低（需频繁转换数据格式）	较高（直接读写内存数据，无格式转换）
适用场景	配置文件、日志、小规模数据（便于调试和手动修改）	大规模数据、多媒体文件、结构化数据（效率优先）

二、文本文件的操作（复习）

文本文件的操作（复习）

文本文件通过字符流读写，操作类为ifstream（读）和ofstream（写），用法与cin/cout类似。

1. 写入文本文件

c++

#include <fstream>
using namespace std;

void writeTextFile() {
    ofstream fout("data.txt");  // 打开文件（不存在则创建）
    if (!fout.is_open()) {
        cerr << "文件打开失败！" << endl;
        return;
    }
    // 写入数据（自动转换为字符）
    fout << "姓名：Alice" << endl;
    fout << "年龄：15" << endl;
    fout << "成绩：92.5" << endl;
    fout.close();  // 关闭文件
}

文本文件内容

姓名：Alice
年龄：15
成绩：92.5

c++

void readTextFile() {
    ifstream fin("data.txt");
    if (!fin.is_open()) {
        cerr << "文件打开失败！" << endl;
        return;
    }
    string line;
    // 按行读取
    while (getline(fin, line)) {
        cout << line << endl;
    }
    fin.close();
}

三、二进制文件的操作（重点）

二进制文件的操作（重点）

二进制文件直接读写内存中的原始数据，需用read()和write()函数，且打开时需指定ios::binary模式。

1. 核心函数

写入：fout.write((const char*)&数据, 字节数);
将变量的内存数据直接写入文件。
读取：fin.read((char*)&变量, 字节数);
从文件读取原始数据到变量内存中。

2. 写入二进制文件

c++

struct Student {  // 定义结构体（二进制操作常用）
    char name[20];  // 固定长度（避免string的复杂内存布局）
    int age;
    double score;
};

void writeBinaryFile() {
    // 打开二进制文件（ios::binary指定二进制模式）
    ofstream fout("students.bin", ios::binary);
    if (!fout) {
        cerr << "文件打开失败！" << endl;
        return;
    }
    // 准备数据
    Student s1 = {"Alice", 15, 92.5};
    Student s2 = {"Bob", 16, 88.0};
    // 写入数据（取地址并强转为char*，指定大小）
    fout.write((const char*)&s1, sizeof(s1));
    fout.write((const char*)&s2, sizeof(s2));
    fout.close();
}

文件内容（不可直接阅读）：
二进制数据（用记事本打开会显示乱码）。

3. 读取二进制文件

c++

void readBinaryFile() {
    ifstream fin("students.bin", ios::binary);
    if (!fin) {
        cerr << "文件打开失败！" << endl;
        return;
    }
    Student s;
    // 循环读取所有数据（直到文件结束）
    while (fin.read((char*)&s, sizeof(s))) {
        cout << "姓名：" << s.name 
             << "，年龄：" << s.age 
             << "，成绩：" << s.score << endl;
    }
    fin.close();
}

输出结果

姓名：Alice，年龄：15，成绩：92.5
姓名：Bob，年龄：16，成绩：88

四、关键差异与注意事项

关键差异与注意事项

1. 打开模式

文本文件：默认模式（可省略），或显式指定ios::in（读）、ios::out（写）。
二进制文件：必须加ios::binary，否则可能因系统对换行符的处理（如Windows的\r\n转换）导致数据错误。

2. 数据类型与转换

文本文件：自动进行数据→字符串的转换（如int→字符序列），适合人类阅读。
二进制文件：直接读写内存数据，必须知道数据类型和结构才能正确解析（如结构体的成员布局）。

3. 字符串处理

二进制文件中避免使用string（内部有指针，存储的是地址而非实际字符），应使用固定长度的字符数组（如char name[20]）。

4. 兼容性

文本文件跨平台兼容性好（不同系统对字符编码的处理一致）。
二进制文件可能因CPU字节序（大端/小端）或数据类型长度（如int在32位/64位系统的差异）导致跨平台问题（信奥赛中通常在同一环境下运行，可忽略）。

五、信奥赛中的选择

信奥赛中的选择

优先用文本文件的场景：
- 数据量小，需要手动检查或修改（如测试用例输入input.txt）。
- 数据格式不规则（如包含字符串、混合类型的日志）。
- 调试阶段（便于观察数据是否正确写入）。
优先用二进制文件的场景：
- 数据量大（如10万条结构体数据），追求读写效率。
- 数据格式固定（如纯数值数组、结构体数组）。
- 需快速保存/加载程序状态（如游戏存档）。

六、实战对比：存储10000个整数

存储10000个整数

1. 文本文件方式

c++

// 写入
ofstream fout("nums.txt");
for (int i = 0; i < 10000; i++) {
    fout << i << " ";  // 每个数转换为字符，加空格分隔
}
// 读取
ifstream fin("nums.txt");
int x;
while (fin >> x) { ... }

缺点：写入时每个数字转换为字符（如12345占5字节），总大小约40KB~60KB，读写速度慢。

2. 二进制文件方式

c++

// 写入
ofstream fout("nums.bin", ios::binary);
int arr[10000];
for (int i = 0; i < 10000; i++) arr[i] = i;
fout.write((char*)arr, sizeof(arr));  // 直接写入40000字节（10000×4）
// 读取
ifstream fin("nums.bin", ios::binary);
int arr[10000];
fin.read((char*)arr, sizeof(arr));

优点：总大小固定40000字节（40KB），读写速度快（无格式转换）。

七、避坑指南

避坑指南

二进制文件的类型匹配：
读取时的变量类型必须与写入时完全一致，否则会解析错误：

c++

// 错误示例：写入int却用double读取
int a = 100;
fout.write((char*)&a, sizeof(a));
double b;
fin.read((char*)&b, sizeof(b));  // 读取结果错误

结构体的对齐问题：
结构体成员可能因内存对齐产生间隙，写入和读取时需用同一编译器和设置（信奥赛环境通常一致，无需额外处理）。

文件结束判断：
二进制文件用fin.read()的返回值判断是否读取成功（而非eof()，避免多读一次）：

c++

// 正确
while (fin.read((char*)&s, sizeof(s))) { ... }
// 错误（可能最后一次读取不完整）
while (!fin.eof()) {
    fin.read((char*)&s, sizeof(s));
}

重要

在信奥赛中，需根据数据规模和格式选择合适的文件类型。调试时用文本文件便于排查错误，最终提交时若数据量大，可改用二进制文件提升效率。掌握两种文件的操作方法，能灵活应对各类输入输出场景。

文本文件：以字符形式存储，易读但效率低，适合小规模、需人工干预的数据。
二进制文件：以原始二进制存储，高效但不可直接阅读，适合大规模、结构化数据。

文件重定向、文件读写等操作

文件重定向、文件读写

在C++信奥赛中，文件操作是处理大规模数据输入输出的核心技能，其中文件重定向和文件读写是最常用的两种方式。掌握这些技巧能让程序更高效地处理测试数据，避免手动输入的繁琐。

一、文件重定向（快速替换标准输入输出）

文件重定向

文件重定向是一种简单的文件操作方式，通过修改程序的标准输入（cin）和标准输出（cout）的流向，直接从文件读取数据或向文件写入数据，无需修改核心逻辑代码。

1. 重定向原理

程序默认从键盘（stdin）读取输入，向屏幕（stdout）输出。
文件重定向通过freopen函数将cin绑定到输入文件，cout绑定到输出文件。

2. 核心函数：`freopen`

c++

#include <cstdio>  // 包含freopen函数

输入重定向：freopen("输入文件名", "r", stdin);
将cin/scanf的输入源改为指定文件。
输出重定向：freopen("输出文件名", "w", stdout);
将cout/printf的输出目标改为指定文件。

3. 使用示例

c++

#include <iostream>
#include <cstdio>  // 必须包含
using namespace std;

int main() {
    // 重定向输入（从input.txt读取）
    freopen("input.txt", "r", stdin);
    // 重定向输出（写入output.txt）
    freopen("output.txt", "w", stdout);

    // 核心逻辑（与控制台操作完全相同）
    int a, b;
    cin >> a >> b;  // 实际从input.txt读取
    cout << a + b << endl;  // 实际写入output.txt

    // 关闭重定向（可选，程序结束会自动关闭）
    fclose(stdin);
    fclose(stdout);
    return 0;
}

4. 优势与适用场景

优势：无需修改核心代码，只需在程序开头添加两行重定向代码，即可实现文件输入输出。
适用场景：信奥赛中快速测试程序（用文件替代手动输入），或提交代码时处理大规模测试数据。

二、文件流读写（灵活控制文件操作）

文件流读写

通过<fstream>库的ifstream（输入流）和ofstream（输出流）类，可更灵活地控制文件读写，支持打开多个文件、判断文件状态等高级操作。

1. 单文件读写（基础）

c++

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

int main() {
    // 1. 打开输入文件和输出文件
    ifstream fin("input.txt");  // 输入流（读）
    ofstream fout("output.txt");  // 输出流（写）

    // 检查文件是否打开成功
    if (!fin.is_open() || !fout.is_open()) {
        cerr << "文件打开失败！" << endl;
        return 1;
    }

    // 2. 读写数据（与cin/cout用法类似）
    int n, sum = 0;
    fin >> n;  // 从input.txt读入n
    for (int i = 0; i < n; i++) {
        int x;
        fin >> x;
        sum += x;
    }
    fout << "总和：" << sum << endl;  // 写入output.txt

    // 3. 关闭文件
    fin.close();
    fout.close();
    return 0;
}

2. 多文件操作（进阶）

可同时打开多个文件进行读写，适合需要对比或合并多个数据源的场景：

c++

void mergeFiles() {
    // 打开两个输入文件和一个输出文件
    ifstream fin1("data1.txt");
    ifstream fin2("data2.txt");
    ofstream fout("merged.txt");

    if (!fin1 || !fin2 || !fout) {
        cerr << "文件打开失败！" << endl;
        return;
    }

    // 交替读取两个文件的内容并写入合并文件
    string line1, line2;
    while (getline(fin1, line1) && getline(fin2, line2)) {
        fout << line1 << " " << line2 << endl;
    }

    // 处理剩余内容
    while (getline(fin1, line1)) fout << line1 << endl;
    while (getline(fin2, line2)) fout << line2 << endl;

    // 关闭所有文件
    fin1.close();
    fin2.close();
    fout.close();
}

3. 二进制文件读写（高效存储）

对于大规模数据（如结构体数组），二进制读写比文本方式更高效：

c++

#include <fstream>
using namespace std;

struct Student {
    char name[20];
    int age;
    double score;
};

// 写入二进制文件
void writeBinary() {
    ofstream fout("students.bin", ios::binary);  // 二进制模式
    Student s1 = {"Alice", 15, 92.5};
    Student s2 = {"Bob", 16, 88.0};
    fout.write((const char*)&s1, sizeof(s1));  // 直接写入内存数据
    fout.write((const char*)&s2, sizeof(s2));
    fout.close();
}

// 读取二进制文件
void readBinary() {
    ifstream fin("students.bin", ios::binary);
    Student s;
    while (fin.read((char*)&s, sizeof(s))) {  // 读取到变量
        cout << s.name << " " << s.age << " " << s.score << endl;
    }
    fin.close();
}

三、两种方式的对比与选择

操作方式	优势	劣势	适用场景
文件重定向	代码改动小，直接复用控制台输入输出逻辑	只能操作标准输入输出，无法同时打开多个文件	快速测试、提交代码时处理单一文件
文件流读写	可打开多个文件，支持二进制模式，更灵活	需要修改代码逻辑，声明流对象	多文件操作、二进制文件、复杂读写逻辑

四、信奥赛实战技巧

信奥赛实战技巧

1. 调试与提交的兼容写法

在本地调试时用控制台输入，提交时切换到文件重定向，避免频繁修改代码：

c++

#include <iostream>
#include <cstdio>
using namespace std;

int main() {
    // 调试时注释掉以下两行，提交时取消注释
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    // 核心逻辑（不变）
    int a, b;
    cin >> a >> b;
    cout << a + b << endl;
    return 0;
}

2. 处理文件路径问题

c++

// Windows路径（用\\分隔）
freopen("C:\\test\\input.txt", "r", stdin);
// Linux/Mac路径（用/分隔）
freopen("/home/user/test/input.txt", "r", stdin);

3. 大数据读写优化

文本文件：用scanf/printf替代cin/cout（更快），并关闭同步：

c++

ios::sync_with_stdio(false);  // 关闭cin与stdio同步，加速输入
cin.tie(0);  // 解除cin与cout绑定，进一步加速

二进制文件：直接读写整块数据（如数组），减少IO次数：

c++

int arr[100000];
// 写入
fout.write((char*)arr, sizeof(arr));
// 读取
fin.read((char*)arr, sizeof(arr));

五、避坑指南

避坑指南

文件打开失败：
- 检查文件名或路径是否正确（区分大小写，如Input.txt和input.txt不同）。
- 确保文件有读写权限（如不要尝试写入只读文件）。
重定向后控制台无输出：
- 重定向后cout的内容会写入文件，控制台不再显示，调试时需注释重定向代码。
二进制文件的类型匹配：
- 读写时的数据类型必须一致（如写入int就必须用int读取），否则会解析错误。
忘记关闭文件：
- 虽然程序结束会自动关闭文件，但手动关闭（close()或fclose()）是良好习惯，避免数据丢失。

重要

掌握这两种方式，并结合优化技巧（如关闭同步、整块读写），能轻松应对各类文件操作场景，显著提升程序效率和稳定性。信奥赛中文件操作的核心是根据场景选择合适的方式：

快速测试或提交代码：用freopen进行文件重定向，简单高效。
多文件处理或大规模数据：用ifstream/ofstream，支持二进制模式和灵活控制。

基础知识与编程环境

C++程序设计

数据结构

算法

数学与其他

基础知识与编程环境

C++程序设计

文件及基本读写