Dokumentasi C interaktif: calloc dan realloc

Q: Apa perbedaan calloc dan malloc di C?

Ada dua perbedaan. calloc(n, size) menerima jumlah dan ukuran elemen secara terpisah, lalu memeriksa bahwa hasil perkaliannya tidak overflow, sedangkan malloc(n * size) bisa melingkar diam-diam. Selain itu, calloc mengisi blok dengan nol, sementara malloc membiarkannya berisi apa pun yang ada sebelumnya.

Q: Bagaimana cara kerja realloc di C?

realloc(p, newsize) mengembalikan blok berukuran baru dengan isi lamamu tetap terjaga sampai ukuran yang lebih kecil dari keduanya. Blok bisa diperbesar di tempat atau dipindahkan, jadi pointer yang dikembalikan adalah satu-satunya yang boleh terus kamu pakai: pointer lama mungkin sudah di-free.

Q: Kenapa hasil realloc harus di-assign ke pointer sementara?

Karena p = realloc(p, n) menimpa p dengan NULL saat pemanggilan gagal, padahal blok aslinya masih teralokasi tanpa ada yang menunjuk ke sana: kebocoran memori. Assign dulu ke tmp, periksa apakah NULL, baru setelah itu tulis p = tmp.

malloc menjawab satu pertanyaan: beri aku byte sebanyak ini. Dua pendampingnya di <stdlib.h> menjawab pertanyaan yang muncul berikutnya: beri aku byte sebanyak ini, dalam keadaan bersih (calloc), dan aku butuh blok yang sudah kumiliki jadi lebih besar (realloc).

calloc: Jumlah, Ukuran, dan Nol

void *calloc(size_t count, size_t size);

Dua argumen, bukan satu, dan hasilnya diisi dengan byte nol.

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

int main(void) {
    size_t n = 6;

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

    /* already zero - no initialization loop needed */
    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;
}

Itulah kasus klasiknya: histogram atau array penghitung di mana setiap slot harus mulai dari nol. Dengan malloc kamu perlu perulangan; calloc melakukannya sebagai bagian dari alokasi, sering kali tanpa biaya tambahan karena sistem operasi memang membagikan halaman memori baru yang sudah bernilai nol.

Alasan overflow

Pemisahan menjadi dua argumen bukan sekadar kosmetik. Bayangkan jumlah yang dibaca dari sebuah file:

size_t n = huge_value_from_input;

int *a = malloc(n * sizeof *a);     /* the product can wrap around */
int *b = calloc(n, sizeof *b);      /* required to detect the overflow */

Kalau n * sizeof *a melebihi kapasitas size_t, hasilnya melingkar menjadi angka kecil, malloc berhasil dengan blok yang mungil, dan setiap penulisan berikutnya berjalan jauh melewati ujungnya. Standar mewajibkan calloc untuk gagal dan mengembalikan NULL dalam kasus ini. Kalau ukuran berasal dari luar programmu, pemeriksaan itu layak dimiliki.

Apa arti "bernilai nol" sebenarnya

calloc menulis byte nol. Untuk integer dan karakter, itu berarti nilai nol, persis yang kamu inginkan. Untuk pointer dan nilai floating-point, semua bit nol berarti null pointer dan 0.0 di semua platform umum, tetapi standar C tidak menjaminnya. Kode yang harus benar-benar portabel meng-assign nilai-nilai itu secara eksplisit.

calloc vs malloc + memset

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

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

Hasilnya sama. Utamakan calloc: cukup satu baris, ada pemeriksaan overflow, dan untuk blok besar ia bisa sama sekali tidak menyentuh memorinya. Utamakan malloc biasa kalau kamu toh akan menimpa setiap byte: mengisi nol satu megabyte yang akan langsung kamu isi lagi hanya buang-buang tenaga.

realloc: Mengubah Ukuran

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

realloc mengembalikan blok berukuran newsize byte yang isinya sama dengan blok lama sampai ukuran yang lebih kecil dari keduanya. Blok bisa diperpanjang di tempatnya, atau dialokasikan baru, disalin, lalu blok lama di-free. Kamu tidak bisa tahu yang mana, jadi satu-satunya pointer yang boleh kamu pakai setelahnya adalah pointer yang dikembalikan.

#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 is still valid - release it */
        fprintf(stderr, "grow failed\n");
        return 1;
    }
    a = tmp;

    /* the first 3 values survived; the new slots are uninitialized */
    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;
}

Pola pointer tmp

Tiga baris di sekitar tmp itulah alasan fungsi ini terkenal rawan. Jalan pintas yang menggoda justru salah:

/* BUG: leaks the original block when realloc fails */
p = realloc(p, newsize);
if (p == NULL) {
    return;
}

Saat realloc gagal, ia mengembalikan NULL dan membiarkan blok asli tetap teralokasi tanpa perubahan. Meng-assign hasilnya langsung ke p menimpa satu-satunya pointer ke blok itu, sehingga blok tersebut tidak akan pernah bisa di-free. Itu kebocoran memori, dan terjadinya tepat saat memori sedang langka. Assign ke tmp, uji tmp, baru simpan:

void *tmp = realloc(p, newsize);
if (tmp == NULL) {
    /* p is still valid; handle the failure however suits the caller */
    return 0;
}
p = tmp;

Dua perilaku lain yang perlu diketahui: realloc(NULL, n) berperilaku persis seperti malloc(n), sehingga fungsi pemerbesar bisa menangani pemanggilan pertamanya tanpa kasus khusus. Lalu memperbesar blok membiarkan byte baru tidak diinisialisasi: hanya isi lama yang dipertahankan.

Memperbesar Array: Pola Standar

Berikut pola yang dipakai hampir setiap container C: panjang, kapasitas, dan menggandakan kapasitas saat keduanya bertemu.

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

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

/* returns 1 on success, 0 if the array could not grow */
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 is untouched and still valid */
        }
        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, "out of memory at %d\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;
}

Ada dua keputusan desain yang menjadi tumpuan di sini.

Digandakan, bukan ditambah satu. Memperbesar dengan jumlah tetap membuat setiap push menyalin seluruh array, sehingga mengisi n elemen memakan kira-kira n² penyalinan byte. Menggandakan membuat penyalinan cukup jarang sehingga rata-rata setiap push berjalan dalam waktu konstan. Awal cap == 0 ? 4 : cap * 2 menangani push pertama tanpa cabang terpisah, karena realloc(NULL, n) hanyalah malloc.

Struct memiliki satu alokasi. v.data di-free tepat satu kali, oleh siapa pun yang memiliki struct itu. Menuliskan aturan kepemilikan itu, entah di komentar atau dengan memasangkan setiap vec_init dengan vec_free, adalah yang menjaga container yang terus membesar agar tidak bocor saat berpindah antarfungsi.

Memperkecil

realloc dengan ukuran yang lebih kecil memangkas sebuah blok, yang berguna setelah kamu membaca data yang jumlahnya tidak diketahui ke dalam buffer yang kebesaran:

#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 = "only a few bytes";
    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;               /* shrink succeeded */
    }
    /* if it failed, buf is still the larger block - perfectly usable */

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

    free(buf);
    return 0;
}

Memperkecil yang gagal bukan error yang perlu sampai membatalkan program: blok lama yang lebih besar masih valid dan masih benar. Inilah satu-satunya kasus di mana mengabaikan kegagalan adalah keputusan yang tepat. Tetapi perhatikan bahwa kode ini tetap lewat tmp, karena aturan untuk tidak menimpa pointer yang masih aktif tidak berubah.

Mana yang Dipakai

Yang kamu inginkan	Gunakan
Byte, isinya tidak penting	`malloc(n * sizeof *p)`
Sejumlah item, diisi nol	`calloc(n, sizeof *p)`
Jumlah dari input yang tidak tepercaya	`calloc`, untuk pemeriksaan overflow
Blok yang sudah ada, diperbesar atau diperkecil	`realloc` lewat pointer `tmp`
Alokasi pertama di perulangan pemerbesar	`realloc(NULL, n)`, tanpa kasus khusus

Keempatnya dilepaskan dengan free yang sama, tepat satu kali.

Kesalahan Umum

p = realloc(p, n): bocor saat gagal. Selalu lewat tmp.
Menyimpan pointer lama ke dalam blok. Setelah realloc, datanya mungkin sudah pindah, jadi setiap pointer ke bagian dalam blok atau alamat yang diturunkan dari indeks yang tersimpan sudah usang. Indeks tetap berlaku setelah pemindahan; pointer tidak.
Menganggap byte baru bernilai nol. Hanya calloc yang mengisi nol. realloc membiarkan area tambahan tidak diinisialisasi.
calloc(n * size, 1): ini membuang pemeriksaan overflow yang menjadi alasan bentuk dua argumen itu ada.
Mem-free pointer lama setelah realloc berhasil. realloc sudah melepaskannya; free kedua adalah double free.

Pertanyaan yang sering diajukan

Apa perbedaan calloc dan malloc di C?

Ada dua perbedaan. calloc(n, size) menerima jumlah dan ukuran elemen secara terpisah, lalu memeriksa bahwa hasil perkaliannya tidak overflow, sedangkan malloc(n * size) bisa melingkar diam-diam. Selain itu, calloc mengisi blok dengan nol, sementara malloc membiarkannya berisi apa pun yang ada sebelumnya.

Bagaimana cara kerja realloc di C?

realloc(p, newsize) mengembalikan blok berukuran baru dengan isi lamamu tetap terjaga sampai ukuran yang lebih kecil dari keduanya. Blok bisa diperbesar di tempat atau dipindahkan, jadi pointer yang dikembalikan adalah satu-satunya yang boleh terus kamu pakai: pointer lama mungkin sudah di-free.

Kenapa hasil realloc harus di-assign ke pointer sementara?

Karena p = realloc(p, n) menimpa p dengan NULL saat pemanggilan gagal, padahal blok aslinya masih teralokasi tanpa ada yang menunjuk ke sana: kebocoran memori. Assign dulu ke tmp, periksa apakah NULL, baru setelah itu tulis p = tmp.

Kapan sebaiknya memakai calloc, bukan malloc?

Saat kamu benar-benar butuh memori bernilai nol (array penghitung, struct yang field-nya harus mulai kosong, buffer yang hanya akan diisi sebagian) atau saat ukurannya adalah jumlah dikali ukuran elemen yang bisa besar. Kalau kamu toh akan menimpa setiap byte, malloc melewatkan pekerjaan mengisi nol itu.

Konsep terkait

calloc dan realloc di C: Memori Bernilai Nol dan Memperbesar Array