C++ File I/O Explained: Reading, Writing and Real-World Patterns

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

int main() {
    // ofstream creates or overwrites the file — perfect for writing fresh output
    std::ofstream logWriter("server_log.txt");

    // Always check if the file actually opened — never assume it did
    if (!logWriter.is_open()) {
        std::cerr << "ERROR: Could not open server_log.txt for writing.\n";
        return 1; // Signal failure to the calling process
    }

    // Writing works just like std::cout — the << operator is overloaded for streams
    logWriter << "[INFO] Server started on port 8080\n";
    logWriter << "[INFO] Accepting connections...\n";

    // Explicitly closing flushes the buffer and releases the OS file handle
    logWriter.close();

    // ifstream opens an existing file for reading only
    std::ifstream logReader("server_log.txt");

    if (!logReader.is_open()) {
        std::cerr << "ERROR: Could not open server_log.txt for reading.\n";
        return 1;
    }

    std::string line;
    std::cout << "--- Contents of server_log.txt ---\n";

    // std::getline reads one full line at a time, handling newlines cleanly
    while (std::getline(logReader, line)) {
        std::cout << line << "\n";
    }

    logReader.close();
    return 0;
}

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

// Simulates writing timestamped events to an audit log
void appendAuditEvent(const std::string& eventMessage) {
    // std::ios::app ensures we NEVER overwrite existing log entries
    std::ofstream auditLog("audit.log", std::ios::app);

    if (!auditLog) {
        std::cerr << "Failed to open audit log.\n";
        return;
    }

    // Get current time as a simple timestamp string
    std::time_t now = std::time(nullptr);
    char timestamp[32];
    std::strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", std::localtime(&now));

    auditLog << "[" << timestamp << "] " << eventMessage << "\n";
    // Destructor closes the file and flushes the buffer — RAII in action
}

// Demonstrates binary mode to write raw struct data without text translation
struct PlayerScore {
    char username[32];
    int  score;
    int  level;
};

void saveBinaryScore(const PlayerScore& player) {
    // std::ios::binary prevents Windows from converting \n to \r\n in raw bytes
    std::ofstream scoreFile("scores.dat", std::ios::binary | std::ios::app);
    if (!scoreFile) {
        std::cerr << "Failed to open scores.dat.\n";
        return;
    }
    // Write the raw bytes of the struct directly to disk
    scoreFile.write(reinterpret_cast<const char*>(&player), sizeof(PlayerScore));
}

int main() {
    // Call this function multiple times — each run APPENDS, never overwrites
    appendAuditEvent("User 'alice' logged in");
    appendAuditEvent("User 'alice' accessed /admin panel");
    appendAuditEvent("User 'alice' logged out");

    // Read back the audit log to confirm appending worked
    std::ifstream auditReader("audit.log");
    std::string line;
    std::cout << "=== Audit Log ===\n";
    while (std::getline(auditReader, line)) {
        std::cout << line << "\n";
    }

    // Save a binary game score record
    PlayerScore topPlayer = {"alice", 98500, 42};
    saveBinaryScore(topPlayer);
    std::cout << "\nBinary score record saved for: " << topPlayer.username << "\n";

    return 0;
}

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

// Fixed-size record — essential for predictable seek arithmetic
struct EmployeeRecord {
    char name[64];
    int  employeeId;
    double salary;
};

// Write a set of records to a binary file
void createEmployeeDatabase(const std::string& filename) {
    std::ofstream dbFile(filename, std::ios::binary);
    if (!dbFile) {
        std::cerr << "Cannot create employee database.\n";
        return;
    }

    EmployeeRecord employees[] = {
        {"Alice Martin",  1001, 85000.00},
        {"Bob Chen",      1002, 92000.00},
        {"Carol Davis",   1003, 78500.00}
    };

    for (const auto& emp : employees) {
        dbFile.write(reinterpret_cast<const char*>(&emp), sizeof(EmployeeRecord));
    }
    // File closes here via RAII
}

// Update a single record by its zero-based index — no need to rewrite the file
void updateSalary(const std::string& filename, int recordIndex, double newSalary) {
    // fstream with in|out|binary opens for both reading and writing
    std::fstream dbFile(filename, std::ios::in | std::ios::out | std::ios::binary);

    if (!dbFile) {
        std::cerr << "Cannot open employee database for update.\n";
        return;
    }

    // Calculate the exact byte offset for the target record
    std::streampos targetOffset = recordIndex * sizeof(EmployeeRecord);

    // Read the existing record first to preserve non-salary fields
    dbFile.seekg(targetOffset);
    EmployeeRecord target;
    dbFile.read(reinterpret_cast<char*>(&target), sizeof(EmployeeRecord));

    std::cout << "Updating " << target.name
              << "'s salary from $" << target.salary
              << " to $" << newSalary << "\n";

    target.salary = newSalary;

    // Seek the WRITE pointer back to the same position and overwrite just this record
    dbFile.seekp(targetOffset);
    dbFile.write(reinterpret_cast<const char*>(&target), sizeof(EmployeeRecord));
}

// Read and print all records sequentially
void printAllEmployees(const std::string& filename) {
    std::ifstream dbFile(filename, std::ios::binary);
    if (!dbFile) {
        std::cerr << "Cannot read employee database.\n";
        return;
    }

    EmployeeRecord emp;
    std::cout << "\n--- Employee Records ---\n";
    while (dbFile.read(reinterpret_cast<char*>(&emp), sizeof(EmployeeRecord))) {
        std::cout << "ID: " << emp.employeeId
                  << " | Name: " << emp.name
                  << " | Salary: $" << emp.salary << "\n";
    }
}

int main() {
    const std::string dbFilename = "employees.dat";

    createEmployeeDatabase(dbFilename);
    printAllEmployees(dbFilename);

    // Update Bob Chen (index 1) without touching Alice or Carol's records
    updateSalary(dbFilename, 1, 97500.00);

    printAllEmployees(dbFilename);
    return 0;
}

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

// Parses a simple key=value config file with robust error handling
void parseConfigFile(const std::string& configPath) {
    std::ifstream configFile;

    // Tell the stream to throw on badbit (hardware errors) but NOT failbit
    // We'll handle failbit manually for fine-grained control
    configFile.exceptions(std::ios::badbit);

    try {
        configFile.open(configPath);

        if (!configFile.is_open()) {
            throw std::runtime_error("Config file not found: " + configPath);
        }

        std::string line;
        int lineNumber = 0;

        // CORRECT pattern: test the result of getline, not eof() directly
        while (std::getline(configFile, line)) {
            ++lineNumber;

            // Skip blank lines and comments
            if (line.empty() || line[0] == '#') continue;

            // Find the separator between key and value
            size_t separatorPos = line.find('=');
            if (separatorPos == std::string::npos) {
                std::cerr << "WARNING: Malformed config at line "
                          << lineNumber << ": '" << line << "'\n";
                continue; // Don't abort — just skip the bad line
            }

            std::string key   = line.substr(0, separatorPos);
            std::string value = line.substr(separatorPos + 1);

            std::cout << "  Config loaded -> [" << key << "] = [" << value << "]\n";
        }

        // After the loop, check WHY we stopped: EOF is fine, anything else is not
        if (configFile.bad()) {
            throw std::runtime_error("I/O error while reading config file.");
        }
        // eof() + fail() together means normal end-of-file — that's expected

    } catch (const std::ios_base::failure& ioError) {
        std::cerr << "Stream I/O failure: " << ioError.what() << "\n";
    } catch (const std::runtime_error& appError) {
        std::cerr << "Application error: " << appError.what() << "\n";
    }
}

void createSampleConfig(const std::string& path) {
    std::ofstream configWriter(path);
    configWriter << "# Sample application config\n";
    configWriter << "database_host=localhost\n";
    configWriter << "database_port=5432\n";
    configWriter << "bad line without equals sign\n"; // intentional malformed line
    configWriter << "max_connections=100\n";
}

int main() {
    const std::string configPath = "app.config";
    createSampleConfig(configPath);

    std::cout << "Parsing config file...\n";
    parseConfigFile(configPath);

    std::cout << "\nTesting with missing file...\n";
    parseConfigFile("nonexistent.config");

    return 0;
}