fstream

Header: <fstream>

The <fstream> header is part of the C++ Standard Library that provides classes for file input and output operations. It extends the functionality of <iostream> to work with files, allowing programs to read from and write to files on the disk.

Key Characteristics

• Defines three main classes: ifstream (input file stream), ofstream (output file stream), and fstream (input/output file stream)
• Inherits from istream, ostream, and iostream respectively
• Supports both text and binary file operations
• Provides methods for opening, closing, reading from, and writing to files
• Allows for file positioning and status checking
• Compatible with <iostream> manipulators for formatting

Example 1: Writing to a Text File

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

int main() {
    std::ofstream outFile("example.txt");

    if (outFile.is_open()) {
        outFile << "Hello, File!" << std::endl;
        outFile << "This is a test of file output." << std::endl;
        outFile << "Numbers can be written too: " << 42 << std::endl;

        outFile.close();
        std::cout << "File written successfully." << std::endl;
    } else {
        std::cerr << "Unable to open file for writing." << std::endl;
    }

    return 0;
}

Explanation

• Creates an ofstream object to write to a file named "example.txt"
• Uses the << operator to write strings and numbers to the file
• Demonstrates checking if the file is open before writing
• Shows proper file closure after writing
• Illustrates error handling if the file cannot be opened

Example 2: Reading from a Text File

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

int main() {
    std::ifstream inFile("example.txt");
    std::string line;

    if (inFile.is_open()) {
        while (std::getline(inFile, line)) {
            std::cout << line << std::endl;
        }
        inFile.close();
    } else {
        std::cerr << "Unable to open file for reading." << std::endl;
    }

    return 0;
}

Explanation

• Creates an ifstream object to read from "example.txt"
• Uses std::getline() to read the file line by line
• Demonstrates a while loop to process the entire file
• Shows how to output each line to the console
• Illustrates proper file closure after reading

Example 3: Binary File Operations

#include <fstream>
#include <iostream>
#include <vector>

struct Person {
    char name[50];
    int age;
};

int main() {
    // Writing binary data
    std::vector<Person> people = {
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };

    std::ofstream outFile("people.bin", std::ios::binary);
    if (outFile.is_open()) {
        for (const auto& person : people) {
            outFile.write(reinterpret_cast<const char*>(&person), sizeof(Person));
        }
        outFile.close();
        std::cout << "Binary data written successfully." << std::endl;
    }

    // Reading binary data
    std::ifstream inFile("people.bin", std::ios::binary);
    if (inFile.is_open()) {
        Person person;
        while (inFile.read(reinterpret_cast<char*>(&person), sizeof(Person))) {
            std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
        }
        inFile.close();
    }

    return 0;
}

Explanation

• Demonstrates writing and reading binary data using fstream
• Uses std::ios::binary flag to open files in binary mode
• Shows how to write structured data (Person objects) to a binary file
• Illustrates reading binary data back into structured objects
• Uses write() and read() methods for binary I/O operations

Additional Notes

• The <fstream> header automatically includes <istream> and <ostream>
• File streams support seeking operations using seekg() (for input) and seekp() (for output)
• Error handling can be enhanced using the fail(), bad(), and eof() methods
• For large file operations, consider using buffering techniques or memory-mapped files

Summary

The <fstream> header in C++ provides powerful tools for file input and output operations. It defines three main classes: ifstream for reading files, ofstream for writing files, and fstream for both reading and writing. These classes inherit from the corresponding iostream classes, allowing for seamless integration with existing I/O operations and manipulators.

The examples provided demonstrate key aspects of using <fstream>: 1. Writing text data to a file, showcasing basic file output operations. 2. Reading text data from a file, illustrating file input and line-by-line processing. 3. Performing binary file I/O, demonstrating how to work with structured data in binary format.

File I/O is a crucial aspect of many C++ applications, enabling data persistence, configuration storage, and processing of large datasets. The <fstream> library provides a flexible and efficient means to interact with files, supporting both text and binary modes.

Effective use of <fstream> requires understanding file opening modes, error checking, and proper file management (opening and closing). It's also important to consider performance implications when working with large files or performing frequent I/O operations.

For C++ developers, mastering file I/O using <fstream> is essential for creating robust applications that can interact with the file system, process data files, and implement persistent storage solutions. Whether dealing with simple text files or complex binary data structures, <fstream> provides the necessary tools for efficient and reliable file operations.