Dynamic Memory Allocation di C++ dengan new dan delete

Dynamic memory allocation adalah proses di mana memori dialokasikan pada waktu runtime daripada waktu kompilasi. Di C++, operator new digunakan untuk mengalokasikan memori secara dinamis, dan operator delete digunakan untuk membebaskan memori yang telah dialokasikan.

Mengapa Perlu Dynamic Memory Allocation?

• Fleksibilitas: Ukuran memori yang diperlukan mungkin tidak diketahui saat kompilasi.
• Efisiensi Memori: Hanya memori yang diperlukan dialokasikan, sehingga dapat mengurangi pemborosan.
• Struktur Data Dinamis: Memungkinkan implementasi struktur data seperti linked list, tree, dan graph.

Operator new

Operator new digunakan untuk mengalokasikan memori secara dinamis. Saat menggunakan new, memori dialokasikan di heap, bukan di stack. Sintaks dasar:

type* pointerName = new type;

Contoh:

int* p = new int;    // Mengalokasikan memori untuk satu integer
*p = 10;             // Menyimpan nilai 10 di alamat yang dialokasikan
cout << *p << endl;  // Output: 10

Mengalokasikan Array Secara Dinamis

Anda juga dapat menggunakan new untuk mengalokasikan array:

int* arr = new int[5]; // Mengalokasikan memori untuk array 5 elemen
for (int i = 0; i < 5; i++) {
    arr[i] = i + 1;    // Menyimpan nilai
    cout << arr[i] << " "; // Output: 1 2 3 4 5
}

Operator delete

Operator delete digunakan untuk membebaskan memori yang dialokasikan dengan new. Jika Anda tidak membebaskan memori setelah selesai digunakan, program Anda dapat mengalami kebocoran memori (memory leak).

Membebaskan Memori untuk Variabel Tunggal

delete p; // Membebaskan memori yang dialokasikan untuk integer
p = nullptr; // Menghindari dangling pointer

Membebaskan Memori untuk Array

delete[] arr; // Membebaskan memori array
arr = nullptr; // Menghindari dangling pointer

Contoh Lengkap

Berikut adalah contoh program sederhana yang menunjukkan alokasi dan dealokasi memori dinamis:

#include <iostream>
using namespace std;

int main() {
    // Mengalokasikan memori untuk variabel tunggal
    int* p = new int(42);
    cout << "Nilai p: " << *p << endl;

    // Mengalokasikan memori untuk array
    int* arr = new int[5];
    for (int i = 0; i < 5; i++) {
        arr[i] = (i + 1) * 10;
    }

    cout << "Array: ";
    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Membebaskan memori
    delete p;
    delete[] arr;

    return 0;
}

Output:

Nilai p: 42
Array: 10 20 30 40 50

Kesalahan Umum dalam Dynamic Memory Allocation

• Memory Leak Jika Anda lupa membebaskan memori menggunakan delete atau delete[], memori akan tetap teralokasi bahkan setelah tidak digunakan. Contoh:

int* p = new int(10);
// Tidak ada delete: memory leak terjadi

• Dangling Pointer Terjadi ketika pointer mengarah ke memori yang sudah dibebaskan. Solusi: Setelah delete, atur pointer ke nullptr.

delete p;
p = nullptr;

• Menggunakan delete pada Array Selalu gunakan delete[] untuk array yang dialokasikan dengan new[].

Salah :

int* arr = new int[5];
delete arr; // Salah

Benar :

delete[] arr;

• Double Deletion Membebaskan memori yang sama lebih dari sekali dapat menyebabkan perilaku tidak terduga. Contoh:

int* p = new int(10);
delete p;
delete p; // Kesalahan

Keuntungan dan Kekurangan

Keuntungan:

• Memberikan kontrol penuh atas manajemen memori.
• Cocok untuk struktur data yang memerlukan alokasi memori dinamis.

Kekurangan:

• Membutuhkan kehati-hatian ekstra untuk menghindari memory leak dan dangling pointer.
• Lebih kompleks dibandingkan alokasi memori otomatis.

Kesimpulan

Dynamic memory allocation dengan new dan delete adalah fitur penting dalam C++ untuk menangani situasi di mana kebutuhan memori tidak dapat ditentukan pada waktu kompilasi. Dengan memanfaatkan alokasi memori dinamis, Anda dapat mengelola memori secara lebih efisien. Namun, penting untuk selalu membebaskan memori yang tidak digunakan dan menangani pointer dengan hati-hati untuk menghindari masalah seperti memory leak dan dangling pointer.