C++ ofstream Flush Failure — Lost Audit Logs on Crash

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

namespace io::thecodeforge::io_basics {

void runDemo() {
    // ofstream creates or overwrites the file
    std::ofstream logWriter("server_log.txt");

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

    logWriter << "[INFO] Server started on port 8080\n";
    logWriter << "[INFO] Accepting connections...\n";
    logWriter.close();

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

    if (!logReader) { // testing the stream directly works too
        std::cerr << "ERROR: Could not open server_log.txt for reading.\n";
        return;
    }

    std::string line;
    std::cout << "--- Contents of server_log.txt ---\n";
    while (std::getline(logReader, line)) {
        std::cout << line << "\n";
    }
}

}

int main() {
    io::thecodeforge::io_basics::runDemo();
    return 0;
}

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

namespace io::thecodeforge::file_modes {

struct PlayerScore {
    char username[32];
    int  score;
    int  level;
};

void saveBinaryScore(const PlayerScore& player) {
    // Combined modes: Append + Binary
    std::ofstream scoreFile("scores.dat", std::ios::binary | std::ios::app);
    if (scoreFile.is_open()) {
        scoreFile.write(reinterpret_cast<const char*>(&player), sizeof(PlayerScore));
    }
}

void appendLog(const std::string& msg) {
    std::ofstream log("audit.log", std::ios::app);
    if (log) log << msg << "\n";
}

}

int main() {
    using namespace io::thecodeforge::file_modes;
    appendLog("User 'alice' logged in");
    PlayerScore top = {"alice", 98500, 42};
    saveBinaryScore(top);
    std::cout << "Log and binary data processed successfully.\n";
    return 0;
}

#include <iostream>
#include <fstream>

namespace io::thecodeforge::random_access {

struct EmployeeRecord {
    char name[64];
    int employeeId;
    double salary;
};

void updateSalary(const std::string& filename, int recordIndex, double newSalary) {
    std::fstream dbFile(filename, std::ios::in | std::ios::out | std::ios::binary);
    if (!dbFile) return;

    std::streampos targetOffset = recordIndex * sizeof(EmployeeRecord);

    // Seek to record, read it, modify it
    dbFile.seekg(targetOffset);
    EmployeeRecord emp;
    dbFile.read(reinterpret_cast<char*>(&emp), sizeof(EmployeeRecord));

    emp.salary = newSalary;

    // Seek back to the SAME offset to overwrite
    dbFile.seekp(targetOffset);
    dbFile.write(reinterpret_cast<const char*>(&emp), sizeof(EmployeeRecord));
}

}

int main() {
    // Imagine database exists with Bob at index 1
    io::thecodeforge::random_access::updateSalary("employees.dat", 1, 97500.00);
    std::cout << "Record updated at index 1.\n";
    return 0;
}

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

namespace io::thecodeforge::robust_io {

void parseConfig(const std::string& path) {
    std::ifstream file(path);
    if (!file) {
        std::cerr << "Could not open file.\n";
        return;
    }

    std::string line;
    // CORRECT: loop on the read result
    while (std::getline(file, line)) {
        if (line.empty() || line[0] == '#') continue;
        std::cout << "Processing: " << line << "\n";
    }

    if (file.bad()) {
        std::cerr << "Critical I/O error occurred.\n";
    }
}

}

int main() {
    io::thecodeforge::robust_io::parseConfig("app.config");
    return 0;
}

#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>

namespace io::thecodeforge::buffering {

void writeWithFlush() {
    std::ofstream log("critical.log");
    log << "Transaction committed\n";
    log.flush();  // force data to OS buffer (not necessarily to disk)
    // For disk sync, use: fsync(log.rdbuf()->fd());
}

void setCustomBuffer() {
    std::ofstream file("data.bin");
    char buffer[65536];
    file.rdbuf()->pubsetbuf(buffer, sizeof(buffer));
    // Now writes are buffered in 64 KB chunks
}

}

int main() {
    io::thecodeforge::buffering::writeWithFlush();
    io::thecodeforge::buffering::setCustomBuffer();
    std::cout << "Buffering demo complete.\n";
    return 0;
}