C'de Dosya İşlemleri: fopen, fclose ve Dosyaları Satır Satır Okumak

Bir programın hesapladığı her şey, yazıya dökülmedikçe program çıktığında yok olur. C'nin dosya arayüzü <stdio.h> içinde yaşar - printf ile aynı başlık - ve bilinçli olarak benzerdir: bir dosya bayt akışıdır ve ekranda çalışan fonksiyonların, akış argümanı alan ikizleri vardır.

Tutamaç tipi FILE *'dır. Bir FILE'ın içine asla bakmazsınız; opak bir tiptir (bkz. typedef) ve yalnızca ona bir gösterici tutarsınız.

Üç Adım

Her dosya işlemi aynı biçimi izler: aç, kullan, kapat.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("greeting.txt", "w");
    if (fp == NULL) {
        fprintf(stderr, "Dosya yazmak icin acilamadi.\n");
        return 1;
    }

    fprintf(fp, "Merhaba, dosya!\n");
    fprintf(fp, "Bir C programi tarafindan yazildi.\n");

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

NULL denetimi isteğe bağlı bir paranoya değildir. fopen; dosya yoksa (okuma kipinde), dizin yazılabilir değilse, yol yanlışsa ya da süreç dosya tutamacı tüketmişse başarısız olur ve bunların her biri NULL döndürür. NULL bir tutamacı kullanmak bir segmentation fault'tur.

Hatayı stdout yerine stderr'e göndermek gelenektir: tamponsuzdur ve gerçek çıktıdan ayrı yönlendirilebilir.

fopen Kipleri

İkinci argüman kısa bir kip metnidir. Onu yanlış yapmak bu alandaki en yıkıcı hatadır, çünkü "w" var olan bir dosyayı sessizce boşaltır.

Bunların herhangi birine b ekleyin ("rb", "wb", "ab+") ve ikili kip elde edin - bu konuda daha fazlası sonda.

Gerçek veri kaybını önleyen iki kural:

• Okumayı kastediyorsanız "r" kullanın. Yanlış yazılmış bir dosya adında "r+" güvenle başarısız olur; "w+" boş bir dosya oluşturur ve zamandan başka bir şey kaybetmezsiniz. Doğru dosya adında "r" kastedip "w" kullanmak veriyi yok eder.
• Günlükler için "a" kullanın. Akış nereye konumlanmış olursa olsun her fprintf sona düşer ki bir günlüğün istediği tam olarak budur.

Tek Programda Yazmak ve Okumak

Aşağıdaki editör eksiksiz bir gidiş-dönüş çalıştırır - bir dosya oluşturur, içine kayıtlar yazar, kapatır, okumak için yeniden açar ve bulduklarını yazdırır.

#include <stdio.h>

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

    /* --- yaz --- */
    FILE *out = fopen(path, "w");
    if (out == NULL) {
        fprintf(stderr, "%s yazmak icin acilamadi\n", path);
        return 1;
    }
    fprintf(out, "Ada %d\n", 92);
    fprintf(out, "Grace %d\n", 105);
    fprintf(out, "Alan %d\n", 87);
    fclose(out);

    /* --- geri oku --- */
    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "%s okumak icin acilamadi\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("ortalama: %.1f\n", (double)total / count);
    }
    return 0;
}

fprintf ve fscanf, ilk argümanı bir akış olan printf ve scanf'tir; biçim belirteçleriyle ilgili her şey, name'in taşmasını önleyen %31s genişliği dahil tıpatıp aynıdır.

Döngü koşulu == 2'dir, yani biçimin istediği öğe sayısı. Bunun yerine EOF ile test etmek klasik bir hatadır: bozuk bir satır fscanf'in EOF değil 0 döndürmesine yol açar ve döngü, tüketemediği girdi üzerinde sonsuza dek döner.

fgets ile Satır Satır Okumak

fscanf, katı biçimlendirilmiş veri için elverişlidir. Metin dosyaları için - yapılandırma, günlük, CSV, bir insanın yazdığı her şey - tüm satırları okuyun. Bu döngü klasik olanıdır:

#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, "birinci satir\n");
    fprintf(out, "ikinci satir\n");
    fprintf(out, "ucuncu satir\n");
    fclose(out);

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

    char line[256];
    int  lineno = 0;

    while (fgets(line, sizeof line, in) != NULL) {
        line[strcspn(line, "\n")] = '\0';    /* sondaki satir sonunu kirp */
        lineno++;
        printf("%3d: [%s] (%zu karakter)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

fgets'i doğru varsayılan kılan şeyler:

• Tampon boyutunu alır, dolayısıyla taşamaz. sizeof line geçirin, diziyi yeniden boyutlandırdığınızda çağrı doğru kalsın.
• Dosya sonunda ya da hatada NULL döndürür ki bu temiz bir döngü koşuludur.
• Satır tampona sığdığında satır sonunu korur. Bu yararlıdır - aldığınızda '\n' yoksa satır tamponunuzdan uzundu ve gerisi hâlâ bekliyordur. strcspn(line, "\n") satır sonunun indeksini (ya da yoksa metnin uzunluğunu) bulur, dolayısıyla oraya '\0' atamak her iki durumda da kırpar.

Gerçek bir dosya sonunu bir hatadan ayırmak için döngüden sonra sorun:

if (ferror(in)) {
    fprintf(stderr, "okuma hatasi\n");
} else if (feof(in)) {
    /* normal son */
}

Bir döngü koşulu olarak while (!feof(fp)) yazmayın. feof yalnızca bir okuma çoktan başarısız olduktan sonra doğru olur, dolayısıyla o döngü son tampon içeriğini fazladan bir kez işler. Bunun yerine okuma fonksiyonunun dönüş değerini test edin - yukarıdaki iki döngünün yaptığı gibi.

Karakter Karakter: fgetc ve fputc

Bayt düzeyindeki işler için - karakter saymak, bir dosyayı dönüştürmek, kopyalamak - fgetc ve fputc çağrı başına bir karakter işler.

#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("Merhaba, C programcisi!\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 harf, %d satir\n", letters, lines);

    /* sonucu goster */
    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;
}

Önemli bir ayrıntı: c, char değil int olarak bildirilmiştir. fgetc, olası her bayt değerini ve ayrı nöbetçi EOF'u (-1) döndürebilmek için bir int döndürür. Onu bir char'da saklamak, platformunuzda char'ın işaretli olup olmamasına göre EOF karşılaştırmasını ya hep yanlış ya da 0xFF baytı için yanlışlıkla doğru yapar. Bu, C'nin en eski tuzaklarından biridir.

Hataları Düzgün Denetlemek

Üretim düzeyinde bir okuma şöyle görünür:

#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, "acma basarisiz: %s\n", strerror(errno));
        perror("perror diyor ki");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno, son başarısızlığı tarif eden bir kod tutar ve strerror onu bir cümleye çevirir; perror sizin mesajınızı artı o cümleyi tek çağrıda yazdırır. İkisi sırasıyla <errno.h> ve <string.h> ister.

fclose da başarısız olabilir - tamponlanmış veriyi boşaltır ve yazma diske sığmayabilir - dolayısıyla önemli bir şey için kontrol edin:

if (fclose(fp) != 0) {
    fprintf(stderr, "bosaltma ve kapatma basarisiz\n");
}

Tek Paragrafta İkili Kip

Metin kipi satır sonlarını çevirebilir (Windows'ta yazarken \n, \r\n olur ve okurken geri döner) ve bazı baytlara özel davranabilir. Metin olmayan veriler için - bir görüntü, olduğu gibi dökülmüş bir yapı, sıkıştırılmış bir blok - b ile açın ve ham bayt taşıyan fread/fwrite kullanın:

#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("%zu kayit okundu\n", got);
    for (size_t i = 0; i < got; i++) {
        printf("id=%d deger=%.2f\n", in[i].id, in[i].value);
    }
    return 0;
}

fwrite(ptr, size, count, fp), size baytlık count öğe yazar ve kaç tanesini başardığını döndürür; fread onu yansıtır. Bu şekilde yazılan bir dosyanın onu yazan makineye bağlı olduğunun farkında olun - yapı dolgusu, tam sayı boyutu ve bayt sırası hepsi baytlara sızar - dolayısıyla bir önbellek ya da geçici dosya için uygundur, başka programların okuması gereken bir biçim için yanlıştır.

Sık Yapılan Hatalar

• fopen'ı NULL için kontrol etmemek. Ardından gelen çökme, açmaya değil okumaya yıkılır.
• "r" kastederken "w" ile açmak. Siz fark etmeden dosya boşaltılır.
• fclose'u unutmak. Tamponlanmış çıktı kaybolur ve kapatılmayan her dosya bir tutamaç sızdırır.
• while (!feof(fp)). Son satırı iki kez işler. Bunun yerine okuma çağrısını test edin.
• char c = fgetc(fp). EOF karşılaştırmasını bozar. int kullanın.
• Genişliksiz fscanf("%s", buf). Klavyede scanf ile olan tampon taşmasının aynısı.
• Göreli yollar. fopen("data.txt", "r"), çalıştırılabilir dosyanın yanına değil çalışma dizinine bakar. Bir dosya "kayboluyorsa" sebebi genellikle budur.