free()

Membebaskan memori yang Dialokasikan dalam C

Fungsi free() digunakan untuk membebaskan memori yang telah dialokasikan secara dinamis menggunakan malloc(), calloc(), atau realloc().

Mengapa free() penting?

Jika kita tidak menggunakan free(), maka memori yang dialokasikan akan tetap terpakai meskipun tidak digunakan lagi. Ini bisa menyebabkan memory leak, yaitu kondisi di mana memori terpakai terus-menerus tanpa dilepaskan.

Sintaks

void free(void *ptr);

• ptr ➜ Pointer ke blok memori yang dialokasikan sebelumnya.

• Setelah free(), pointer tetap ada tetapi tidak menunjuk ke memori yang valid (dangling pointer).

• Jika ptr == NULL, maka free(ptr) tidak melakukan apa-apa (aman untuk dipanggil).

Contoh Pengunaan

1. Membebaskan memori setelah menggunakan malloc()

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

int main() {
    int *ptr;

    // Alokasi memori untuk satu integer
    ptr = (int*) malloc(sizeof(int));

    if (ptr == NULL) {
        printf("Alokasi memori gagal!\n");
        return 1;
    }

    *ptr = 42;  // Menyimpan nilai
    printf("Nilai yang disimpan: %d\n", *ptr);

    free(ptr);  // Membebaskan memori
    ptr = NULL; // Menghindari dangling pointer

    return 0;
}

Hasilnya:

Nilai yang disimpan: 42

• malloc(sizeof(int)) ➜ Mengalokasikan memori untuk satu integer.

• Menggunakan memori (*ptr = 42).

• Memanggil free(ptr) ➜ Membebaskan memori yang dialokasikan.

• Mengatur ptr = NULL ➜ Untuk mencegah dangling pointer.

2. Membebaskan memori untuk array dinamis

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

int main() {
    int *arr;
    int n = 5;

    // Alokasi memori untuk array
    arr = (int*) malloc(n * sizeof(int));

    if (arr == NULL) {
        printf("Alokasi memori gagal!\n");
        return 1;
    }

    // Mengisi array
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    // Menampilkan isi array
    printf("Array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);  // Membebaskan memori
    arr = NULL; // Mencegah dangling pointer

    return 0;
}

Hasilnya:

Array: 1 2 3 4 5

• Alokasi memori untuk array (malloc(n * sizeof(int))).

• Mengisi dan menampilkan isi array.

• Memanggil free(arr) untuk membebaskan memori.

• Mengatur arr = NULL untuk mencegah dangling pointer.

3. Memori yang sudah dibebaskan tidak bisa digunakan lagi

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

int main() {
    int *ptr = (int*) malloc(sizeof(int));

    if (ptr == NULL) {
        printf("Alokasi memori gagal!\n");
        return 1;
    }

    *ptr = 10;
    printf("Sebelum free: %d\n", *ptr);

    free(ptr);

    // Menggunakan pointer setelah free() (BUG!)
    printf("Setelah free: %d\n", *ptr); // BUG: Undefined Behavior

    return 0;
}

Hasilnya:

Sebelum free: 10
Setelah free: 1638292290 (atau nilai acak)

• Setelah free(ptr), ptr masih menunjuk ke lokasi lama, tetapi memori tersebut sudah dilepaskan.

• Membaca *ptr setelah free() menyebabkan "Undefined Behavior".

  • Solusi: Set ptr = NULL setelah free(ptr).

4. Penanganan double free (membebaskan memori dua kali)

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

int main() {
    int *ptr = (int*) malloc(sizeof(int));

    if (ptr == NULL) {
        printf("Alokasi memori gagal!\n");
        return 1;
    }

    free(ptr);
    free(ptr); // BUG: Double Free!

    return 0;
}

• Double free(ptr) bisa menyebabkan crash atau behavior tidak terduga.

  • Solusi: Set ptr = NULL setelah free(ptr), sehingga pemanggilan free(ptr) berikutnya menjadi aman.

5. Aman Memanggil free(NULL)

Jika pointer adalah NULL, maka free(ptr) tidak melakukan apa-apa (aman dipanggil).

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

int main() {
    int *ptr = NULL;

    free(ptr); // Aman, tidak akan menyebabkan error

    return 0;
}

Kenapa free(NULL) aman?

Standar C memastikan bahwa free(NULL) tidak akan menyebabkan error atau crash.