[数据结构·C++语法] 文件IO核心指南

C++ 通过 <fstream> 头文件提供强大的文件输入/输出功能。它将文件视为一种“流”（stream），允许你像使用 cin 和 cout 一样方便地读写文件。

核心头文件：

#include <fstream>
````

---

## 1. 核心类 (文件流对象)

在 `<fstream>` 中，你主要会用到三个类，它们是文件操作的“变量”：

- **`std::ifstream`** (Input File Stream)
    
    - **用途：** 用于从文件中**读取**数据。
        
    - **类比：** 就像 `cin`，但数据源是文件。
        
- **`std::ofstream`** (Output File Stream)
    
    - **用途：** 用于向文件中**写入**数据。
        
    - **类比：** 就像 `cout`，但目的地是文件。
        
- **`std::fstream`** (File Stream)
    
    - **用途：** 可以同时**读取和写入**同一个文件。
        
    - **类比：** `cin` 和 `cout` 的结合体。
        

---

## 2. 核心函数与操作

### A. 打开文件

有两种方式打开文件：

**方式一：在构造时打开 (推荐)**
```cpp
// 1. 打开文件用于写入 (默认会清空文件内容)
std::ofstream outFile("my_file.txt"); 

// 2. 打开文件用于读取
std::ifstream inFile("my_file.txt");

方式二：使用 open() 成员函数

std::ofstream outFile;
outFile.open("my_file.txt");

std::ifstream inFile;
inFile.open("my_file.txt");

B. 检查文件是否打开成功 (必须)

在读写之前，必须检查文件是否成功打开。如果文件不存在（读取时）或没有权限（写入时），操作会失败。

std::ifstream inFile("my_file.txt");

// 方式一：使用 .is_open()
if (!inFile.is_open()) {
    std::cerr << "错误：无法打开文件 my_file.txt" << std::endl;
    // 在此 return 或 exit
}

// 方式二：直接在 if 语句中检查 (更简洁)
// 文件流对象在布尔上下文中会自动转换为 true (如果成功) 或 false (如果失败)
if (!inFile) {
    std::cerr << "错误：无法打开文件 my_file.txt" << std::endl;
}

C. 文件打开模式 (File Modes)

在打开文件时，你可以指定“模式”来控制如何操作文件。模式通过 std::ios 命名空间访问，并使用 | (按位或) 组合。

std::ios::in：读模式（ifstream 默认）。
std::ios::out：写模式（ofstream 默认）。
std::ios::trunc：截断模式。在打开文件时清空所有内容（ofstream 默认）。
std::ios::app：追加模式。从文件末尾开始写入，不清空内容。
std::ios::binary：二进制模式（默认为文本模式）。

常见组合示例：

// 1. 写入文件 (清空原内容) - 默认模式
std::ofstream outFile1("log.txt"); 
// 等同于: std::ofstream outFile1("log.txt", std::ios::out | std::ios::trunc);

// 2. 向文件末尾追加内容
std::ofstream outFile2("log.txt", std::ios::app);
// 等同于: std::ofstream outFile2("log.txt", std::ios::out | std::ios::app);

// 3. 打开文件用于读和写
std::fstream file("data.dat", std::ios::in | std::ios::out);

// 4. 打开二进制文件用于写入
std::ofstream binFile("data.bin", std::ios::out | std::ios::binary);

D. 关闭文件

1 2	outFile.close(); inFile.close();

注意： 当 ifstream 或 ofstream 对象离开其作用域时（例如函数结束），其析构函数会自动调用 close()。因此，显式调用 close() 不是必须的，但在长函数中或需要立即释放文件句柄时是好习惯。

3. 常见用法 1: 文本文件 I/O (Text I/O)

文本 I/O 用于读写人类可读的字符数据（如 .txt, .csv, .md 文件）。

A. 写入文本文件 (使用 `<<`)

使用流插入运算符 <<，就像 cout 一样。

实例：

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ofstream outFile("config.txt"); // 打开文件 (默认清空)

    if (!outFile) {
        std::cerr << "无法创建 config.txt" << std::endl;
        return 1;
    }

    // 像 cout 一样写入
    outFile << "AppName=SalarySystem" << std::endl;
    outFile << "Version=1.0" << std::endl;
    int userCount = 100;
    outFile << "UserCount=" << userCount << std::endl;

    outFile.close(); // 关闭文件
    std::cout << "配置文件写入成功。" << std::endl;
    return 0;
}

config.txt 的内容：

1
2
3

AppName=SalarySystem
Version=1.0
UserCount=100

B. 读取文本文件 (使用 `>>` 和 `getline`)

方式一：使用 >> (按空格/换行分隔)

流提取运算符 >> 会自动以空白字符（空格、制表符、换行符）为分隔符来读取数据。
这正是你项目中 loadFromFile 使用的方法：ifs >> type >> name >> data;

方式二：使用 std::getline() (按行读取)

getline 读取一整行，直到遇到换行符。

实例 (结合两种方式)：

#include <iostream>
#include <fstream>
#include <string>
#include <sstream> // 之后会用到

int main() {
    std::ifstream inFile("employees.txt");
    if (!inFile) {
        std::cerr << "无法打开 employees.txt" << std::endl;
        return 1;
    }

    // 假设 employees.txt 内容如下:
    // Manager Alice 4
    // Technican Bob 3
    // Saleman Charlie 1

    std::string type, name;
    int rank;

    std::cout << "--- 方式一: 使用 >> 读取 ---" << std::endl;
    // 最佳实践：使用 (inFile >> var) 作为循环条件
    // 当读取失败或到达文件末尾时，循环会自动停止。
    while (inFile >> type >> name >> rank) {
        std::cout << "类型: " << type << ", 姓名: " << name << ", 级别: " << rank << std::endl;
    }

    // 陷阱：不要使用 while (!inFile.eof())
    // eof() 标志只在 *尝试读取* 文件末尾 *之后* 才会为 true，
    // 这会导致循环多执行一次。

    inFile.close(); // 关闭并重置

    // --- 演示 getline ---
    std::cout << "\n--- 方式二: 使用 getline 读取 ---" << std::endl;
    std::ifstream inFile2("employees.txt");
    std::string line;

    // 每次读取一行
    while (std::getline(inFile2, line)) {
        std::cout << "读取到整行: " << line << std::endl;
        
        // 如果需要解析行内数据，需配合 stringstream
        std::stringstream ss(line);
        std::string line_type, line_name;
        int line_rank;
        if (ss >> line_type >> line_name >> line_rank) {
             std::cout << "  (解析) 类型: " << line_type << ", 姓名: " << line_name << std::endl;
        }
    }
    
    inFile2.close();
    return 0;
}

4. 常见用法 2: 二进制文件 I/O (Binary I/O)

二进制 I/O 用于读写原始的字节数据。它速度更快、文件更小，但内容不是人类可读的。常用于保存 struct 或 class 的原始内存映像。

A. 关键函数 (`write` / `read`)

write(const char* buffer, streamsize count)：将 buffer 指向的内存中的 count 个字节写入文件。
read(char* buffer, streamsize count)：从文件中读取 count 个字节到 buffer 指向的内存。

注意： 你需要使用 reinterpret_cast 来将你的数据指针转换为 char*。

B. 实例：保存和读取结构体

#include <iostream>
#include <fstream>
#include <string>

// 假设有一个简单的数据结构 (POD - Plain Old Data)
struct Player {
    int id;
    char name[50]; // 二进制读写时，用 C 风格字符串更简单
    double score;
};

int main() {
    Player p1 = {101, "TestUser", 95.5};
    Player p2_load; // 用于加载数据

    // --- 1. 写入二进制文件 ---
    // 必须指定 std::ios::binary
    std::ofstream outFile("player.dat", std::ios::binary);
    if (!outFile) {
        std::cerr << "无法创建 player.dat" << std::endl;
        return 1;
    }

    // 将 p1 对象的内存数据，原封不动地写入文件
    outFile.write(reinterpret_cast<const char*>(&p1), sizeof(Player));
    outFile.close();
    std::cout << "二进制数据写入成功。" << std::endl;

    // --- 2. 读取二进制文件 ---
    std::ifstream inFile("player.dat", std::ios::binary);
    if (!inFile) {
        std::cerr << "无法读取 player.dat" << std::endl;
        return 1;
    }

    // 从文件读取数据，原封不动地填充到 p2_load 对象的内存中
    inFile.read(reinterpret_cast<char*>(&p2_load), sizeof(Player));
    inFile.close();

    std::cout << "读取数据成功：" << std::endl;
    std::cout << "ID: " << p2_load.id << std::endl;
    std::cout << "Name: " << p2_load.name << std::endl;
    std::cout << "Score: " << p2_load.score << std::endl;

    return 0;
}

5. 重要陷阱与注意事项

⚠️ 陷阱：二进制 I/O 和 std::string / std::vector

你不能像上面的 Player 示例一样，直接对包含 std::string、std::vector 或其他指针成员的类使用 read/write。

原因： std::string 对象本身（在栈上）只包含一个指向堆内存的指针和一些大小信息。write 只会保存这个指针地址，而不是它指向的实际字符数据。当你 read 回来时，得到的是一个无效的指针，程序会崩溃。

对你项目的影响：

你的 Person 类有 std::string name 成员。因此，你不能像下面这样做：

1
2
3

// 错误！不能对包含 std::string 的类使用二进制 write
Manager m("Alice");
outFile.write(reinterpret_cast<const char*>(&m), sizeof(Manager));

结论： 对于你的项目，使用文本 I/O（即 << 和 >>）是正确且安全的选择。

文章作者: Eisem

文章链接: http://example.com/2025/12/06/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%AC%94%E8%AE%B0/C++%E8%AF%AD%E6%B3%95/C++%20%E6%96%87%E4%BB%B6%20IO%20%E6%A0%B8%E5%BF%83%E6%8C%87%E5%8D%97/

C++文件IO fstream

相关推荐

2025-12-06

[数据结构·C++语法] STL list 详解

C++ STL std::list 详解与应用指南std::list 是 C++ 标准模板库（STL）中的双向链表容器。与 std::vector（动态数组）不同，它的内存是不连续的。 1. 核心特性与迭代器1.1 迭代器类型：双向迭代器 (Bidirectional Iterator)这是 list 最需要注意的地方，它的迭代器不像 vector 那样支持随机访问。不支持的操作： it + 5, it - 3 (算术加减) it[2] (下标访问) it1 < it2 (大小比较，只能判断 != 或 ==) std::sort(list.begin(), list.end()) (标准库的通用排序无法处理它) 支持的操作： it++, ++it, it--, --it *it (解引用) it1 == it2, it1 != it2 1.2 辅助函数 (移动迭代器)由于不能直接 +n，如果需要移动多步，必须使用 <iterator> 头文件中的函数： std::next(it, n): 返回向前移动 $n$ 步后的迭代器（$O(n)$...

2025-12-06

[数据结构·C++语法] 模板用法详解

C++ 中的模板（Template）是泛型编程的基石。它允许我们编写与类型无关的代码，即编写一个函数或一个类，让它们能够处理任何数据类型，而无需为每一种类型都重写一次代码。这大大提高了代码的可重用性和灵活性。 1. 什么是 template <typename T>？这是一个模板声明，它告诉编译器接下来的代码（无论是函数还是类）是一个“蓝图”或“模板”，而不是一个具体的实现。 template: C++ 的关键字，表示这是一个模板。 <...>: 尖括号内是模板参数列表。 typename: 关键字，用来声明后面的标识符是一个类型参数。在模板参数列表中，typename 和 class 关键字是等价的，可以互换使用。但通常推荐使用 typename，因为它更明确地表示 T 是一个类型名称。 T: 这是一个模板参数，它是一个占位符，代表一个尚未确定的数据类型。你可以使用任何合法的标识符来代替 T（例如 U, MyType 等），但 T 是最常用的惯例。当你在代码中使用这个模板时（比如 max<int>(a,...

2025-12-06

[数据结构·C++语法] string 成员函数详解

C++ std::string 成员函数详解std::string 是 C++ 标准库中用于处理字符串的类。它提供了丰富的成员函数，使其操作既方便又高效。本文档整理了 std::string 的常用成员函数，并提供了使用实例。 1. 构造函数 (Constructors)用于创建 std::string 对象。默认构造函数创建一个空字符串。12345678#include <iostream>#include <string>int main() { std::string s; std::cout << "空字符串: \"" << s << "\"" << std::endl; return 0;} 拷贝构造函数用一个已有的 std::string 对象创建新对象。 123456789#include <iostream>#include <string>int main()...

2025-12-06

[数据结构·C++语法] 常见序列容器对比

简介在 C++ STL (标准模板库) 中，序列容器（Sequence Containers）是这样一类容器，它们中的元素都按严格的线性顺序排列。每个元素都有其固定的位置，你可以访问“第一个”元素、“最后一个”元素或“第n个”元素。最常见的序列容器包括： std::vector std::deque std::list std::array (C++11) std::forward_list (C++11) std::string (专门的字符序列容器) 下面我们将详细介绍前五个通用容器，并简要对比 std::string。 1. std::vector头文件: <vector>底层实现: 动态数组（连续内存）。 vector 是 C++ 中最常用、最灵活的序列容器。它将元素存储在一段连续的内存中，这使得它具有极高的随机访问（通过索引 []）性能。核心特点: 优点: 随机访问速度最快 (O(1))。尾部插入/删除速度快（均摊 O(1)）。缺点: 在中间或头部插入/删除元素非常慢 (O(n))，因为它需要移动之后的所有元素。内存:...

2025-12-06

[数据结构·C++语法] 处理未知长度或多组数据

针对你在期末考试或 LeetCode 刷题中遇到的“未知长度多组数据录入”的情况，C++ 有几种标准的处理模式。 C++ 处理未知长度/多组数据录入的常用模板在数据结构考试或算法题（OJ/LeetCode）中，通常没有明确告诉你“一共有多少个数字”，而是说“直到输入结束”或“输入为0时停止”。以下是标准解决方案： 1. 利用 cin 的返回值 (C++ 标准写法)cin >> x 表达式在 C++ 中会返回输入流对象本身。在 while 循环条件中，它会被隐式转换为 bool 类型。如果读取成功，返回 true。如果遇到 EOF (End Of File) 或格式错误，返回 false。场景 A：每次读取一个数123456789101112int x;// 当输入流没有结束时，循环继续while (cin >> x) { // 处理 x，例如插入链表 process(x); }````### 场景 B：每次读取两个数 (常见于图论边的输入)C++ int a, b;// 只有当 a 和 b...

2025-12-06

[数据结构·C++语法] cout 使用方法详解

std::cout 是 C++ I/O 流库中用于标准输出（通常是控制台/终端）的对象。要使用它，必须包含 <iostream> 头文件。 C++ std::cout 使用方法详解1. 基础：包含头文件和命名空间在使用 cout 之前，必须包含 <iostream> 头文件。cout 位于 std 命名空间中。 123456789101112131415161718#include <iostream>int main() { // 必须使用 std:: 前缀 std::cout << "Hello, world!" << std::endl; // 或者使用 using 声明 using std::cout; using std::endl; cout << "Hello again!" << endl; // 或者使用 using namespace...

B. 检查文件是否打开成功 (必须)

C. 文件打开模式 (File Modes)

D. 关闭文件

3. 常见用法 1: 文本文件 I/O (Text I/O)

A. 写入文本文件 (使用 <<)

B. 读取文本文件 (使用 >> 和 getline)

4. 常见用法 2: 二进制文件 I/O (Binary I/O)

A. 关键函数 (write / read)

B. 实例：保存和读取结构体

5. 重要陷阱与注意事项

A. 写入文本文件 (使用 `<<`)

B. 读取文本文件 (使用 `>>` 和 `getline`)

A. 关键函数 (`write` / `read`)