File Handling

Introduction

In the previous lesson, you learned about exception handling. So far, most of the data used in our programs has been stored temporarily in memory.

Consider a variable such as int marks = 90. While the program is running, the value exists in memory. When the program terminates, that variable no longer exists.

int marks = 90;

std::cout << marks;

For small learning programs, temporary data is often enough. Real applications, however, usually need information to remain available after the program closes.

What is File Handling?

File handling is the process of creating, opening, reading, writing, updating, and managing data stored in files.

Unlike ordinary local variables, file contents can remain available after a program terminates because the data is stored on persistent storage.

Program
   │
   ├── Write ─────► File
   │
   └── Read ◄───── File

Why Do We Need File Handling?

Programs often need data to survive beyond a single execution. Without persistent storage, users would need to recreate the same information every time an application starts.

Real-World Analogy

Imagine writing information on a whiteboard. The information is useful while it remains on the board, but it can easily disappear when the board is erased.

Now imagine writing the same information in a notebook. You can close the notebook, keep it safely, and open it again later to read the same information.

File Streams in C++

C++ performs file input and output through streams. The standard <fstream> header provides the main file stream classes.

#include <fstream>

Reading:

File ─────────► Program
       ifstream


Writing:

Program ───────► File
       ofstream


Reading + Writing:

Program ◄──────► File
        fstream

Opening a File

Before reading or writing file data, a program needs a file stream associated with the target file.

One approach is to create the stream object first and then call its open() member function.

#include <fstream>

std::ofstream file;

file.open("student.txt");

Another common approach is to provide the file name directly when constructing the stream object.

std::ofstream file(
    "student.txt"
);

Example 1: Writing to a File

The following program creates an output file stream and writes text to a file.

#include <iostream>
#include <fstream>

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

    if (!file)
    {
        std::cout
            << "Unable to open file";

        return 1;
    }

    file << "Rahul";

    file.close();

    return 0;
}

Program
   │
   ▼
std::ofstream
   │
   ▼
student.txt
   │
   ▼
Write "Rahul"

Rahul

Example 2: Reading from a File

The std::ifstream class is commonly used to read data from a file.

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

int main()
{
    std::ifstream file(
        "student.txt"
    );

    if (!file)
    {
        std::cout
            << "Unable to open file";

        return 1;
    }

    std::string name;

    file >> name;

    std::cout << name;

    file.close();

    return 0;
}

student.txt
     │
     ▼
 std::ifstream
     │
     ▼
std::string name
     │
     ▼
Console Output

Rahul

Example 3: Writing and Reading Multiple Lines

Files often contain multiple records or lines. The following program first writes several names and then reads them back line by line.

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

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

    if (!outFile)
    {
        std::cout
            << "Unable to open file";

        return 1;
    }

    outFile << "Rahul\n";
    outFile << "Amit\n";
    outFile << "Priya\n";

    outFile.close();

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

    if (!inFile)
    {
        std::cout
            << "Unable to open file";

        return 1;
    }

    std::string line;

    while (std::getline(inFile, line))
    {
        std::cout
            << line
            << '\n';
    }

    inFile.close();

    return 0;
}

Rahul
Amit
Priya

Rahul
Amit
Priya

Appending Data

Sometimes existing file content must be preserved while new information is added at the end. C++ provides append mode for this purpose.

std::ofstream file(
    "student.txt",
    std::ios::app
);

#include <iostream>
#include <fstream>

int main()
{
    std::ofstream file(
        "student.txt",
        std::ios::app
    );

    if (!file)
    {
        std::cout
            << "Unable to open file";

        return 1;
    }

    file << "Suresh\n";

    file.close();

    return 0;
}

Rahul
Amit
Priya

Rahul
Amit
Priya
Suresh

File Opening Modes

File opening modes control how a stream interacts with a file.

std::fstream file(
    "data.txt",
    std::ios::in
);

std::fstream file(
    "data.txt",
    std::ios::out
);

std::fstream file(
    "data.txt",
    std::ios::in |
    std::ios::out
);

std::ifstream file(
    "image.bin",
    std::ios::binary
);

Checking File Status

A program should verify that a file operation is ready to proceed before depending on the stream.

std::ifstream file(
    "student.txt"
);

if (file.is_open())
{
    std::cout
        << "File opened successfully";
}
else
{
    std::cout
        << "Unable to open file";
}

A stream can also be tested directly in a condition.

std::ifstream file(
    "student.txt"
);

if (!file)
{
    std::cout
        << "Unable to open file";

    return 1;
}

Program Execution Flow

A typical file-handling program follows a sequence of creating a stream, opening or associating it with a file, validating the stream, performing operations, and finishing safely.

Program Starts
      │
      ▼
Create Stream Object
      │
      ▼
Open File
      │
      ▼
Opening Successful?
   ┌──┴──┐
   │     │
  No    Yes
   │     │
   ▼     ▼
Handle   Read / Write
Failure      │
             ▼
        Check Operation
             │
             ▼
        Finish Stream Use
             │
             ▼
         Program Ends

Memory vs File Storage

Runtime memory and file storage serve different purposes. Variables are useful for active computation, while files are useful when data must remain available later.

Runtime Memory
┌────────────────────┐
│ marks = 90         │
│ name = "Rahul"     │
└────────────────────┘
          │
          │ Program Ends
          ▼
   Runtime Data Gone


Persistent File
┌────────────────────┐
│ student.txt        │
│                    │
│ Rahul              │
│ Amit               │
│ Priya              │
└────────────────────┘
          │
          │ Program Ends
          ▼
   File Remains

Real-World Applications

File handling is used whenever applications need to preserve, exchange, import, export, or log information.

Advantages of File Handling

Common Beginner Mistakes

// ❌ Missing:
// #include <fstream>

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

// ❌ Risky
std::ifstream file(
    "missing.txt"
);

std::string data;
file >> data;

// ✅ Better
std::ifstream file(
    "data.txt"
);

if (!file)
{
    std::cout
        << "Unable to open file";

    return 1;
}

// ❌ Avoid
while (!file.eof())
{
    std::getline(file, line);

    std::cout << line;
}

// ✅ Better
while (std::getline(file, line))
{
    std::cout
        << line
        << '\n';
}

Best Practices

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

int main()
{
    std::ifstream file(
        "student.txt"
    );

    if (!file)
    {
        std::cerr
            << "Unable to open file";

        return 1;
    }

    std::string line;

    while (std::getline(file, line))
    {
        std::cout
            << line
            << '\n';
    }

    if (!file.eof())
    {
        std::cerr
            << "File reading failed";

        return 1;
    }

    return 0;
}

Frequently Asked Questions

Key Takeaways

Summary

File handling allows C++ programs to store information beyond a single program execution and retrieve that information later.

The <fstream> header provides std::ifstream for input, std::ofstream for output, and std::fstream for combined input and output operations.

A stream can be associated with a file through its constructor or the open() member function. Before depending on a file operation, programs should verify that the stream is in an appropriate state.

The insertion operator writes formatted data, while the extraction operator reads formatted input. When complete lines are required, std::getline() is usually the better choice.

Opening modes determine how files are accessed. Append mode preserves existing content and writes new output at the end, while truncating behavior replaces previous content.

A successful file opening does not guarantee that every later read or write will succeed. Robust programs consider stream state throughout important file operations.

Standard file streams use RAII, so their associated files are closed automatically when the stream objects are destroyed. Explicit close() remains useful when a file must be released before the end of the stream object lifetime.

Files are used for saved application state, logs, reports, configuration, import and export, and many other persistent data requirements.

By understanding file streams, opening methods, reading, writing, appending, stream states, opening modes, and safe reading patterns, you now have the foundation required to build C++ programs that preserve and retrieve information.

You have now completed the current 30-lesson C++ programming course, covering the journey from programming fundamentals to functions, arrays, pointers, object-oriented programming, templates, namespaces, exception handling, and persistent file storage.