Cara Memahami Referensi di Rust: Sebuah Panduan Praktis

Posted on by syauqi wiryahasana

Dalam bahasa pemrograman Rust, konsep kepemilikan dan peminjaman adalah inti dari manajemen memori. Mari kita bahas lebih lanjut mengenai referensi dalam Rust, dengan terlebih dahulu memahami sistem kepemilikan Rust.

Memahami Sistem Kepemilikan di Rust

Rust memiliki sistem kepemilikan unik, di mana setiap potongan data dalam memori hanya memiliki satu pemilik yang sah. Pemilik ini adalah variabel yang bertanggung jawab atas alokasi dan dealokasi memori untuk data tersebut. Data dapat disimpan di dua tempat: stack atau heap.

  • Stack: Variabel yang memiliki ukuran tetap, seperti integer, float, atau boolean, disimpan di stack. Penempatan data di stack sangat efisien karena prosesnya langsung dan cepat.
  • Heap: Variabel yang dapat berubah ukurannya, seperti string atau vector, disimpan di heap. Alokasi memori di heap lebih fleksibel, namun prosesnya lebih lambat karena memerlukan pencarian lokasi yang tepat di memori.

Contoh:

let x = 2; // Variabel 'x' disimpan di stack

let y = x; // Nilai 'x' disalin ke 'y' (copy murah di stack)

println!("x: {x}"); // Output: x: 2

println!("y: {y}"); // Output: y: 2

Perbedaan stack dan heap menjadi penting ketika kita membahas data di heap.

Contoh:

let a = "hello".to_string(); // Variabel 'a' disimpan di heap

let b = a; // 'b' menjadi pemilik baru data, 'a' menjadi invalid

println!("{a}"); // Error: 'a' tidak valid

Saat ‘b’ menjadi pemilik baru data, ‘a’ kehilangan aksesnya. Hal ini dilakukan agar tidak terjadi akses simultan yang tidak terkendali ke data yang sama.

Referensi dan Peminjaman

Terkadang, kita ingin mengakses data yang dimiliki oleh variabel lain tanpa mengambil kepemilikannya. Inilah konsep peminjaman. Peminjaman dilakukan dengan membuat pointer khusus yang menunjuk ke alamat memori pemilik data, pointer ini disebut referensi.

Contoh:

let a = "hello".to_string();

let b = &a; // 'b' adalah referensi ke 'a'

println!("a: {a}"); // Output: a: hello

println!("b: {b}"); // Output: b: hello

Aturan Peminjaman

Ada beberapa aturan yang harus diikuti saat membuat dan menggunakan referensi:

  1. Referensi selalu valid. Sebuah referensi hanya akan valid selama pemiliknya masih valid. Jika pemilik dipindahkan atau dihapus, semua referensi yang menunjuk padanya menjadi tidak valid.
  2. Pilihan: Referensi tidak dapat berubah atau dapat berubah. Ada dua jenis referensi:
    • Referensi tidak dapat berubah: Referensi ini hanya bisa membaca data. Mereka tidak dapat mengubah nilai yang mereka rujuk.
    • Referensi dapat berubah: Referensi ini dapat mengubah nilai data yang mereka rujuk.

Contoh:

let mut v = vec![0, 1, 2]; // 'v' dapat diubah

// Referensi yang dapat diubah:
let u = &mut v; 
u.push(3); // Mengubah isi 'v' melalui 'u'

println!("vector v: {v:?}"); // Output: vector v: [0, 1, 2, 3]
  1. Hanya satu referensi yang dapat diubah yang diizinkan. Kita hanya bisa memiliki satu referensi yang dapat diubah ke suatu data. Referensi lainnya harus bersifat tidak dapat diubah.

Contoh:

let mut a = vec![0, 1, 2];

let b = &a; // Referensi tidak dapat diubah

let c = &a; // Referensi tidak dapat diubah

let d = &mut a; // Referensi dapat diubah

d.push(3); // Mengubah 'a' melalui 'd'

println!("{c}"); // Error: 'c' tidak valid karena ada referensi 'd' yang dapat diubah

println!("{d:?}"); // Output: [0, 1, 2, 3]

Memperkenalkan Lifetime

Referensi tidak dapat hidup lebih lama daripada pemiliknya.

Contoh:

let s;

{
  let t = 5;
  s = &t; // 's' menunjuk ke 't'
}

println!("{s}"); // Error: 't' tidak valid

Ketika ‘t’ keluar dari cakupannya, ‘s’ menjadi tidak valid karena ‘s’ menunjuk ke memori yang sudah dibebaskan. Untuk menghindari masalah ini, Rust menggunakan konsep lifetime.

Lifetime adalah label yang diberikan kepada bagian dari kode tempat variabel didefinisikan.

Contoh:

fn main() {
  // LIFETIMES

  //---------------------- 'a
  let s;               //|
                       //|
  {                    //|
  //---------------'b    |
    let t = 5;  //|      |
                //|      |
    s = &t      //|      |
  //---------------'b    |
  }                    //|
  //---------------------|'a
}

Dalam contoh ini, ‘s’ memiliki lifetime ‘a’ yang lebih panjang daripada ‘t’ yang memiliki lifetime ‘b’. Ketika ‘t’ keluar dari cakupannya, ‘s’ menjadi tidak valid karena ‘s’ menunjuk ke memori yang sudah dibebaskan.

Lifetime dalam Fungsi

Dalam fungsi, lifetime seringkali diperlukan untuk menunjukkan bagaimana lifetime dari nilai yang dikembalikan terkait dengan lifetime parameter fungsi.

Contoh:

fn example_1() -> &i32 { // Error: 'x' keluar dari cakupannya
  let x = 2;
  &x
}

fn example_2(x: &i32) -> &i32 { // Valid: 'x' tetap valid
  &x
}

fn example_3<'a>(x: &'a i32, y: &'a i32) -> &'a i32 { // Valid: 'x' atau 'y' tetap valid
  &x
}

Kesimpulan

Referensi di Rust adalah konsep penting untuk memahami manajemen memori secara manual. Dengan memahami sistem kepemilikan dan aturan peminjaman, Anda dapat menulis kode yang efisien, aman, dan bebas dari error memori.