C'de calloc ve realloc: Sıfırlanmış Bellek ve Bir Diziyi Büyütmek

malloc tek bir soruyu yanıtlar: bana şu kadar bayt ver. <stdlib.h> içindeki iki yol arkadaşı sonraki soruları yanıtlar - bana şu kadar bayt ver, temizlenmiş (calloc) ve elimdeki bloğun daha büyük olması lazım (realloc).

calloc: Sayı, Boyut ve Sıfırlar

void *calloc(size_t count, size_t size);

Bir yerine iki argüman ve sonuç sıfır baytlarla dolu.

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

int main(void) {
    size_t n = 6;

    int *counts = calloc(n, sizeof *counts);
    if (counts == NULL) {
        fprintf(stderr, "bellek yetersiz\n");
        return 1;
    }

    /* zaten sifir - ilk deger dongusu gerekmiyor */
    for (size_t i = 0; i < n; i++) {
        printf("%d ", counts[i]);
    }
    printf("\n");

    counts[2] += 1;
    counts[2] += 1;
    printf("counts[2] = %d\n", counts[2]);

    free(counts);
    return 0;
}

Klasik durum budur: her yuvanın sıfırdan başlaması gereken bir histogram ya da sayaç dizisi. malloc ile bir döngüye ihtiyacınız olurdu; calloc bunu tahsisin parçası olarak yapar ve çoğu zaman bedavaya, çünkü işletim sistemi zaten taze sayfaları önceden sıfırlanmış olarak dağıtır.

Taşma argümanı

İki argümana bölünme kozmetik değildir. Bir dosyadan okunan bir sayıyı düşünün:

size_t n = girdiden_gelen_devasa_deger;

int *a = malloc(n * sizeof *a);     /* çarpım sarabilir */
int *b = calloc(n, sizeof *b);      /* taşmayı saptamakla yükümlüdür */

n * sizeof *a, size_t'nin tutabileceğini aşarsa küçük bir sayıya sarar, malloc minik bir blokla başarılı olur ve sonraki her yazma sonun çok ötesine geçer. calloc'un standarda göre bunun yerine başarısız olup NULL döndürmesi gerekir. Bir boyut programınızın dışından geldiğinde o denetime sahip olmaya değer.

"Sıfırlanmış" aslında ne demek

calloc sıfır baytlar yazar. Tam sayılar ve karakterler için bu, istediğiniz şey olan sıfır değeridir. Göstericiler ve kayan noktalı değerler için tüm bitlerin sıfır olması yaygın her platformda boş gösterici ve 0.0 anlamına gelir, ama C standardı bunu vaat etmez. Kesinlikle taşınabilir olması gereken kod bunları açıkça atar.

calloc ile malloc + memset karşılaştırması

int *a = calloc(n, sizeof *a);

int *b = malloc(n * sizeof *b);
if (b != NULL) {
    memset(b, 0, n * sizeof *b);
}

Aynı sonucu üretirler. calloc'u tercih edin: tek satırdır, taşma denetimini yapar ve büyük bloklar için belleğe hiç dokunmaktan kaçınabilir. Zaten her baytın üzerine yazmak üzereyseniz düz malloc'u tercih edin - hemen dolduracağınız bir megabaytı sıfırlamak saf israftır.

realloc: Boyutu Değiştirmek

void *realloc(void *p, size_t newsize);

realloc, içeriği iki boyuttan küçük olanına kadar eski blokla aynı olan newsize baytlık bir blok döndürür. Bloğu bulunduğu yerde genişletebilir ya da yeni bir tane tahsis edip kopyalayarak eskisini serbest bırakabilir. Hangisini yaptığını anlayamazsınız, dolayısıyla sonrasında kullanabileceğiniz tek gösterici onun döndürdüğüdür.

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

int main(void) {
    size_t n = 3;
    int *a = malloc(n * sizeof *a);
    if (a == NULL) {
        return 1;
    }
    for (size_t i = 0; i < n; i++) {
        a[i] = (int)i;
    }

    size_t bigger = 6;
    int *tmp = realloc(a, bigger * sizeof *a);
    if (tmp == NULL) {
        free(a);                 /* a hala gecerli - serbest birak */
        fprintf(stderr, "buyutme basarisiz\n");
        return 1;
    }
    a = tmp;

    /* ilk 3 deger hayatta kaldi; yeni yuvalar ilk degersiz */
    for (size_t i = n; i < bigger; i++) {
        a[i] = (int)(i * 10);
    }

    for (size_t i = 0; i < bigger; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    free(a);
    return 0;
}

tmp gösterici deyimi

tmp etrafındaki üç satır, bu fonksiyonun bir üne sahip olmasının tüm sebebidir. Cazip kısayol bozuktur:

/* HATA: realloc başarısız olduğunda özgün bloğu sızdırır */
p = realloc(p, newsize);
if (p == NULL) {
    return;
}

realloc başarısız olduğunda NULL döndürür ve özgün bloğu tahsis edilmiş ve değişmemiş bırakır. Sonucu doğrudan p'ye atamak, o bloğa giden tek göstericinin üzerine yazar, dolayısıyla asla serbest bırakılamaz - bir sızıntı ve tam da bellek zaten kıtken olan bir sızıntı. tmp'ye atayın, tmp'yi test edin, sonra kesinleştirin:

void *tmp = realloc(p, newsize);
if (tmp == NULL) {
    /* p hâlâ geçerli; başarısızlığı çağırana uygun şekilde ele alın */
    return 0;
}
p = tmp;

Bilmeye değer iki davranış daha: realloc(NULL, n) tam olarak malloc(n) gibi davranır; bu, bir büyütme fonksiyonunun ilk çağrısını özel durum olmadan ele almasını sağlar. Ve büyütmek yeni baytları ilk değersiz bırakır - yalnızca eski içerik korunur.

Bir Diziyi Büyütmek: Standart Kalıp

İşte neredeyse her C kapsayıcısının kullandığı kalıp - bir uzunluk, bir kapasite ve ikisi buluştuğunda ikiye katlama.

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

struct IntVec {
    int   *data;
    size_t len;
    size_t cap;
};

/* basarida 1, dizi buyuyemezse 0 dondurur */
int vec_push(struct IntVec *v, int value) {
    if (v->len == v->cap) {
        size_t newcap = (v->cap == 0) ? 4 : v->cap * 2;

        int *tmp = realloc(v->data, newcap * sizeof *v->data);
        if (tmp == NULL) {
            return 0;               /* v->data dokunulmamis ve hala gecerli */
        }
        v->data = tmp;
        v->cap  = newcap;
    }

    v->data[v->len++] = value;
    return 1;
}

int main(void) {
    struct IntVec v = {NULL, 0, 0};

    for (int i = 1; i <= 10; i++) {
        if (!vec_push(&v, i * i)) {
            fprintf(stderr, "%d'de bellek yetersiz\n", i);
            free(v.data);
            return 1;
        }
    }

    printf("len = %zu, cap = %zu\n", v.len, v.cap);
    for (size_t i = 0; i < v.len; i++) {
        printf("%d ", v.data[i]);
    }
    printf("\n");

    free(v.data);
    v.data = NULL;
    v.len = v.cap = 0;
    return 0;
}

Burada ağırlığı iki tasarım noktası taşıyor.

Bir eklemek değil, ikiye katlamak. Sabit bir miktarda büyümek her eklemenin tüm diziyi kopyalamasına yol açar, dolayısıyla n eleman doldurmak kabaca n² bayt kopyalamaya mal olur. İkiye katlamak kopyalamaları, her eklemenin ortalamada sabit zaman almasına yetecek kadar seyrekleştirir. cap == 0 ? 4 : cap * 2 başlangıcı ilk eklemeyi ayrı bir dal olmadan halleder, çünkü realloc(NULL, n) zaten malloc'tur.

Yapı tek bir tahsisin sahibidir. v.data, yapının sahibi kimse onun tarafından tam olarak bir kez serbest bırakılır. Bu sahiplik kuralını yazıya dökmek - bir yorumda ya da her vec_init'i bir vec_free ile eşleyerek - büyüyen bir kapsayıcının fonksiyonlar arasında dolaşırken sızıntı yapmasını engelleyen şeydir.

Küçültme

Daha küçük bir boyutla realloc bir bloğu budar; bu, fazla büyük bir tampona bilinmeyen miktarda veri okuduktan sonra işe yarar:

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

int main(void) {
    size_t cap = 1024;
    char *buf = malloc(cap);
    if (buf == NULL) {
        return 1;
    }

    const char *text = "yalnizca birkac bayt";
    size_t used = 0;
    while (text[used] != '\0' && used < cap - 1) {
        buf[used] = text[used];
        used++;
    }
    buf[used] = '\0';

    char *tmp = realloc(buf, used + 1);
    if (tmp != NULL) {
        buf = tmp;               /* kucultme basarili */
    }
    /* basarisiz olduysa buf hala buyuk blok - gayet kullanilabilir */

    printf("[%s] yeni boyut %zu\n", buf, used + 1);

    free(buf);
    return 0;
}

Başarısız bir küçültme, uğruna programı sonlandırmaya değer bir hata değildir: eski, daha büyük blok hâlâ geçerli ve hâlâ doğrudur. Başarısızlığı yok saymanın doğru karar olduğu tek durum budur - ama yine de tmp üzerinden geçtiğine dikkat edin, çünkü yaşayan göstericinin üzerine yazmama kuralı değişmez.

Hangisine Uzanmalı

Dördü de aynı free ile, tam olarak bir kez serbest bırakılır.

Sık Yapılan Hatalar

• p = realloc(p, n) - başarısızlıkta sızdırır. Her zaman tmp üzerinden gidin.
• Bloğa giden eski bir göstericiyi saklamak. realloc'tan sonra veri taşınmış olabilir, dolayısıyla saklanan her iç gösterici ya da indeksten türetilmiş adres bayattır. İndeksler bir taşınmadan sağ çıkar; göstericiler çıkmaz.
• Yeni baytların sıfır olduğunu varsaymak. Yalnızca calloc sıfırlar. realloc büyüme bölgesini ilk değersiz bırakır.
• calloc(n * size, 1) - iki argümanlı biçimin var olma sebebi olan taşma denetimini çöpe atar.
• Başarılı bir realloc'tan sonra eski göstericiyi serbest bırakmak. realloc onu zaten serbest bıraktı; ikinci bir free çifte serbest bırakmadır.