C++ File I/O

Writing data to files lets you save information that persists after your program ends. Whether it's configuration settings, logs, or user data, ofstream makes it simple and efficient. Master file writing to create lasting applications that store and manage data beyond program execution.

Understanding File Output

File writing (output) is the process of transferring data from your program's memory to permanent storage on disk. Unlike console output with cout which displays text temporarily on the screen, file writing creates persistent data that survives program termination, system reboots, and can be shared across different applications and platforms.

Basic File Writing

Writing to a file with ofstream (output file stream) is as intuitive as writing to cout. You use the same << insertion operator - the only difference is the destination. The stream handles all formatting, buffering, and low-level I/O operations automatically, allowing you to focus on your data rather than the mechanics of file operations.

#include <fstream>
#include <iostream>

int main() {
    // Create and open a file for writing
    std::ofstream outFile("example.txt");
    
    // Check if file opened successfully
    if (!outFile) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

    // Write to the file (just like cout!)
    outFile << "Hello, File!" << std::endl;
    outFile << "This is line 2." << std::endl;
    outFile << "Number: " << 42 << std::endl;
    outFile << "Pi: " << 3.14159 << std::endl;

    // File automatically closes when outFile goes out of scope
    std::cout << "Data written successfully!" << std::endl;
    
    return 0;
}

After running this program, example.txt will contain:

Hello, File!
This is line 2.
Number: 42
Pi: 3.14159

Appending to Files

Imagine you're maintaining a daily journal file. Each day, you want to add new entries without erasing what you wrote yesterday. Or consider an application log where each program run should add new events without destroying the history. This is where append mode becomes essential - it allows you to add new content to the end of existing files while preserving everything that's already there.

Opening a File in Append Mode

To activate append mode, pass std::ios::app as the second parameter when constructing the ofstream object. This single flag changes the entire behavior from destructive overwriting to safe content preservation.

#include <fstream>
#include <iostream>

int main() {
    // Open file in append mode
    std::ofstream logFile("log.txt", std::ios::app);

    if (!logFile) {
        std::cerr << "Error opening log file!" << std::endl;
        return 1;
    }
    
    // New data is added at the end
    logFile << "[2026-02-03 10:30:00] Application started" << std::endl;
    logFile << "[2026-02-03 10:30:05] User logged in" << std::endl;

    std::cout << "Log entries added!" << std::endl;
    
    return 0;
}

Writing Different Data Types

You can write any data type that works with cout. Let's save structured student data in CSV format.

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

struct Student {
    std::string name;
    int age;
    double gpa;
};

int main() {
    std::vector<Student> students = {
        {"Alice", 20, 3.8},
        {"Bob", 22, 3.5},
        {"Charlie", 21, 3.9}
    };
    
    std::ofstream outFile("students.txt");
    
    if (!outFile) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

    // Write header
    outFile << "Name,Age,GPA" << std::endl;

    // Write each student (CSV format)
    for (const auto& student : students) {
        outFile << student.name << ","
                << student.age << ","
                << student.gpa << std::endl;
    }

    std::cout << "Saved " << students.size() << " students!" << std::endl;
    
    return 0;
}

The output file students.txt will be a CSV file:

Name,Age,GPA
Alice,20,3.8
Bob,22,3.5
Charlie,21,3.9

Reading files allows your program to process external data - configuration files, user data, or any text content. The ifstream class makes file input as easy as reading from cin.

Reading Word by Word

The simplest way to read from a file uses the extraction operator >>. This reads whitespace-separated "words" one at a time, just like cin >>.

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

int main() {
    std::ifstream inFile("example.txt");
    
    if (!inFile) {
        std::cerr << "Error: Cannot open file!" << std::endl;
        return 1;
    }

    std::string word;
    
    // Read word by word until end of file
    while (inFile >> word) {
        std::cout << "Word: " << word << std::endl;
    }

    return 0;
}

Reading Line by Line

Often you need to read entire lines, including spaces. Use std::getline() for this - it reads until it hits a newline character.

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

int main() {
    std::ifstream inFile("example.txt");
    
    if (!inFile) {
        std::cerr << "Error: Cannot open file!" << std::endl;
        return 1;
    }

    std::string line;
    int lineNumber = 1;
    
    // Read line by line
    while (std::getline(inFile, line)) {
        std::cout << lineNumber << ": " << line << std::endl;
        lineNumber++;
    }

    return 0;
}

Reading the Entire File

Sometimes you need the entire file contents as a single string for processing or analysis.

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

int main() {
    std::ifstream inFile("example.txt");
    
    if (!inFile) {
        std::cerr << "Error: Cannot open file!" << std::endl;
        return 1;
    }

    // Method 1: Using stringstream
    std::stringstream buffer;
    buffer << inFile.rdbuf();
    std::string contents = buffer.str();

    std::cout << "File contents:\n" << contents << std::endl;
    
    return 0;
}

Reading Numbers from Files

When your file contains numbers, the extraction operator automatically converts them to the appropriate type.

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

int main() {
    // Assume "numbers.txt" contains: 10 20 30 40 50
    std::ifstream inFile("numbers.txt");
    
    if (!inFile) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

    std::vector<int> numbers;
    int num;
    
    // Read all integers
    while (inFile >> num) {
        numbers.push_back(num);
    }

    // Calculate sum
    int sum = 0;
    for (int n : numbers) {
        sum += n;
    }
    
    std::cout << "Read " << numbers.size() << " numbers" << std::endl;
    std::cout << "Sum: " << sum << std::endl;  // Sum: 150
    
    return 0;
}

Parsing CSV Files

CSV (Comma-Separated Values) files are common for data storage. Let's parse a student database.

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

struct Student {
    std::string name;
    int age;
    double gpa;
};

int main() {
    std::ifstream inFile("students.txt");
    
    if (!inFile) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }
    
    std::vector<Student> students;
    std::string line;

    // Skip header line
    std::getline(inFile, line);

    // Read each data line
    while (std::getline(inFile, line)) {
        std::stringstream ss(line);
        Student student;
        std::string field;

        // Parse comma-separated fields
        std::getline(ss, student.name, ',');
        
        std::getline(ss, field, ',');
        student.age = std::stoi(field);
        
        std::getline(ss, field, ',');
        student.gpa = std::stod(field);

        students.push_back(student);
    }

    // Display loaded data
    std::cout << "Loaded " << students.size() << " students:\n";
    for (const auto& s : students) {
        std::cout << s.name << " (Age: " << s.age 
                  << ", GPA: " << s.gpa << ")\n";
    }
    
    return 0;
}

File modes control how a file is opened - whether to read, write, append, or handle binary data. Understanding these modes gives you precise control over file operations.

Available File Modes

C++ provides several file mode flags that can be combined using the bitwise OR operator (|):

Combining File Modes

You can combine multiple modes using the | operator:

#include <fstream>
#include <iostream>

int main() {
    // Read and write (file must exist)
    std::fstream file1("data.txt", std::ios::in | std::ios::out);
    
    // Write in binary mode, truncate existing
    std::ofstream file2("data.bin", std::ios::out | std::ios::binary | std::ios::trunc);
    
    // Append in binary mode
    std::ofstream file3("log.bin", std::ios::app | std::ios::binary);
    
    // Read and write, create if doesn't exist
    std::fstream file4("new.txt", std::ios::in | std::ios::out | std::ios::trunc);
    
    return 0;
}

Default Modes

Each stream type has sensible defaults, so you often don't need to specify modes explicitly:

Binary file I/O writes data in its raw memory format, making it faster and more space-efficient than text files. It's essential for images, audio, and complex data structures.

Why Use Binary Files?

Text files store everything as human-readable characters. The number 1000000 takes 7 characters (7 bytes). In binary, the same integer takes only 4 bytes. For large datasets, this difference is significant!

Writing Binary Data

Use write() to write raw bytes. It takes a pointer to the data and the number of bytes to write.

#include <fstream>
#include <iostream>

struct Player {
    char name[50];
    int score;
    float playtime;
};

int main() {
    // Open file in binary mode
    std::ofstream outFile("player.dat", std::ios::binary);
    
    if (!outFile) {
        std::cerr << "Error creating file!" << std::endl;
        return 1;
    }

    // Create player data
    Player player;
    strcpy(player.name, "Alice");
    player.score = 9500;
    player.playtime = 45.5f;

    // Write the entire struct as binary
    outFile.write(reinterpret_cast<char*>(&player), sizeof(Player));
    
    std::cout << "Saved player data (" << sizeof(Player) << " bytes)" << std::endl;
    
    return 0;
}

Reading Binary Data

Use read() to read raw bytes back into memory. The struct definition must match exactly.

#include <fstream>
#include <iostream>

struct Player {
    char name[50];
    int score;
    float playtime;
};

int main() {
    std::ifstream inFile("player.dat", std::ios::binary);
    
    if (!inFile) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

    Player player;
    
    // Read the struct from binary file
    inFile.read(reinterpret_cast<char*>(&player), sizeof(Player));

    std::cout << "Name: " << player.name << std::endl;
    std::cout << "Score: " << player.score << std::endl;
    std::cout << "Playtime: " << player.playtime << " hours" << std::endl;
    
    return 0;
}

Working with Arrays

Binary I/O shines when working with arrays of data. Let's save and load a vector of integers.

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

int main() {
    // Write an array of integers
    std::vector<int> numbers = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    
    std::ofstream outFile("numbers.bin", std::ios::binary);

    // Write size first (so we know how many to read back)
    size_t size = numbers.size();
    outFile.write(reinterpret_cast<char*>(&size), sizeof(size));

    // Write all numbers at once
    outFile.write(reinterpret_cast<char*>(numbers.data()), 
                  size * sizeof(int));
    outFile.close();

    // Read them back
    std::ifstream inFile("numbers.bin", std::ios::binary);
    
    // Read size
    size_t readSize;
    inFile.read(reinterpret_cast<char*>(&readSize), sizeof(readSize));

    // Read all numbers
    std::vector<int> loaded(readSize);
    inFile.read(reinterpret_cast<char*>(loaded.data()), 
                readSize * sizeof(int));

    // Verify
    std::cout << "Loaded " << loaded.size() << " numbers: ";
    for (int n : loaded) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

File streams maintain a position pointer that tracks where the next read or write will occur. Seeking allows you to move this pointer to any location, enabling random access to file data.

Understanding File Pointers

Every file stream maintains two internal position indicators:

Seek Functions

C++ provides four functions for manipulating file positions:

Seek Directions

You can seek relative to three reference points. Let's explore each direction with practical examples.

#include <fstream>
#include <iostream>

int main() {
    std::fstream file("data.txt", std::ios::in | std::ios::out | std::ios::binary);
    
    if (!file) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

    // std::ios::beg - Beginning of file (default)
    file.seekg(10, std::ios::beg);  // Move to byte 10 from start

    // std::ios::cur - Current position
    file.seekg(5, std::ios::cur);   // Move forward 5 bytes from current
    file.seekg(-3, std::ios::cur);  // Move back 3 bytes from current

    // std::ios::end - End of file
    file.seekg(-10, std::ios::end); // Move to 10 bytes before end
    file.seekg(0, std::ios::end);   // Move to end of file
    
    return 0;
}

Getting File Size

A common use of seeking is determining file size. Let's explore how to use file positioning to calculate the size of a file without reading its contents.

#include <fstream>
#include <iostream>

int main() {
    std::ifstream file("data.txt", std::ios::binary);
    
    if (!file) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

    // Seek to end of file
    file.seekg(0, std::ios::end);

    // Get position (which is the file size)
    std::streampos fileSize = file.tellg();
    
    std::cout << "File size: " << fileSize << " bytes" << std::endl;

    // Go back to beginning
    file.seekg(0, std::ios::beg);
    
    return 0;
}

Random Access to Records

File positioning enables random access to structured data, like accessing specific records in a database. Let's build a system that can read any employee record without reading the entire file.

First, define a fixed-size structure to represent each employee record. Fixed sizes are crucial for calculating positions:

#include <fstream>
#include <iostream>
#include <cstring>

struct Record {
    int id;
    char name[50];
    double salary;
};
// Each Record is sizeof(Record) bytes (typically 64 bytes)

This structure has a predictable size, making it perfect for random access. Every record occupies the same amount of space in the file.

Create a binary file with several employee records:

int main() {
    // Open file for binary writing
    std::ofstream outFile("records.dat", std::ios::binary);
    
    // Create sample employee data
    Record employees[] = {
        {101, "Alice", 75000.0},
        {102, "Bob", 68000.0},
        {103, "Charlie", 82000.0},
        {104, "Diana", 71000.0}
    };
    
    // Write all records to file
    for (const auto& emp : employees) {
        outFile.write(reinterpret_cast<const char*>(&emp), sizeof(Record));
    }
    outFile.close();

This writes 4 employee records sequentially. Each record is written as raw binary data, positioned one after another in the file.

Open the file for reading in binary mode:

    // Open file for binary reading
    std::ifstream inFile("records.dat", std::ios::binary);
    
    if (!inFile) {
        std::cerr << "Error opening file!" << std::endl;
        return 1;
    }

Binary mode ensures no data transformation occurs, maintaining the exact byte positions.

To read the 3rd record directly, calculate its byte position:

    int recordNumber = 2; // 0-indexed (3rd record)
    
    // Calculate position: record size * record number
    std::streampos position = recordNumber * sizeof(Record);
    // position = 2 * 64 = 128 bytes from start

Since records are stored sequentially, the 3rd record starts at byte 128 (record 0 at byte 0, record 1 at byte 64, record 2 at byte 128).

Move the file pointer to the calculated position and read the record:

    // Seek to the calculated position
    inFile.seekg(position, std::ios::beg);
    
    // Read the record at that position
    Record emp;
    inFile.read(reinterpret_cast<char*>(&emp), sizeof(Record));

seekg() instantly jumps to byte 128 without reading the first two records. Then read() loads exactly one Record worth of data.

Output the retrieved record:

    std::cout << "Record " << recordNumber + 1 << ":" << std::endl;
    std::cout << "  ID: " << emp.id << std::endl;
    std::cout << "  Name: " << emp.name << std::endl;
    std::cout << "  Salary: $" << emp.salary << std::endl;
    
    return 0;
}

Output:

Record 3:
  ID: 103
  Name: Charlie
  Salary: $82000

The program directly accessed the 3rd record without reading the first two - this is random access in action! This technique is extremely efficient for large files.