Memahami Ownership, Borrowing, dan Reference di Rust

"Rust tidak punya garbage collector, tapii dia tetap tahu kapan data harus dibuang. Kok bisaa? Ownership dan Borrowing."

1. Ownership: Siapa yang Punya Barang?

Bayangin kamu punya buku catatan berjudul "Robotika AI".

let buku = String::from("Robotika AI");

Artinya buku adalah pemilik sah dari data string "Robotika AI" di heap. Kalau buku hilang (keluar scope), maka isi string itu ikut dihapus (Rust otomatis panggil drop()).

Kalau kamu coba kasih buku itu ke orang lain:

let buku = String::from("Robotika AI");
let pinjam = buku;
println!("{}", buku); // error: `buku` sudah pindah kepemilikan dari variabel buku ke variabel pinjam

Rust langsung cegah error semacam double free dengan move semantics:

• Ownership pindah ke pinjam
• buku tidak bisa diakses lagi

2. Borrowing: Pinjam, Bukan Ambil

Kadang kamu gak mau ngasih kepemilikan, cuma mau minjemin. Nah, di sinilah konsep borrowing muncul, pakai & untuk pinjaman baca, dan &mut untuk pinjaman ubah.

Immutable Borrow (pinjam baca)

fn baca(b: &String) {
    println!("Judul: {}", b);
}

fn main() {
    let buku = String::from("Robotika AI");
    baca(&buku);
    println!("Masih bisa dipakai: {}", buku); // ownership tetap
}

• baca() hanya pinjam, tidak mengambil.
• Boleh banyak pinjaman baca sekaligus.

Aturan:

Boleh banyak &T, tapi tidak boleh ada &mut T aktif bersamaan.

Mutable Borrow (pinjam ubah)

fn edit(b: &mut String) {
    b.push_str(" - Edisi 2");
}

fn main() {
    let mut buku = String::from("Robotika AI");
    edit(&mut buku);
    println!("{}", buku); // sudah berubah
}

Aturan:

Boleh satu &mut T, tapi tidak boleh ada &T lain saat itu aktif.

Rust pastikan gak ada dua tangan ngedit barang yang sama secara bersamaan (race condition prevention).

3. Reference = Tiket Pinjaman

& di Rust itu bukan “copy data”, tapi pointer aman yang menunjuk ke data asli di memori. Contoh:

let s = String::from("Uke");
let r = &s;
println!("{}", r); // baca lewat tiket pinjaman

Rust tahu:

• s punya datanya.
• r cuma punya “tiket baca”.

Dan karena Rust cek semuanya di compile time, gak ada kemungkinan dangling reference kayak di C/C++.

4. Cara Baca Kode Biar Ringan

Rust memang verbose di awal, tapi bisa kamu baca kayak narasi:

fn main() {
    let mut nama = String::from("Uke");
    sapa(&nama);
    ubah(&mut nama);
    println!("Akhirnya: {}", nama);
}

Baca kayak cerita:

Aku punya nama. Aku pinjemin buat dibaca (&nama). Lalu aku pinjemin buat diubah (&mut nama). Setelah dikembalikan, aku print hasil akhirnya.

: di parameter berfungsi mendefinisikan tipe data dan aturan kepemilikan/izin akses:

5. Alur Saat Fungsi Dijalankan

1. Compile-time: Rust cek dulu apakah tipe parameter cocok (&String, String, dsb)
2. Runtime: Baru reference dibuat, dan fungsi dijalankan.
3. Scope selesai: Borrow otomatis dikembalikan ke pemilik aslinya.

main()                   fn sapa(s: &String)
┌──────────────┐          ┌────────────────────┐
│ nama: String │──&──▶───│ s: &String (pinjam)│
└──────────────┘          └────────────────────┘

6. Aturan Emas Ownership & Borrowing

Kesimpulan

Ownership menentukan siapa pemilik data. Borrowing menentukan siapa yang boleh pegang sementara. Reference adalah tiket pinjaman itu sendiri.

Semua dicek sebelum program jalan, jadi Rust aman tanpa GC.