Kita sudah melihat betapa rapuhnya pelepasan manual: cukup satu early return atau satu exception untuk melupakannya. RAII — singkatan dari Resource Acquisition Is Initialization — adalah idiom yang menghapus ketergantungan itu dengan satu langkah elegan: umur resource diikat pada umur sebuah objek. Resource di-acquire di constructor dan dilepas di destructor, sehingga begitu objek itu berakhir — di akhir blok, saat early return, maupun saat exception menyapu stack — destructor pasti berjalan dan resource pasti kembali. Idiom ini adalah tulang belakang pustaka standar C++: std::ofstream, std::string, std::vector, dan semua smart pointer bekerja dengan pola yang sama.

Mekanisme: Resource Sebagai Anggota Objek #

Nama panjangnya sering membingungkan pemula, jadi mari kita artikan maksudnya: inisialisasi objek (constructor) adalah momen yang tepat untuk meng-acquire resource, dan akhir hidup objek (destructor) adalah momen yang pasti datang untuk melepaskannya. Objek dengan automatic storage menjamin destructor dipanggil pada akhir blok — jaminan bahasa, bukan disiplin programmer. Tiga jalur keluar yang berbeda berakhir di titik yang sama:

Berkat jaminan itu, kita tidak lagi membaca fungsi sambil mencocokkan setiap return dengan baris pelepasan. Cukup memastikan alokasi dibungkus objek, dan compiler menyisipkan pelepasan di semua titik keluar secara otomatis.

Membungkus Array Heap dalam Kelas RAII #

Contoh berikut membangun kelas ArrayRAII yang membungkus array heap: constructor mengalokasikan, destructor melepas, dan satu function sengaja dipanggil dua kali dengan jalur keluar berbeda untuk membuktikan jaminannya.

cpp 
#include <cstddef>
#include <iostream>

class ArrayRAII {
public:
    explicit ArrayRAII(std::size_t n) : ukuran_(n), data_(new int[n]{}) {
        std::cout << "  [RAII] alokasi " << ukuran_ << " elemen\n";
    }
    ~ArrayRAII() {
        delete[] data_;
        std::cout << "  [RAII] array dibebaskan\n";
    }

    int& elemen(std::size_t i) { return data_[i]; }
    std::size_t ukuran() const { return ukuran_; }

private:
    std::size_t ukuran_;
    int* data_;
};

void prosesDenganEarlyReturn(bool valid) {
    ArrayRAII angka(4);
    if (!valid) {
        std::cout << "  data tidak valid, keluar lebih awal\n";
        return;   // destructor tetap berjalan: tidak ada kebocoran
    }

    for (std::size_t i = 0; i < angka.ukuran(); ++i) {
        angka.elemen(i) = static_cast<int>(i) * 100;
    }
    int total = 0;
    for (std::size_t i = 0; i < angka.ukuran(); ++i) {
        total += angka.elemen(i);
    }
    std::cout << "  total elemen: " << total << "\n";
}

int main() {
    std::cout << "panggilan 1:\n";
    prosesDenganEarlyReturn(true);
    std::cout << "panggilan 2:\n";
    prosesDenganEarlyReturn(false);
    std::cout << "main() selesai\n";
    return 0;
}

Output yang Dihasilkan:

text 
panggilan 1:
  [RAII] alokasi 4 elemen
  total elemen: 600
  [RAII] array dibebaskan
panggilan 2:
  [RAII] alokasi 4 elemen
  data tidak valid, keluar lebih awal
  [RAII] array dibebaskan
main() selesai

Bagian-bagian kuncinya layak dibedah satu per satu:

  1. Baris 6 (constructor): resource di-acquire di sini — new int[n]{} mengalokasikan n elemen bernilai nol. Akuisisi dan inisialisasi menyatu, sesuai nama idiomnya.
  2. Baris 9-12 (destructor): pelepasan yang kita tulis SATU kali, dan compiler yang menyisipkan pemanggilannya di semua jalur keluar.
  3. Baris 14-15 (elemen dan ukuran): antarmuka aman di atas resource; pengguna kelas tidak pernah melihat pointer mentahnya.
  4. Baris 26 (return; di jalur !valid): bukti utamanya ada di output panggilan 2 — meski fungsi keluar lebih awal, pesan [RAII] array dibebaskan tetap tercetak sebelum main() lanjut.

Perbandingan dua panggilan itu adalah inti RAII: jalur normal dan jalur early return menghasilkan keadaan yang sama — memori terlepas, nol kebocoran, tanpa satu baris pelepasan tambahan pun.

Keunggulan RAII yang Terukur #

  • Aman pada exception: stack unwinding memanggil destructor setiap objek otomatis yang sudah selesai dibangun — topik yang kita buktikan khusus di Chapter Exception-Safe Resource Management.
  • Aman pada early return: pelepasan tidak lagi berjarak dari alokasinya; keduanya berada di satu kelas yang sama.
  • Deterministik: resource kembali tepat saat scope berakhir, bukan saat garbage collector merasa perlu — perencanaan memori bisa dibaca langsung dari kode.
  • Teruji di pustaka standar: std::vector melepas elemennya, std::ofstream menutup berkasnya, dan std::lock_guard (Section Concurrency dan Parallelism) membuka mutexnya — semuanya RAII.

Membangun kelas RAII sendiri tetap berguna untuk resource khusus, tetapi untuk kasus kepemilikan memori standar pustaka sudah menyediakan alat jadi. Chapter berikutnya memperkenalkan std::unique_ptr — kelas RAII siap pakai untuk kepemilikan tunggal yang menjadi default kode C++ modern.

Referensi: cppreference — RAII , cppreference — destructor .