File Handling in C — 'w' Mode Truncated Our Logs

#include <stdio.h>
#include <stdlib.h>  // for exit()

int main(void) {
    // Attempt to open (or create) a log file for writing
    // 'w' mode: creates the file if it doesn't exist,
    //           TRUNCATES it to zero bytes if it does — be careful!
    FILE *log_file = fopen("app_log.txt", "w");

    // ALWAYS check for NULL before using the pointer.
    // fopen returns NULL when the file can't be opened for any reason.
    if (log_file == NULL) {
        // perror prints the system error message (e.g. "Permission denied")
        // prefixed by whatever string you pass it.
        perror("ERROR: Could not open app_log.txt");
        exit(EXIT_FAILURE);  // exit cleanly rather than crash later
    }

    // Write a header line to the log
    fprintf(log_file, "=== Application Log Started ===\n");
    fprintf(log_file, "Status: Initialised successfully\n");

    // fclose flushes any buffered data to disk AND releases the FILE*
    // resource. Skip this and you may lose the last chunk of data.
    if (fclose(log_file) != 0) {
        perror("ERROR: Could not close app_log.txt");
        exit(EXIT_FAILURE);
    }

    printf("Log written successfully. Check app_log.txt\n");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LINE_LENGTH 256
#define SCORES_FILE     "scores.txt"

// Writes three player scores to a text file
void write_scores(void) {
    FILE *scores_file = fopen(SCORES_FILE, "w");
    if (scores_file == NULL) {
        perror("ERROR: Cannot create scores file");
        exit(EXIT_FAILURE);
    }

    // fprintf works exactly like printf but targets a file
    fprintf(scores_file, "Alice,4200\n");
    fprintf(scores_file, "Bob,3875\n");
    fprintf(scores_file, "Charlie,5100\n");

    fclose(scores_file);
    printf("Scores written to %s\n", SCORES_FILE);
}

// Reads every line back and prints it with a rank number
void read_scores(void) {
    FILE *scores_file = fopen(SCORES_FILE, "r");
    if (scores_file == NULL) {
        perror("ERROR: Cannot open scores file for reading");
        exit(EXIT_FAILURE);
    }

    char line_buffer[MAX_LINE_LENGTH];  // holds one line at a time
    int rank = 1;

    printf("\n--- Leaderboard ---\n");

    // fgets reads up to (MAX_LINE_LENGTH - 1) chars, stops at '\n' or EOF.
    // It returns NULL when there's nothing left to read.
    while (fgets(line_buffer, sizeof(line_buffer), scores_file) != NULL) {
        // fgets keeps the trailing '\n' — strip it for clean display
        line_buffer[strcspn(line_buffer, "\n")] = '\0';

        // strtok splits the line on the comma delimiter
        char *player_name  = strtok(line_buffer, ",");
        char *score_string = strtok(NULL, ",");

        if (player_name != NULL && score_string != NULL) {
            printf("  #%d  %-10s  %s pts\n", rank++, player_name, score_string);
        }
    }

    fclose(scores_file);
}

int main(void) {
    write_scores();
    read_scores();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define RECORDS_FILE "employees.dat"
#define MAX_NAME_LEN 50

// A fixed-size struct — perfect for binary I/O because the layout is predictable
typedef struct {
    int    employee_id;
    char   full_name[MAX_NAME_LEN];
    double annual_salary;
} Employee;

void save_employees(const Employee *employees, int count) {
    // 'wb' — write binary. Without the 'b', Windows may corrupt data
    // by translating '\n' bytes in your struct to '\r\n'.
    FILE *data_file = fopen(RECORDS_FILE, "wb");
    if (data_file == NULL) {
        perror("ERROR: Cannot open employees.dat for writing");
        exit(EXIT_FAILURE);
    }

    // fwrite returns the number of items written.
    // If it doesn't match 'count', the disk might be full.
    size_t items_written = fwrite(employees, sizeof(Employee), count, data_file);
    if ((int)items_written != count) {
        fprintf(stderr, "ERROR: Only wrote %zu of %d records\n", items_written, count);
        fclose(data_file);
        exit(EXIT_FAILURE);
    }

    fclose(data_file);
    printf("Saved %d employee record(s) to %s\n", count, RECORDS_FILE);
}

void load_and_print_employees(int expected_count) {
    FILE *data_file = fopen(RECORDS_FILE, "rb");  // 'rb' — read binary
    if (data_file == NULL) {
        perror("ERROR: Cannot open employees.dat for reading");
        exit(EXIT_FAILURE);
    }

    Employee record;  // reuse a single struct for each read

    printf("\n--- Employee Records ---\n");

    // Read one Employee at a time until fread returns 0 (EOF or error)
    int rank = 1;
    while (fread(&record, sizeof(Employee), 1, data_file) == 1) {
        printf("  [%d] ID: %04d  Name: %-20s  Salary: $%.2f\n",
               rank++,
               record.employee_id,
               record.full_name,
               record.annual_salary);
    }

    // Distinguish between EOF (normal) and a real read error
    if (ferror(data_file)) {
        perror("ERROR: Failed while reading employees.dat");
    }

    fclose(data_file);
}

int main(void) {
    Employee team[3] = {
        {1001, "Sarah Mitchell",  92500.00},
        {1002, "James Okafor",   87000.00},
        {1003, "Lin Wei",       105000.00}
    };

    save_employees(team, 3);
    load_and_print_employees(3);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define RECORDS_FILE "employees.dat"  // reuses file from previous example
#define MAX_NAME_LEN 50

typedef struct {
    int    employee_id;
    char   full_name[MAX_NAME_LEN];
    double annual_salary;
} Employee;

// Returns file size in bytes using fseek/ftell — a classic C idiom
long get_file_size(FILE *file) {
    fseek(file, 0, SEEK_END);    // jump to the very end
    long size = ftell(file);     // ftell returns current byte position
    rewind(file);                // rewind back to the start for subsequent reads
    return size;
}

// Update a single record by index without touching other records
void update_salary(int record_index, double new_salary) {
    // 'r+b' = read-write binary (file must already exist)
    FILE *data_file = fopen(RECORDS_FILE, "r+b");
    if (data_file == NULL) {
        perror("ERROR: Cannot open employees.dat for update");
        exit(EXIT_FAILURE);
    }

    long file_size    = get_file_size(data_file);
    int  total_records = (int)(file_size / sizeof(Employee));

    printf("File size: %ld bytes | Records: %d\n", file_size, total_records);

    if (record_index < 0 || record_index >= total_records) {
        fprintf(stderr, "ERROR: Record index %d out of range (0-%d)\n",
                record_index, total_records - 1);
        fclose(data_file);
        exit(EXIT_FAILURE);
    }

    // Jump directly to the target record — no need to read what's before it
    long byte_offset = (long)record_index * sizeof(Employee);
    fseek(data_file, byte_offset, SEEK_SET);

    // Read the current record first so we can update just the salary field
    Employee target_record;
    if (fread(&target_record, sizeof(Employee), 1, data_file) != 1) {
        perror("ERROR: Failed to read target record");
        fclose(data_file);
        exit(EXIT_FAILURE);
    }

    printf("Updating %s: $%.2f -> $%.2f\n",
           target_record.full_name,
           target_record.annual_salary,
           new_salary);

    target_record.annual_salary = new_salary;

    // Seek back to the same position — fread advanced the pointer past the record
    fseek(data_file, byte_offset, SEEK_SET);
    fwrite(&target_record, sizeof(Employee), 1, data_file);

    fclose(data_file);
    printf("Update complete.\n");
}

int main(void) {
    // Update the salary of the second employee (index 1 = James Okafor)
    update_salary(1, 95000.00);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

// Production-safe fopen with buffer control and explicit error reporting
// Returns NULL on failure after printing a meaningful error message.
// If setbuf_size > 0, uses a custom buffer; if 0, unbuffered.
FILE *io_thecodeforge_file_open(const char *path, const char *mode, size_t setbuf_size) {
    FILE *fp = fopen(path, mode);
    if (fp == NULL) {
        fprintf(stderr, "[io_thecodeforge] ERROR: fopen(\"%s\", \"%s\") failed: %s\n",
                path, mode, strerror(errno));
        return NULL;
    }

    if (setbuf_size > 0) {
        char *buf = (char *)malloc(setbuf_size);
        if (buf == NULL) {
            // setvbuf with NULL buffer is allowed — just use default
            fprintf(stderr, "[io_thecodeforge] WARNING: malloc(%zu) failed, using default buffer\n", setbuf_size);
        } else {
            if (setvbuf(fp, buf, _IOFBF, setbuf_size) != 0) {
                fprintf(stderr, "[io_thecodeforge] WARNING: setvbuf failed, using default buffer\n");
                free(buf);
            }
        }
    } else if (setbuf_size == 0) {
        setvbuf(fp, NULL, _IONBF, 0);  // unbuffered
    }

    return fp;
}

// Safely write exactly 'count' items of 'size' bytes, retrying on short writes
int io_thecodeforge_file_write(FILE *fp, const void *data, size_t size, size_t count) {
    size_t total_written = 0;
    const unsigned char *ptr = (const unsigned char *)data;
    size_t total_bytes = size * count;

    while (total_written < total_bytes) {
        size_t written = fwrite(ptr + total_written, 1, total_bytes - total_written, fp);
        if (written == 0) {
            if (ferror(fp)) {
                fprintf(stderr, "[io_thecodeforge] ERROR: fwrite failed: %s\n", strerror(errno));
                return -1;
            }
            // Shouldn't happen with blocking I/O, but guard against infinite loop
            break;
        }
        total_written += written;
    }

    return (total_written == total_bytes) ? 0 : -1;
}

// Usage example
int main(void) {
    FILE *log = io_thecodeforge_file_open("production.log", "a", 8192);
    if (log == NULL) {
        exit(EXIT_FAILURE);
    }

    const char *msg = "Service started successfully\n";
    if (io_thecodeforge_file_write(log, msg, 1, strlen(msg)) != 0) {
        fprintf(stderr, "Failed to write startup message\n");
    }

    fclose(log);
    return 0;
}

// io.thecodeforge — c-cpp tutorial

#include <fstream>
#include <iostream>

int main() {
    // Explicit append mode — safe for logs
    std::ofstream log("transactions.log", std::ios::app);
    if (!log) {
        std::cerr << "Failed to open log file for appending\n";
        return 1;
    }
    log << "Transaction committed at " << 1712345678 << "\n";
    log.close();

    // Binary read mode — no implicit truncation
    std::ifstream config("settings.bin", std::ios::in | std::ios::binary);
    if (!config) {
        std::cerr << "Config file not found — using defaults\n";
        return 1;
    }
    // ... read binary data
    config.close();
    return 0;
}

// io.thecodeforge — c-cpp tutorial

#include <fstream>
#include <iostream>

int main() {
    std::ifstream config("config.ini");
    if (!config.is_open()) {
        // Fallback: use hardcoded defaults
        std::cerr << "config.ini not found, using defaults\n";
        int retries = 3;
        std::cout << "Retries: " << retries << "\n";
        return 0;
    }
    // Read config
    std::string line;
    while (std::getline(config, line)) {
        std::cout << line << "\n";
    }
    config.close();
    return 0;
}