Understanding File Handling in C++, With Examples

Computers provide us with a lot of ways to handle files and manipulate data. But when you reprogramming, you often want a finer level of control and customization over your files. And when you re working with large amounts ofdata, some programs can introduce unnecessary overheads and impair performance. These are situations where you may need a more robust technique, especially if you re developing a program. In this article, we re going to explore the elements involved in file handling inC++, including the operations used and best practices.

What Is File Handling in C++?

You may guess that file handling refers to the process involved in managing, creating, reading, and writing files, and you d be absolutely right. As such, file handling in C++ is where we use the programming language to manipulate our files of data. This is usually preferable when developing a C++ project and vast amounts of data, as we can work quickly in the same language we re developing in. C++ provides us with a lot of classes that can be used for handling files. We ll get into the basics behind these next.

Classes for File Handling

The main classes used for handling files in C++ are ifstream, ofstream, and fstream. Usually, when we re working with C++, we import the iostream header file, as this is needed for all standard input/output operations. However, when we want to manage files, we go one step further and import the fstream class as well. This provides us with specific classes to manipulate files effectively. We ve summarized the class hierarchy and class functions in the following table:

File Handling Operations

There s a brief overview of the operations involved in the previous table, but the following provides some more detail on how these work.

Example of Operations

Now that we ve gone over the basic operations and classes involved in file handling, let s illustrate some of them with an example. Consider this code block:

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

int main() {
    std::ofstream file("data.txt");

    if (file.is_open()) {
        std::string message = "Hello, World!";
        int number = 42;

        file.precision(2);
        file.width(10);

        file.tie(&std::cout);

        file << "Message: " << message << std::endl;
        file << "Number: " << number << std::endl;

        file.flush();

        if (file.good()) {
            std::cout << "File write operation was successful." << std::endl;
        } else {
            std::cout << "File write operation failed." << std::endl;
        }

        file.close();
    } else {
        std::cout << "Failed to open the file." << std::endl;
        return 1;
    }

    std::ifstream inputFile("data.txt");

    if (inputFile.is_open()) {
        char character;
        std::string line;

        character = inputFile.get();
        std::cout << "Character: " << character << std::endl;

        inputFile.clear();

        inputFile.ignore(4);
        character = inputFile.get();
        std::cout << "Next Character: " << character << std::endl;

        inputFile.seekg(0);
        character = inputFile.peek();
        std::cout << "Peeked Character: " << character << std::endl;

        inputFile.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::getline(inputFile, line);
        std::cout << "Line: " << line << std::endl;

        inputFile.close();
    } else {
        std::cout << "Failed to open the file for reading." << std::endl;
        return 1;
    }

    return 0;
}

Explanation of Code

First, we import the necessary modules iostream for input/output operations, fstream for file operations, and string for manipulating strings.

Opening the File, and Declaring Variables

Next, we declare the main() method, which declares an object called file , and opens a truncated file called data.txt in write mode. We then check if the file was opened successfully using is_open() .

After this, we declare the message string variable, assigning the Hello, World! value to it, and the number integer variable, assigning the value of 42. We also set the decimal values to 2 using precision() and the width to 10 using width() .

tie() is then used to synchronize the file stream with the std::cout stream, meaning that when we write to file , we also write to std::cout .

Writing the Message

The << is used after that to write the message and number to the file. The output buffer is then flushed to make sure the data is written.

A check is then performed to make sure the state of the file is good and the operation was finished successfully. The message is also printed to indicate this, and the file is closed.

We then declare a new object of the std::fstream stream, called inputFile . We also open this file in read mode. The opening of the file is checked. The character and line variables are also declared.

Reading and Printing

get() is used to read a single character from the file, which is stored in the character variable and printed. Any potential error flags are also cleared using the clear() method.

The next 4 characters are ignored using ignore() , and then the next character is printed using get() .

After this, the position is moved to the beginning of the file with seekg() and the next character is printed using peek() . All remaining characters are then ignored until a newline is reached, and getline() is used to read the entire line, which is stored in the line variable and printed.

Lastly, the file is closed. The output can be seen in the accompanying image.

Wrapping Up

There are many operations involved with file handling in C++. By understanding these, you can read and write files efficiently, as well as process files line by line and store data persistently. It s important to check the file state and return error codes to handle any issues that arise effectively. Gaining an appreciation for file handling will also help you integrate your data with other systems, making it more robust.