Alokasi Memori Dinamis dalam C: Menguasai malloc, calloc, realloc, dan free
Sebelum menyelami alokasi memori dinamis dalam C, penting untuk memahami bagaimana memori dikelola dalam bahasa ini.
Bagaimana Manajemen Memori Bekerja dalam C
Saat Anda mendeklarasikan variabel dengan tipe primitif, kompiler secara otomatis mengalokasikan ruang untuknya di stack. Misalnya, sebuah float biasanya menempati 4 bytes (bergantung pada platform). Anda dapat mengonfirmasinya dengan operator sizeof:
#include <stdio.h> int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0; } Outputnya akan menjadi:
The size of float is 4 bytes
Array dengan ukuran tertentu juga dialokasikan secara berurutan di stack, dengan setiap elemen menempati ukuran tipe datanya:
#include <stdio.h> int main() { float arr[10]; printf("The size of the float array with 10 elements is %d", sizeof(arr)); return 0; } Hasilnya adalah:
The size of the float array with 10 elements is 40
Meskipun alokasi stack otomatis, banyak program memerlukan memori yang ukurannya tidak diketahui sampai runtime. Kebutuhan ini diatasi oleh alokasi memori dinamis, yang menggunakan heap daripada stack.
Alokasi Memori Dinamis dalam C
Alokasi dinamis melibatkan permintaan dan pembebasan memori secara manual sesuai kebutuhan, dengan pointer melacak blok yang dialokasikan di heap. Pustaka standar C menyediakan beberapa fungsi untuk tujuan ini:
- malloc() – Mengalokasikan blok byte yang berurutan dan mengembalikan pointer ke byte pertama.
- calloc() – Mengalokasikan array elemen, menginisialisasi semua byte ke nol, dan mengembalikan pointer ke elemen pertama.
- realloc() – Mengubah ukuran blok yang telah dialokasi sebelumnya, menjaga isinya.
- free() – Melepaskan blok yang telah dialokasi sebelumnya kembali ke heap.
Mari kita jelajahi setiap fungsi secara rinci.
Fungsi malloc()
Fungsi malloc() singkat dari “memory allocation.” Ini menyediakan blok memori dengan ukuran yang ditentukan dan mengembalikan pointer padanya. Pointer biasanya dikonversi ke tipe yang diinginkan:
ptr = (cast_type *) malloc(byte_size);
Contoh:
#include <stdlib.h> int main(){ int *ptr; ptr = malloc(15 * sizeof(*ptr)); /* 15 integers */ if (ptr != NULL) { *(ptr + 5) = 480; /* sixth element */ printf("Value of the 6th integer is %d", *(ptr + 5)); } } Output:
Value of the 6th integer is 480
Poin penting:
- Gunakan
sizeof(*ptr) untuk membuat kode tahan terhadap perubahan tipe. - Periksa apakah mengembalikan
NULL untuk mendeteksi kegagalan alokasi. - Memori yang dialokasi berseberang; treat sebagai array dan gunakan aritmetika pointer.
Alokasi dinamis tidak terbatas pada tipe primitif; ini bekerja dengan struktur, array karakter, dan lainnya.
Fungsi free()
Memori yang dialokasi dengan malloc(), calloc(), atau realloc() harus dilepaskan secara eksplisit untuk menghindari kebocoran. Fungsi free() melakukan tugas ini:
#include <stdio.h> int main() { int* ptr = malloc(10 * sizeof(*ptr)); if (ptr != NULL){ *(ptr + 2) = 50; printf("Value of the 2nd integer is %d", *(ptr + 2)); } free(ptr); } Output:
Value of the 2nd integer is 50
Fungsi calloc()
calloc() mengalokasikan beberapa blok dengan ukuran yang sama dan menginisialisasi setiap byte ke nol, menjadikannya ideal untuk array dan struktur yang memerlukan memori yang difungsikan nol:
ptr = (cast_type *) calloc(n, size);
Contoh – menjumlahkan deret aritmetika:
#include <stdio.h> int main() { int i, *ptr, sum = 0; ptr = calloc(10, sizeof(int)); if (ptr == NULL) { printf("Error! memory not allocated."); exit(0); } for (i = 0; i < 10; ++i) { *(ptr + i) = i; sum += *(ptr + i); } printf("Sum = %d", sum); free(ptr); return 0; } Result:
Sum = 45
calloc() vs. malloc()
Perbedaan utama:
- Inisialisasi:
calloc() mengatur nol memori; malloc() membiarkannya tidak diinisialisasi (sampah). - Penggunaan:
calloc() lebih disukai untuk array atau struktur yang membutuhkan nilai nol; malloc() lebih sederhana ketika tidak diperlukan inisialisasi. - Performa: Keduanya bekerja sama, tetapi
calloc() mungkin sedikit lebih lambat karena pengaturan nol.
Fungsi realloc()
Fungsi realloc() mengubah ukuran alokasi yang ada sambil mempertahankan isinya:
ptr = realloc(ptr, newsize);
Contoh – memperluas buffer string:
#include <stdio.h> int main () { char *ptr = malloc(10); strcpy(ptr, "Programming"); ptr = realloc(ptr, 20); // enlarge strcat(ptr, " In 'C'"); printf("%s, Address = %u", ptr, ptr); free(ptr); return 0; } Jika reallocasi gagal, realloc() mengembalikan NULL dan blok asli tetap valid.
Array Dinamis
Array dinamis memungkinkan jumlah elemen untuk bertambah selama eksekusi, pola umum dalam algoritma dan struktur data:
#include <stdio.h> int main() { int *arr_dynamic = NULL; int elements = 2, i; arr_dynamic = calloc(elements, sizeof(int)); for (i = 0; i < elements; i++) arr_dynamic[i] = i; for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]); elements = 4; arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); printf("After realloc\n"); for (i = 2; i < elements; i++) arr_dynamic[i] = i; for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]); free(arr_dynamic); } Result:
arr_dynamic[0]=0 arr_dynamic[1]=1 After realloc arr_dynamic[0]=0 arr_dynamic[1]=1 arr_dynamic[2]=2 arr_dynamic[3]=3
Ringkasan
- Memori dinamis memungkinkan Anda mengalokasikan dan membebaskan ruang heap pada runtime.
- Gunakan
malloc() untuk blok tunggal, calloc() untuk array yang diinisialisasi nol. - Selalu periksa
NULL untuk mendeteksi kegagalan alokasi. - Lepaskan memori dengan
free() untuk menghindari kebocoran. - Ubah ukuran alokasi dengan
realloc() ketika diperlukan lebih banyak ruang. - Array dinamis adalah pola yang kuat untuk struktur data fleksibel.