Alokasi Memori Dinamis di C menggunakan Fungsi malloc(), calloc()

Sebelum Anda mempelajari alokasi Memori Dinamis C, mari kita pahami:

Bagaimana Manajemen Memori di C bekerja?

Saat Anda mendeklarasikan variabel menggunakan tipe data dasar, kompiler C secara otomatis mengalokasikan ruang memori untuk variabel tersebut dalam kumpulan memori yang disebut tumpukan.

Misalnya, variabel float biasanya membutuhkan 4 byte (menurut platform) saat dideklarasikan. Kami dapat memverifikasi informasi ini menggunakan ukuran dari operator seperti yang ditunjukkan pada contoh di bawah ini

#include <stdio.h>
int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

output akan:

 The size of float is 4 bytes

Selain itu, array dengan ukuran tertentu dialokasikan dalam blok memori yang berdekatan, setiap blok memiliki ukuran untuk satu elemen:

#include <stdio.h>
int main() { float arr[10];
printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}

Hasilnya adalah:

 The size of the float array with 10 element is 40

Seperti yang telah dipelajari sejauh ini, ketika mendeklarasikan tipe data dasar atau array, memori dikelola secara otomatis. Namun, ada proses untuk mengalokasikan memori di C yang memungkinkan Anda mengimplementasikan program yang ukuran arraynya belum ditentukan hingga Anda menjalankan program (runtime). Proses ini disebut “Alokasi memori dinamis. "

Sekarang Anda dapat membuat dan menghancurkan serangkaian elemen secara dinamis saat runtime tanpa masalah. Singkatnya, manajemen memori otomatis menggunakan tumpukan, dan Alokasi Memori Dinamis C menggunakan tumpukan.

Itu perpustakaan memiliki fungsi yang bertanggung jawab untuk Manajemen Memori Dinamis.

fungsi	Tujuan
malloc ()	Mengalokasikan memori dengan ukuran yang diminta dan mengembalikan penunjuk ke byte pertama ruang yang dialokasikan.
panggilan()	Mengalokasikan ruang untuk elemen array. Menginisialisasi elemen ke nol dan mengembalikan pointer ke memori.
alokasi ulang()	Ini digunakan untuk mengubah ukuran ruang memori yang dialokasikan sebelumnya.
Bebas()	Membebaskan atau mengosongkan ruang memori yang dialokasikan sebelumnya.

Mari kita bahas fungsi-fungsi di atas beserta penerapannya

Sintaks malloc() Fungsi:

ptr = (cast_type *) malloc (byte_size);

Di sini,

• ptr adalah penunjuk cast_type.
• Fungsi C malloc() mengembalikan pointer ke memori yang dialokasikan byte_size.

Contoh malloc():

Example: ptr = (int *) malloc (50)

Ketika pernyataan ini berhasil dijalankan, ruang memori sebesar 50 byte dicadangkan. Alamat byte pertama dari ruang cadangan diberikan ke penunjuk ptr bertipe int.

Perhatikan contoh lain:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Keluaran:

Value of the 6th integer is 480

1. Perhatikan bahwa ukuran(*ptr) digunakan sebagai gantinya ukuran(int) untuk membuat kode lebih kuat ketika deklarasi *ptr diketik ke tipe data berbeda nanti.
2. Alokasi mungkin gagal jika memori tidak mencukupi. Dalam hal ini, ia mengembalikan pointer NULL. Jadi, Anda harus memasukkan kode untuk memeriksa pointer NULL.
3. Perlu diingat bahwa memori yang dialokasikan adalah bersebelahan dan dapat diperlakukan sebagai array. Kita dapat menggunakan aritmatika pointer untuk mengakses elemen array daripada menggunakan tanda kurung [ ]. Kami menyarankan untuk menggunakan + untuk merujuk ke elemen array karena penggunaan incrementation ++ atau += mengubah alamat yang disimpan oleh petunjuk.

Fungsi Malloc() juga dapat digunakan dengan tipe data karakter maupun tipe data kompleks seperti struktur.

Sebagai contoh:

#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);
}

Keluaran:

 Value of the 2nd integer is 50

Sintaks calloc() Fungsi:

ptr = (cast_type *) calloc (n, size);

• Pernyataan di atas digunakan untuk mengalokasikan n blok memori dengan ukuran yang sama.
• Setelah ruang memori dialokasikan, maka semua byte diinisialisasi ke nol.
• Pointer yang saat ini berada pada byte pertama dari ruang memori yang dialokasikan dikembalikan.

Setiap kali ada kesalahan dalam mengalokasikan ruang memori seperti kekurangan memori, maka penunjuk nol dikembalikan.

Contoh calloc():

Program di bawah ini menghitung jumlah barisan aritmatika.

#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);
        }
        printf("Building and calculating the sequence sum of the first 10 terms \ n ");
        for (i = 0; i < 10; ++i) { * (ptr + i) = i;
            sum += * (ptr + i);
        }
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }

Hasil:

Building and calculating the sequence sum of the first 10 terms
Sum = 45

calloc() vs. malloc(): Perbedaan Utama

Berikut ini adalah perbedaan utama antara malloc() Vs calloc() dalam C:

Fungsi calloc() secara umum lebih sesuai dan efisien daripada fungsi malloc(). Meskipun kedua fungsi tersebut digunakan untuk mengalokasikan ruang memori, calloc() dapat mengalokasikan beberapa blok sekaligus. Anda tidak perlu meminta blok memori setiap saat. Fungsi calloc() digunakan dalam struktur data kompleks yang memerlukan ruang memori lebih besar.

Blok memori yang dialokasikan oleh calloc() di C selalu diinisialisasi ke nol sedangkan di fungsi malloc() di C, selalu berisi nilai sampah.

Sintaks fungsi realloc():

ptr = realloc (ptr,newsize);

Pernyataan di atas mengalokasikan ruang memori baru dengan ukuran tertentu dalam variabel newsize. Setelah menjalankan fungsi tersebut, penunjuk akan dikembalikan ke byte pertama blok memori. Ukuran barunya bisa lebih besar atau lebih kecil dari memori sebelumnya. Kami tidak dapat memastikan apakah blok yang baru dialokasikan akan menunjuk ke lokasi yang sama dengan blok memori sebelumnya. Fungsi ini akan menyalin semua data sebelumnya di wilayah baru. Ini memastikan bahwa data akan tetap aman.

Contoh alokasi ulang():

#include <stdio.h>
int main () {
   char *ptr;
   ptr = (char *) malloc(10);
   strcpy(ptr, "Programming");
   printf(" %s,  Address = %u\n", ptr, ptr);

   ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size
   strcat(ptr, " In 'C'");
   printf(" %s,  Address = %u\n", ptr, ptr);
   free(ptr);
   return 0;
}

Setiap kali realloc() dalam C menghasilkan operasi yang gagal, ia mengembalikan penunjuk null, dan data sebelumnya juga dibebaskan.

#include <stdio.h>
    int main() {
        int * arr_dynamic = NULL;
        int elements = 2, i;
        arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks
        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)); //reallocate 4 elements
        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);
    }

Hasil program C Dynamic array di layar:

 
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

• Kita dapat mengelola memori secara dinamis dengan membuat blok memori sesuai kebutuhan di heap
• Dalam Alokasi Memori Dinamis C, memori dialokasikan pada waktu proses.
• Alokasi memori dinamis memungkinkan untuk memanipulasi string dan array yang ukurannya fleksibel dan dapat diubah kapan saja dalam program Anda.
• Ini diperlukan ketika Anda tidak tahu berapa banyak memori yang akan ditempati oleh struktur tertentu.
• Malloc() di C adalah fungsi alokasi memori dinamis yang merupakan singkatan dari alokasi memori yang memblokir memori dengan ukuran tertentu yang diinisialisasi ke nilai sampah
• Calloc() di C adalah fungsi alokasi memori bersebelahan yang mengalokasikan beberapa blok memori sekaligus diinisialisasi ke 0
• Realloc() pada C digunakan untuk merealokasi memori sesuai dengan ukuran yang ditentukan.
• Fungsi Free() digunakan untuk menghapus memori yang dialokasikan secara dinamis.