Ownership di Rust

Ownership adalah fitur paling unik di Rust — inilah yang memungkinkan Rust menjamin memory safety tanpa garbage collector. Konsep ini tidak ada di bahasa lain!

Tiga Aturan Ownership

1. Setiap value di Rust punya satu owner (pemilik)
2. Hanya boleh ada satu owner pada satu waktu
3. Ketika owner keluar dari scope, value akan di-drop (dihapus dari memori)

Move Semantics

let s1 = String::from("hello");
let s2 = s1;  // s1 di-MOVE ke s2

// println!("{}", s1);  // ERROR! s1 sudah tidak valid
println!("{}", s2);     // OK — s2 adalah owner baru

Ini berbeda dari bahasa lain di mana s2 = s1 hanya meng-copy reference. Di Rust, ownership berpindah — ini mencegah double-free bug.

Tipe yang Implement Copy

Tipe sederhana seperti integer, float, bool, dan char secara otomatis di-copy (bukan move):

let x = 5;
let y = x;  // x di-COPY, bukan di-move
println!("{} {}", x, y);  // OK! keduanya valid

Clone — Explicit Deep Copy

let s1 = String::from("hello");
let s2 = s1.clone();  // deep copy eksplisit

println!("{} {}", s1, s2);  // OK! keduanya valid

Ownership dan Fungsi

fn ambil_ownership(s: String) {
    println!("{}", s);
}  // s di-drop di sini

fn main() {
    let nama = String::from("Budi");
    ambil_ownership(nama);
    // println!("{}", nama);  // ERROR! nama sudah di-move
}

// Solusi: return ownership kembali
fn proses_dan_kembalikan(s: String) -> String {
    println!("Proses: {}", s);
    s  // kembalikan ownership
}

Kenapa Ownership Penting?

• No null pointers — variabel selalu valid selama masih dalam scope
• No double free — hanya satu owner yang bisa men-drop
• No use after free — compiler mencegah akses ke value yang sudah di-move
• No data races — ownership rules berlaku juga di concurrent code