C++文件流：通过ofstream和ifstream轻松实现文件读写

一、简介

C++文件流是用于进行文件读写操作的工具，它提供了一种能够简单、高效地与外部文件进行交互的方式。C++中文件流主要通过ofstream和ifstream来实现对文件的写入和读取。

• ofstream（output file stream）用于写入文件，可以创建、打开并写入文件内容。
• ifstream（input file stream）用于读取文件内容，可以打开并读取文件中的数据。

文件流操作可以是文本模式的，也可以是二进制模式的，允许以不同的方式对文件进行读取和写入。

C++文件流提供了许多用于处理文件的功能和方法，包括打开文件、读写文件内容、关闭文件等。为了保证文件流的正确使用，需要对文件操作过程中可能出现的错误进行处理。

二、开始使用ofstream进行文件写入

创建一个ofstream对象来打开和写入文件：

1. 包含必要的头文件：

   #include <fstream>
   

2. 创建ofstream对象：

   std::ofstream outputFile;
   

3. 打开文件并写入内容：

   outputFile.open("example.txt"); // 打开名为example.txt的文件进行写入
   
   if (outputFile.is_open()) {
       outputFile << "Hello, World!" << std::endl; // 将字符串写入文件
       outputFile << "This is a sample text." << std::endl;
   } else {
       std::cout << "Failed to open the file." << std::endl; // 如果文件打开失败，输出错误信息
   }
   
   outputFile.close(); // 关闭文件流
   

在文件成功打开后，可以使用流插入运算符（<<）来向文件中写入内容。最后，记得使用close()函数关闭文件流，释放资源并确保文件操作的完成。这样就完成了创建ofstream对象并进行文件写入的操作。

下面是ofstream类的主要成员函数：

成员函数	描述	参数
open()	打开文件	const char* filename, ios_base::openmode mode
close()	关闭文件	无
is_open()	检查文件是否已经成功打开	无
good()	检查文件流是否处于一个有效状态	无
bad()	检查文件流是否处于一个错误状态	无
operator<<	将数据写入到文件流中	int, char, string等不同类型的数据
tellp()	返回当前文件指针的位置（写入位置）	无
seekp()	设置写入位置	streamoff off, ios_base::seekdir way
flush()	刷新输出缓冲区	无
rdbuf()	获取缓冲区指针	无

其中，ios_base::openmode是一个枚举类型，用于指定文件打开模式，包括out（写入）、app（追加）、trunc（截断并写入）、ate（打开文件后立即定位到文件末尾）。

除了上述成员函数外，ofstream还可以使用继承自ostream的其他成员函数，包括setf、unsetf、width 等用于设置标志和格式控制。

ofstream 类是用于将数据写入文件的输出流类。它继承自ostream类，因此具有ostream类的所有成员函数，同时也具有一些自己特有的成员函数。

1. open()：打开文件，参数包括文件名和打开模式。

   ofstream outputFile;
   outputFile.open("example.txt");
   

2. close()：关闭打开的文件。

   outputFile.close();
   

3. is_open()：检查文件是否成功打开。

   if (outputFile.is_open()) {
       // 文件已经成功打开
   } else {
       // 文件打开失败
   }
   

4. good()：检查文件流是否处于一个有效状态。

   if (outputFile.good()) {
       // 文件流处于有效状态
   } else {
       // 文件流不处于有效状态
   }
   

5. bad()：检查文件流是否处于一个错误状态。

   if (outputFile.bad()) {
       // 文件流处于错误状态
   } else {
       // 文件流未处于错误状态
   }
   

三、使用ifstream进行文件读取

创建一个ifstream对象来打开和读取文件：

1. 包含必要的头文件：

   #include <fstream>
   

2. 创建ifstream对象：

   std::ifstream inputFile;
   

3. 打开文件并读取内容：

   inputFile.open("example.txt"); // 打开名为example.txt的文件进行读取
   
   if (inputFile.is_open()) {
       std::string line;
       while (std::getline(inputFile, line)) {
           std::cout << line << std::endl; // 输出文件中的每一行内容
       }
   } else {
       std::cout << "Failed to open the file." << std::endl; // 如果文件无法打开，输出错误信息
   }
   
   inputFile.close(); // 关闭文件流
   

通过循环使用getline()函数逐行读取文件内容，并输出到控制台上。最后，别忘了使用close()函数关闭文件流，以确保读取完成。

下面是ifstream类的主要成员函数以及它们的描述和参数：

成员函数	描述	参数
open()	打开文件	const char* filename, ios_base::openmode mode
close()	关闭文件	无
is_open()	检查文件是否已经成功打开	无
good()	检查文件流是否处于一个有效状态	无
bad()	检查文件流是否处于一个错误状态	无
operator>>	从文件流中读取数据	int, char, string等不同类型的数据
tellg()	返回当前文件指针的位置（读取位置）	无
seekg()	设置读取位置	streamoff off, ios_base::seekdir way
peek()	查看下一个字符，但不提取它	无
ignore()	忽略一定数量的字符	streamsize n = 1, int_type delim = Traits::eof()

其中，ios_base::openmode 是一个枚举类型，用于指定文件打开模式，包括 in（读取）、binary（二进制模式）等。

四、文件的打开模式

模式	描述
in	以输入方式打开文件，允许读取文件内容。
out	以输出方式打开文件，允许写入文件内容。如果文件不存在，则创建新文件；如果文件已存在，则将其长度截为0。
app	在文件末尾附加内容，允许写入文件；如果文件不存在，则创建新文件。
ate	打开文件后立即定位到文件末尾。
trunc	如果文件已存在，则将截断文件长度为0（清空文件）。
binary	以二进制方式打开文件，而非文本模式。文件内容将以二进制格式进行读取和写入，而不是以文本格式。

通过组合不同的打开模式选项，可以实现对文件的不同方式打开，包括读取、写入、追加和二进制模式的操作。

不同场景下选择打开模式的方法：

1. 读取文件：

   • 如果只需要读取文件的内容，应该选择“in”模式，以输入方式打开文件。
   • 如果希望以二进制方式读取文件内容，可以选择“in | binary”模式。

2. 写入文件：

   • 如果希望创建新文件并写入内容，应该选择“out”模式，以输出方式打开文件。
   • 如果文件已存在，且希望覆盖原有内容，可以选择“out”模式。
   • 如果希望在文件末尾追加内容，可以选择“app”模式。

3. 二进制文件操作：

   • 如果需要以二进制方式对文件进行读写，应该选择“binary”模式。
   • 当进行二进制文件操作时，可以考虑使用“in | binary”或“out | binary”模式，具体取决于是读取还是写入操作。

4. 确保文件安全性：

   • 如果需要在写入文件内容之前清空文件内容，可以选择“out | trunc”模式，以确保在写入之前文件已被清空。
   • 在追加内容之前，可以选择“app”模式，以确保在文件末尾追加内容。

五、错误处理

5.1、处理文件打开和读写过程中可能发生的错误

通过检查文件流的状态以及使用异常处理来处理文件打开和读写过程中可能发生的错误。

1. 检查流的状态：在打开文件或进行读写操作之后，使用流的成员函数来检查文件流的状态。常用的函数包括good()、bad()、fail()和eof()等。通过检查这些状态来确定文件操作是否成功，并根据需要采取相应的操作。

2. 使用异常处理：C++的异常处理机制可以用于捕获和处理文件操作中的错误。通过在文件操作代码块中使用try-catch语句，可以捕获可能发生的异常，例如文件打开失败、读写错误等，并进行相应的处理或报告错误信息。

示例：

#include <iostream>
#include <fstream>

int main() {
    std::ofstream outputFile("example.txt");
    
    try {
        if (!outputFile) {
            throw "File opening failed.";
        }
        
        outputFile << "Hello, World!";
        
        if (outputFile.fail()) {
            throw "Writing to file failed.";
        }
        
        outputFile.close();
    } catch (const char* errorMessage) {
        std::cerr << "Error: " << errorMessage << std::endl;
    }

    return 0;
}

通过检查文件流的状态和使用异常处理，可以有效地处理文件打开和读写过程中可能发生的错误，从而确保文件操作的稳定性和安全性。

5.2、使用流的状态来检测和处理错误

C++的流类提供了几个成员函数来获取流的状态，并且可以通过这些状态来检测和处理错误。这些状态标志通常以成员函数的返回值形式表示。

用于检测和处理流状态的成员函数：

1. good()：检查流是否处于有效状态，即未发生任何错误。返回true表示流处于有效状态。

2. bad()：检查流是否处于错误状态。返回true表示流处于错误状态。

3. fail()：检查流是否处于失败状态，可能是由于输入/输出操作失败，但并非致命错误。返回true表示流处于失败状态。

4. eof()：检查是否已经达到文件的末尾（end-of-file）。返回true表示已经达到文件末尾。

这些状态标志可以帮助我们确定文件读写过程中出现的具体错误，并做出相应的处理。例如，在读取文件时，可以检查eof()状态来确定是否已经读到文件末尾；在写入文件时，可以检查fail()状态来确定是否写入失败等。

示例：

#include <iostream>
#include <fstream>

int main() {
    std::ifstream inputFile("example.txt");
    
    if (!inputFile.good()) {
        std::cerr << "Error: Failed to open the file." << std::endl;
        return 1;
    }

    std::string data;
    while (inputFile >> data) {
        if (inputFile.fail()) {
            std::cerr << "Error: Failed to read from the file." << std::endl;
            break;
        }
        std::cout << data << " ";
    }

    inputFile.close();

    if (inputFile.bad()) {
        std::cerr << "Error: An unrecoverable error occurred while reading the file." << std::endl;
        return 1;
    }

    return 0;
}

六、二进制文件操作

使用二进制模式来读写文件在C++中是很常见的。二进制模式适用于处理非文本文件，如图像、音频、视频等内容。在二进制模式下，文件的内容以其原始的字节形式进行读写，而不会对内容进行解释或转换。

1. 以二进制模式打开文件：使用 ofstream 或 ifstream 对象，并在 open() 函数中指定 binary 模式。

   std::ofstream outputFile("example.bin", std::ios::out | std::ios::binary);
   std::ifstream inputFile("example.bin", std::ios::in | std::ios::binary);
   

2. 写入数据到二进制文件：使用 write() 函数向文件中写入二进制数据。write() 函数的参数包括一个指向要写入的数据的指针和数据的长度。

   int data[] = {1, 2, 3, 4, 5};
   outputFile.write(reinterpret_cast<char*>(&data), sizeof(data));
   

3. 从二进制文件中读取数据：使用 read() 函数从文件中读取二进制数据。read() 函数的参数包括一个指向要读取数据的指针和数据的长度。

   int data[5];
   inputFile.read(reinterpret_cast<char*>(&data), sizeof(data));
   

4. 关闭文件流：使用 close() 函数关闭文件流，确保数据写入或读取完成。

   outputFile.close();
   inputFile.close();
   

注意：使用二进制模式读写文件需要对数据的存储和大小有一个清晰的认识，确保正确地读取和写入数据。同时，在处理二进制数据时，需要注意避免出现类型转换错误，确保对二进制数据的处理是正确的。

示例：

#include <iostream>
#include <fstream>

struct Data {
    int id;
    double value;
};

int main() {
    // 写入二进制数据
    std::ofstream outputFile("example.bin", std::ios::out | std::ios::binary);
    
    if(outputFile.is_open()) {
        Data data1 = {1, 3.14};
        Data data2 = {2, 6.28};
        
        // 将数据写入二进制文件
        outputFile.write(reinterpret_cast<char*>(&data1), sizeof(data1));
        outputFile.write(reinterpret_cast<char*>(&data2), sizeof(data2));
        
        outputFile.close();
    } else {
        std::cerr << "Failed to open the file for writing." << std::endl;
        return 1; 
    }
    
    // 读取二进制数据
    std::ifstream inputFile("example.bin", std::ios::in | std::ios::binary);
  
    if(inputFile.is_open()) {
        Data data1, data2;
        
        // 从文件中读取二进制数据
        inputFile.read(reinterpret_cast<char*>(&data1), sizeof(data1));
        inputFile.read(reinterpret_cast<char*>(&data2), sizeof(data2));
        
        // 输出读取的数据
        std::cout << "Data 1: " << data1.id << " " << data1.value << std::endl;
        std::cout << "Data 2: " << data2.id << " " << data2.value << std::endl;
        
        inputFile.close();
    } else {
        std::cerr << "Failed to open the file for reading." << std::endl;
        return 1;
    }

    return 0;
}

七、综合示例

使用ofstream和ifstream来进行文件读写，包括文本文件和二进制文件的操作。

#include <iostream>
#include <fstream>

// 结构体用于存储二进制文件数据
struct Data {
    int id;
    double value;
};

int main() {
    // 写入文本文件
    std::ofstream textOutputFile("textfile.txt");
    
    if(textOutputFile.is_open()) {
        textOutputFile << "This is a text file." << std::endl;
        textOutputFile << "It is used to demonstrate text file writing." << std::endl;
        
        textOutputFile.close();
    } else {
        std::cerr << "Failed to open the text file for writing." << std::endl;
        return 1; 
    }

    // 读取文本文件
    std::ifstream textInputFile("textfile.txt");
  
    if(textInputFile.is_open()) {
        std::string line;
        
        while (std::getline(textInputFile, line)) {
            std::cout << line << std::endl;
        }
        
        textInputFile.close();
    } else {
        std::cerr << "Failed to open the text file for reading." << std::endl;
        return 1;
    }

    // 写入二进制文件
    std::ofstream binaryOutputFile("binaryfile.bin", std::ios::out | std::ios::binary);
    
    if(binaryOutputFile.is_open()) {
        Data data1 = {1, 3.14};
        Data data2 = {2, 6.28};
        
        binaryOutputFile.write(reinterpret_cast<char*>(&data1), sizeof(data1));
        binaryOutputFile.write(reinterpret_cast<char*>(&data2), sizeof(data2));
        
        binaryOutputFile.close();
    } else {
        std::cerr << "Failed to open the binary file for writing." << std::endl;
        return 1; 
    }
    
    // 读取二进制文件
    std::ifstream binaryInputFile("binaryfile.bin", std::ios::in | std::ios::binary);
  
    if(binaryInputFile.is_open()) {
        Data data1, data2;
        
        binaryInputFile.read(reinterpret_cast<char*>(&data1), sizeof(data1));
        binaryInputFile.read(reinterpret_cast<char*>(&data2), sizeof(data2));
        
        std::cout << "Data 1: " << data1.id << " " << data1.value << std::endl;
        std::cout << "Data 2: " << data2.id << " " << data2.value << std::endl;
        
        binaryInputFile.close();
    } else {
        std::cerr << "Failed to open the binary file for reading." << std::endl;
        return 1;
    }

    return 0;
}

八、总结

1. 介绍了 C++ 文件流作为进行文件读写操作的工具，以及 ofstream 和 ifstream 类的基本作用和用法。

2. ofstream 的成员函数：覆盖了 ofstream 类的一些常用成员函数，包括 open()、close()、is_open()、good()、bad()、operator<< 等。这些函数是实现文件写入操作时的关键。

3. 使用流插入运算符（<<）将数据写入文件。

4. 文件的打开模式，包括读取、写入、追加和二进制模式，以及如何在不同情况下选择合适的打开模式的方法。

5. 处理文件打开和读写操作中可能发生的错误，包括使用流的状态来检测错误以及使用异常处理。

6. 使用二进制模式读写文件：介绍了如何使用二进制模式来进行文件读写操作，包括如何以二进制模式打开文件、写入数据到二进制文件、从二进制文件中读取数据等。