File Handling di C: fopen, fclose, dan Membaca File Baris per Baris

Semua yang dihitung sebuah program hilang saat program keluar, kecuali kalau ditulis ke suatu tempat. Antarmuka file di C ada di <stdio.h>, header yang sama dengan printf, dan sengaja dibuat mirip: file adalah stream berisi byte, dan fungsi-fungsi yang bekerja di layar punya kembaran yang menerima argumen stream.

Tipe handle-nya adalah FILE *. Kamu tidak pernah melihat isi FILE; tipe itu adalah tipe opaque (lihat typedef) dan kamu hanya pernah memegang pointer ke sana.

Tiga Langkahnya

Setiap operasi file mengikuti bentuk yang sama: buka, pakai, tutup.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("greeting.txt", "w");
    if (fp == NULL) {
        fprintf(stderr, "Could not open the file for writing.\n");
        return 1;
    }

    fprintf(fp, "Hello, file!\n");
    fprintf(fp, "Written by a C program.\n");

    fclose(fp);
    printf("Wrote greeting.txt\n");
    return 0;
}

Pemeriksaan NULL bukan sekadar kekhawatiran berlebihan. fopen gagal setiap kali file tidak ada (dalam mode baca), direktorinya tidak bisa ditulisi, path-nya salah, atau proses kehabisan handle file, dan semua itu mengembalikan NULL. Memakai handle NULL berujung segmentation fault.

Mengirim error ke stderr, bukan stdout, adalah konvensinya: stream itu tidak di-buffer, dan bisa diarahkan secara terpisah dari output yang sebenarnya.

Mode fopen

Argumen kedua adalah string mode yang pendek. Salah memilihnya adalah kesalahan paling merusak di seluruh area ini, karena "w" diam-diam mengosongkan file yang sudah ada.

Tambahkan b ke salah satunya ("rb", "wb", "ab+") untuk mode biner; penjelasannya ada di bagian akhir.

Dua aturan yang mencegah kehilangan data sungguhan:

• Gunakan "r" kalau kamu bermaksud membaca. "r+" pada nama file yang salah ketik gagal dengan aman; "w+" membuat file kosong dan yang hilang hanya waktumu. "w" pada nama file yang benar padahal maksudmu "r" akan menghancurkan datanya.
• Gunakan "a" untuk log. Setiap fprintf mendarat di akhir file di mana pun posisi stream-nya, persis yang dibutuhkan log.

Menulis dan Membaca dalam Satu Program

Editor di bawah menjalankan perjalanan pulang-pergi yang lengkap: membuat file, menulis data ke dalamnya, menutupnya, membukanya lagi untuk dibaca, lalu mencetak apa yang ditemukannya.

#include <stdio.h>

int main(void) {
    const char *path = "scores.txt";

    /* --- write --- */
    FILE *out = fopen(path, "w");
    if (out == NULL) {
        fprintf(stderr, "cannot open %s for writing\n", path);
        return 1;
    }
    fprintf(out, "Ada %d\n", 92);
    fprintf(out, "Grace %d\n", 105);
    fprintf(out, "Alan %d\n", 87);
    fclose(out);

    /* --- read it back --- */
    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "cannot open %s for reading\n", path);
        return 1;
    }

    char name[32];
    int  score;
    int  total = 0, count = 0;

    while (fscanf(in, "%31s %d", name, &score) == 2) {
        printf("%-8s %3d\n", name, score);
        total += score;
        count++;
    }
    fclose(in);

    if (count > 0) {
        printf("average: %.1f\n", (double)total / count);
    }
    return 0;
}

fprintf dan fscanf adalah printf dan scanf dengan stream sebagai argumen pertama; semua hal tentang format specifier-nya identik, termasuk lebar %31s yang mencegah name meluap.

Kondisi loop-nya adalah == 2, jumlah item yang diminta format. Menguji terhadap EOF adalah bug klasik: baris yang formatnya salah membuat fscanf mengembalikan 0, bukan EOF, dan loop berputar selamanya pada input yang tidak bisa diprosesnya.

Membaca Baris per Baris dengan fgets

fscanf praktis untuk data dengan format yang kaku. Untuk file teks, seperti konfigurasi, log, CSV, atau apa pun yang ditulis manusia, baca satu baris penuh. Loop ini adalah bentuk standarnya:

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

int main(void) {
    const char *path = "notes.txt";

    FILE *out = fopen(path, "w");
    if (out == NULL) { return 1; }
    fprintf(out, "first line\n");
    fprintf(out, "second line\n");
    fprintf(out, "third line\n");
    fclose(out);

    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "cannot open %s\n", path);
        return 1;
    }

    char line[256];
    int  lineno = 0;

    while (fgets(line, sizeof line, in) != NULL) {
        line[strcspn(line, "\n")] = '\0';    /* trim the trailing newline */
        lineno++;
        printf("%3d: [%s] (%zu chars)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

Yang membuat fgets menjadi pilihan default yang tepat:

• Ia menerima ukuran buffer, jadi tidak bisa meluap. Berikan sizeof line dan pemanggilannya tetap benar kalau kamu mengubah ukuran array.
• Ia mengembalikan NULL di akhir file atau saat error, yang menjadi kondisi loop yang rapi.
• Ia mempertahankan karakter baris baru kalau barisnya muat di buffer. Itu berguna: tidak adanya '\n' di hasil yang kamu dapat berarti barisnya lebih panjang dari buffer-mu dan sisanya masih menunggu. strcspn(line, "\n") menemukan indeks karakter baris baru (atau panjang string kalau tidak ada), jadi meng-assign '\0' di sana memangkasnya dalam kedua kasus.

Untuk membedakan akhir file yang sebenarnya dari error, tanyakan setelah loop:

if (ferror(in)) {
    fprintf(stderr, "read error\n");
} else if (feof(in)) {
    /* normal end */
}

Jangan menulis while (!feof(fp)) sebagai kondisi loop. feof baru bernilai true setelah sebuah pembacaan gagal, jadi loop itu memproses isi buffer terakhir satu kali ekstra. Uji nilai kembalian fungsi pembacanya, seperti yang dilakukan kedua loop di atas.

Satu Karakter Sekali Baca: fgetc dan fputc

Untuk pekerjaan tingkat byte, seperti menghitung karakter, mengubah isi file, atau menyalin, fgetc dan fputc menangani satu karakter per pemanggilan.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *src = "mixed.txt";
    const char *dst = "upper.txt";

    FILE *out = fopen(src, "w");
    if (out == NULL) { return 1; }
    fputs("Hello there, C programmer!\n", out);
    fclose(out);

    FILE *in = fopen(src, "r");
    FILE *up = fopen(dst, "w");
    if (in == NULL || up == NULL) {
        if (in) fclose(in);
        if (up) fclose(up);
        return 1;
    }

    int c;
    int letters = 0, lines = 0;

    while ((c = fgetc(in)) != EOF) {
        if (isalpha(c)) letters++;
        if (c == '\n')  lines++;
        fputc(toupper(c), up);
    }

    fclose(in);
    fclose(up);

    printf("%d letters, %d lines\n", letters, lines);

    /* show the result */
    FILE *check = fopen(dst, "r");
    if (check != NULL) {
        char line[128];
        while (fgets(line, sizeof line, check) != NULL) {
            printf("%s", line);
        }
        fclose(check);
    }
    return 0;
}

Satu detail yang penting: c dideklarasikan sebagai int, bukan char. fgetc mengembalikan int agar bisa mengembalikan setiap nilai byte yang mungkin dan penanda khusus EOF (yang bernilai -1). Menyimpannya di char membuat perbandingan dengan EOF selalu false, atau keliru bernilai true untuk byte 0xFF, tergantung apakah char bersifat signed di platformmu. Ini salah satu jebakan tertua di C.

Memeriksa Error dengan Benar

Pembacaan di kode produksi terlihat seperti ini:

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

int main(void) {
    FILE *fp = fopen("does-not-exist.txt", "r");
    if (fp == NULL) {
        fprintf(stderr, "open failed: %s\n", strerror(errno));
        perror("perror says");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno menyimpan kode yang menjelaskan kegagalan terakhir dan strerror mengubahnya menjadi kalimat; perror mencetak pesanmu ditambah kalimat itu dalam satu pemanggilan. Keduanya masing-masing butuh <errno.h> dan <string.h>.

fclose juga bisa gagal, karena ia mengosongkan data di buffer dan penulisannya mungkin tidak muat di disk. Jadi untuk hal yang penting, periksa:

if (fclose(fp) != 0) {
    fprintf(stderr, "failed to flush and close\n");
}

Mode Biner dalam Satu Paragraf

Mode teks bisa menerjemahkan akhir baris (di Windows, \n menjadi \r\n saat ditulis dan kembali lagi saat dibaca) dan bisa memperlakukan byte tertentu secara khusus. Untuk data yang bukan teks, seperti gambar, struct yang disalin apa adanya, atau blob terkompresi, buka dengan b dan gunakan fread/fwrite, yang memindahkan byte mentah:

#include <stdio.h>

struct Record {
    int    id;
    double value;
};

int main(void) {
    struct Record out[2] = {{1, 3.5}, {2, 7.25}};

    FILE *fp = fopen("records.bin", "wb");
    if (fp == NULL) { return 1; }
    fwrite(out, sizeof out[0], 2, fp);
    fclose(fp);

    struct Record in[2];
    fp = fopen("records.bin", "rb");
    if (fp == NULL) { return 1; }
    size_t got = fread(in, sizeof in[0], 2, fp);
    fclose(fp);

    printf("read %zu records\n", got);
    for (size_t i = 0; i < got; i++) {
        printf("id=%d value=%.2f\n", in[i].id, in[i].value);
    }
    return 0;
}

fwrite(ptr, size, count, fp) menulis count item berukuran size byte dan mengembalikan berapa banyak yang berhasil ditulis; fread adalah cerminannya. Perlu diingat bahwa file yang ditulis dengan cara ini terikat pada mesin yang menulisnya: padding struct, ukuran integer, dan urutan byte semuanya ikut masuk ke byte-byte itu. Jadi cara ini cocok untuk cache atau file sementara, tetapi salah untuk format yang harus dibaca program lain.

Kesalahan Umum

• Tidak memeriksa fopen terhadap NULL. Crash yang menyusul disalahkan pada pembacaan, bukan pada pembukaan file.
• Membuka dengan "w" padahal maksudmu "r". File-nya sudah dikosongkan sebelum kamu sadar.
• Lupa fclose. Output di buffer hilang, dan setiap file yang tidak ditutup membocorkan satu handle.
• while (!feof(fp)). Memproses baris terakhir dua kali. Uji pemanggilan fungsi pembacanya.
• char c = fgetc(fp). Merusak perbandingan dengan EOF. Gunakan int.
• fscanf("%s", buf) tanpa lebar. Buffer overflow yang sama seperti scanf dari keyboard.
• Path relatif. fopen("data.txt", "r") mencari di working directory, bukan di sebelah executable. Kalau sebuah file "menghilang", biasanya itulah sebabnya.