Penjelasan Destructor C++: ~ClassName, RAII, Pembersihan

Apa Itu Destructor

Di halaman sebelumnya kamu melihat constructor, yaitu fungsi khusus yang berjalan saat objek lahir untuk menyiapkan keadaan awalnya. Destructor adalah kebalikannya: fungsi khusus yang berjalan saat objek mati, untuk membereskan sisa-sisanya.

Kamu mendeklarasikannya dengan nama class yang diawali tanda tilde (~). Ia tidak menerima parameter, tidak mengembalikan apa pun, dan sebuah class punya tepat satu destructor. Kamu hampir tidak pernah memanggilnya secara manual; C++ memanggilkannya untukmu di saat yang tepat.

#include <iostream>
using namespace std;

class Logger {
public:
    Logger()  { cout << "Logger created\n"; }   // constructor
    ~Logger() { cout << "Logger destroyed\n"; }  // destructor
};

int main() {
    Logger log;                  // "Logger created"
    cout << "doing work...\n";
    return 0;
}                                // "Logger destroyed" runs here, automatically

Perhatikan bahwa pesan destructor dicetak setelah main menyelesaikan isinya, tetapi sebelum program keluar. Saat log keluar dari scope di kurung kurawal penutup, C++ menjalankan ~Logger() untukmu.

Kapan Destructor Berjalan

Waktu tepatnya bergantung pada tempat objek itu berada:

• Objek di stack (lokal) dihancurkan saat keluar dari scope, yaitu di } penutup blok.
• Objek di heap (dibuat dengan new) dihancurkan saat kamu memanggil delete. Kalau kamu lupa delete, destructor-nya tidak pernah berjalan dan terjadi kebocoran memori.

Contoh ini memperlihatkan perbedaannya:

#include <iostream>
using namespace std;

class Tagged {
    int id;
public:
    Tagged(int i) : id(i) { cout << "create " << id << "\n"; }
    ~Tagged()             { cout << "destroy " << id << "\n"; }
};

int main() {
    Tagged a(1);              // create 1

    {
        Tagged b(2);          // create 2
    }                         // destroy 2  (b leaves its inner scope)

    Tagged* c = new Tagged(3); // create 3
    delete c;                 // destroy 3  (you must trigger this)

    return 0;
}                             // destroy 1  (a leaves main)

Objek dihancurkan dengan urutan kebalikan dari pembuatannya. a dibuat pertama, jadi ia mati paling akhir. Urutan LIFO (last-in, first-out) ini penting saat objek-objek saling bergantung.

Kenapa Destructor Penting: RAII

Kekuatan sebenarnya dari destructor adalah membuat pembersihan berjalan otomatis dan aman terhadap exception. Daripada mengingat untuk melepaskan resource di setiap jalur kode, kamu menaruh pelepasan itu di destructor dan membiarkan bahasa menjamin ia berjalan. Pola ini disebut RAII (Resource Acquisition Is Initialization), dan merupakan tulang punggung C++ modern.

Di sini sebuah class memiliki buffer di heap: ia mengalokasikannya di constructor dan membebaskannya di destructor, sehingga pemanggilnya tidak pernah menyentuh new/delete sendiri.

#include <iostream>
using namespace std;

class IntArray {
    int* data;
    int size;
public:
    IntArray(int n) : data(new int[n]), size(n) {
        for (int i = 0; i < size; ++i) data[i] = i * i;
        cout << "allocated " << size << " ints\n";
    }
    ~IntArray() {
        delete[] data;                 // matches the new[] above
        cout << "freed the buffer\n";
    }
    int at(int i) const { return data[i]; }
};

int main() {
    IntArray squares(5);
    cout << "squares[3] = " << squares.at(3) << "\n";  // 9
    return 0;
}   // ~IntArray() runs here: the buffer is freed even if we forgot to

Wawasan pentingnya: bahkan kalau sebuah exception dilempar setelah squares dibuat, stack akan di-unwind dan ~IntArray() tetap berjalan. Jaminan itulah yang membuat RAII begitu andal, dan alasan kamu jarang menulis delete secara langsung di kode C++ yang baik.

Rule of Three (dan Five)

Class dengan destructor buatan sendiri hampir selalu memiliki resource mentah, dan itu memunculkan bahaya tersembunyi. Copy constructor dan copy assignment yang dibuat compiler melakukan salinan dangkal (shallow copy): yang disalin adalah pointer-nya, bukan buffer yang ditunjuknya. Sekarang dua objek memegang pointer yang sama, dan kedua destructor akan melakukan delete padanya, sehingga program crash karena double free.

IntArray a(5);
IntArray b = a;   // shallow copy: a.data and b.data are the SAME pointer
// at scope end: b's destructor frees the buffer,
// then a's destructor frees it AGAIN -> undefined behavior (double free)

Inilah asal Rule of Three: kalau kamu menulis salah satu dari destructor, copy constructor, atau copy assignment operator, hampir pasti kamu butuh ketiganya. Di C++11 ke atas aturan ini diperluas menjadi Rule of Five, dengan tambahan move constructor dan move assignment.

Namun ada aturan yang lebih baik lagi, yaitu Rule of Zero: rancang class supaya kamu sama sekali tidak mengelola resource mentah. Simpan std::vector, std::string, atau smart pointer sebagai gantinya, dan destructor buatan compiler akan bekerja dengan benar tanpa usaha tambahan.

#include <iostream>
#include <vector>
using namespace std;

class IntArray {
    vector<int> data;              // manages its own memory
public:
    IntArray(int n) : data(n) {
        for (int i = 0; i < n; ++i) data[i] = i * i;
    }
    int at(int i) const { return data[i]; }
    // No destructor, no copy/move code needed: vector handles all of it.
};

int main() {
    IntArray a(5);
    IntArray b = a;                // safe deep copy - vector copies itself
    cout << b.at(3) << "\n";       // 9
    return 0;
}

Jadikan Rule of Zero sebagai pilihan default. Tulis destructor sendiri hanya kalau kamu benar-benar memiliki resource mentah yang tidak dibungkus oleh tipe standar mana pun.

Virtual Destructor

Saat kamu menghapus objek lewat pointer base class, destructor-nya harus virtual. Kalau tidak, hanya bagian base-nya yang dihancurkan dan bagian turunannya bocor. Ini salah satu bug paling umum di kode polimorfik, dan secara default compiler tidak akan memperingatkanmu.

#include <iostream>
using namespace std;

struct Base {
    virtual ~Base() { cout << "~Base\n"; }   // virtual is essential here
};

struct Derived : Base {
    ~Derived() { cout << "~Derived\n"; }
};

int main() {
    Base* p = new Derived();
    delete p;                  // ~Derived then ~Base, both run correctly
    return 0;
}

Tanpa virtual pada ~Base, delete p hanya akan memanggil ~Base(). Itu undefined behavior, dan bagian Derived dari objek tidak pernah dibersihkan. Patokannya: setiap class yang punya virtual function (base class polimorfik) butuh virtual destructor. Kamu akan melihat persis kenapa ini penting begitu kamu mulai menurunkan class.

Kesalahan Umum dan Jebakan

Beberapa jebakan menjebak hampir semua orang:

new/delete yang tidak berpasangan. Kalau kamu mengalokasikan dengan new[], bebaskan dengan delete[]. Mencampur new[] dengan delete biasa (atau sebaliknya) adalah undefined behavior.

Lupa virtual pada destructor base class. Seperti di atas, menghapus objek turunan lewat pointer base tanpa virtual destructor membuat bagian turunannya bocor. Kalau kamu menulis class yang dimaksudkan untuk diturunkan, jadikan destructor-nya virtual.

Membiarkan exception keluar dari destructor. Destructor yang melempar exception saat stack unwinding akan menghentikan programmu. Destructor secara implisit bersifat noexcept di C++ modern, jadi jaga agar kode pembersihan tidak melempar exception, atau tangkap exception itu di dalam destructor.

Menulis destructor yang tidak kamu butuhkan. Kalau member-mu sudah membersihkan dirinya sendiri, ~ClassName() {} yang kosong hanya menambah keramaian dan bisa diam-diam menonaktifkan operasi move. Kalau tidak ada yang perlu dibersihkan, jangan tulis destructor sama sekali.

Berikutnya: Pewarisan

Sekarang kamu sudah melihat siklus hidup lengkap sebuah objek: constructor menghidupkannya, destructor membersihkannya, dan destructor virtual menjaga pembersihan itu tetap benar saat satu class dibangun di atas class lain. Poin terakhir itu adalah gambaran awal dari ide besar berikutnya, yaitu pewarisan (inheritance), ketika sebuah class memakai ulang dan memperluas data serta perilaku class lain. Halaman berikutnya menunjukkan cara menurunkan satu class dari class lain, bagaimana pembuatan dan penghancuran objek berantai di sepanjang hierarki, dan bagaimana potongan-potongan yang baru kamu pelajari saling melengkapi.