Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Reference dan Borrowing

Masalah pada kode tuple di Listing 4-5 adalah kita harus mengembalikan String ke fungsi yang memanggilnya agar String itu masih bisa kita pakai setelah pemanggilan calculate_length, karena String-nya sudah dipindahkan ke dalam calculate_length. Sebagai gantinya, kita bisa memberikan reference ke nilai String itu. Reference itu mirip pointer: keduanya berisi alamat yang bisa kita ikuti untuk mengakses data tersimpan di alamat tersebut, dan data itu dimiliki oleh variabel lain. Beda dengan pointer, reference dijamin menunjuk ke nilai valid bertipe tertentu selama reference itu masih ada.

Begini cara kamu mendefinisikan dan memakai fungsi calculate_length yang menerima reference ke sebuah objek sebagai parameter, alih-alih mengambil ownership atas nilai tersebut:

Filename: src/main.rs
fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Pertama, perhatikan bahwa seluruh kode tuple pada deklarasi variabel dan nilai kembalian fungsi sudah hilang. Kedua, perhatikan bahwa kita mengoper &s1 ke calculate_length dan pada tanda tangannya kita memakai &String alih-alih String. Tanda ampersand itu adalah reference; dengannya kamu bisa merujuk ke suatu nilai tanpa mengambil ownership-nya. Gambar 4-6 menggambarkan konsep ini.

Tiga tabel: tabel untuk s hanya berisi pointer ke tabel untuk s1.
Tabel s1 berisi data stack milik s1 dan menunjuk ke data string di heap.

Gambar 4-6: Diagram &String s yang menunjuk ke String s1

Catatan: Kebalikan dari membuat reference dengan & adalah dereferencing, yang dilakukan dengan operator dereference, *. Kita akan melihat beberapa kegunaan operator dereference di Bab 8 dan membahas detail dereferencing di Bab 15.

Mari kita lihat lebih dekat pemanggilan fungsi di sini:

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Sintaks &s1 membuat reference yang merujuk ke nilai s1 tetapi tidak memiliki nilai itu. Karena reference itu tidak memiliki nilainya, nilai yang ditunjuknya tidak akan di-drop saat reference berhenti dipakai.

Begitu pula, tanda tangan fungsi memakai & untuk menunjukkan bahwa tipe parameter s adalah reference. Mari kita tambahkan beberapa anotasi penjelas:

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize { // s is a reference to a String
    s.len()
} // Here, s goes out of scope. But because s does not have ownership of what
  // it refers to, the String is not dropped.

Scope tempat variabel s berlaku sama seperti scope parameter fungsi mana pun, tetapi nilai yang ditunjuk reference tidak di-drop saat s berhenti dipakai, karena s tidak memiliki ownership. Ketika fungsi menerima reference sebagai parameter alih-alih nilai sebenarnya, kita tidak perlu mengembalikan nilai itu untuk mengembalikan ownership, karena memang sejak awal kita tidak pernah memilikinya.

Tindakan membuat reference kita sebut borrowing. Seperti dalam kehidupan nyata: kalau seseorang memiliki sesuatu, kamu bisa meminjamnya darinya. Setelah selesai, kamu harus mengembalikannya. Kamu bukan pemiliknya.

Lalu, bagaimana kalau kita mencoba memodifikasi sesuatu yang sedang kita pinjam? Coba kode di Listing 4-6. Spoiler alert: kode itu tidak berhasil!

Filename: src/main.rs
fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}
Listing 4-6: Mencoba memodifikasi nilai yang dipinjam

Inilah error dari compiler:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
8 |     some_string.push_str(", world");
  |     ^^^^^^^^^^^ `some_string` is a `&` reference, so it cannot be borrowed as mutable
  |
help: consider changing this to be a mutable reference
  |
7 | fn change(some_string: &mut String) {
  |                         +++

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Sama seperti variabel yang immutable secara default, reference juga begitu. Kita tidak boleh memodifikasi sesuatu yang sedang kita rujuk.

Reference Mutable

Kita bisa memperbaiki kode dari Listing 4-6 agar kita bisa memodifikasi nilai yang dipinjam, cukup dengan beberapa perubahan kecil yang memakai sebuah reference mutable:

Filename: src/main.rs
fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

Pertama, kita ubah s menjadi mut. Lalu, kita buat reference mutable dengan &mut s di tempat kita memanggil fungsi change, dan memperbarui tanda tangan fungsi agar menerima reference mutable lewat some_string: &mut String. Dengan begitu, jelas sekali bahwa fungsi change akan memutasi nilai yang dipinjamnya.

Reference mutable punya satu pembatasan besar: kalau kamu punya reference mutable ke suatu nilai, kamu tidak boleh punya reference lain ke nilai itu. Kode berikut yang mencoba membuat dua reference mutable ke s akan gagal:

Filename: src/main.rs
fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{r1}, {r2}");
}

Inilah error dari compiler:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{r1}, {r2}");
  |                -- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Error ini menyatakan bahwa kode itu tidak valid karena kita tidak bisa meminjam s sebagai mutable lebih dari satu kali dalam satu waktu. Borrow pertama ada di r1 dan harus bertahan sampai r1 dipakai di println!, tapi di antara pembuatan reference mutable itu dan pemakaiannya, kita sudah mencoba membuat reference mutable lain di r2 yang meminjam data yang sama dengan r1.

Pembatasan yang melarang banyak reference mutable pada data yang sama di waktu bersamaan tetap memungkinkan mutasi, hanya saja dengan cara yang sangat terkendali. Hal ini sering membuat Rustacean baru kesulitan, karena di kebanyakan bahasa kamu bebas memutasi kapan pun kamu mau. Keuntungan dari pembatasan ini adalah Rust bisa mencegah data race saat kompilasi. Sebuah data race mirip dengan race condition dan terjadi ketika tiga hal berikut terpenuhi:

  • Dua pointer atau lebih mengakses data yang sama di waktu yang sama.
  • Setidaknya satu dari pointer itu dipakai untuk menulis ke data tersebut.
  • Tidak ada mekanisme apa pun yang dipakai untuk menyinkronkan akses ke data tersebut.

Data race menyebabkan undefined behavior dan bisa sulit didiagnosis serta diperbaiki saat kamu menelusurinya di runtime; Rust mencegah masalah ini dengan menolak mengompilasi kode yang mengandung data race!

Seperti biasa, kita bisa memakai kurung kurawal untuk membuat scope baru, sehingga boleh ada banyak reference mutable—hanya saja tidak bersamaan:

fn main() {
    let mut s = String::from("hello");

    {
        let r1 = &mut s;
    } // r1 goes out of scope here, so we can make a new reference with no problems.

    let r2 = &mut s;
}

Rust memberlakukan aturan serupa untuk menggabungkan reference mutable dan immutable. Kode berikut menghasilkan error:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    let r3 = &mut s; // BIG PROBLEM

    println!("{r1}, {r2}, and {r3}");
}

Inilah error dari compiler:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &s; // no problem
  |              -- immutable borrow occurs here
5 |     let r2 = &s; // no problem
6 |     let r3 = &mut s; // BIG PROBLEM
  |              ^^^^^^ mutable borrow occurs here
7 |
8 |     println!("{r1}, {r2}, and {r3}");
  |                -- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Fiuh! Kita juga tidak boleh punya reference mutable ketika kita sedang punya reference immutable ke nilai yang sama.

Pengguna reference immutable tidak mengharapkan nilainya tiba-tiba berubah tanpa mereka sadari! Namun, banyak reference immutable diizinkan karena siapa pun yang hanya membaca data tidak dapat memengaruhi cara orang lain membaca data itu.

Perhatikan bahwa scope sebuah reference dimulai dari tempat reference itu diperkenalkan dan berlanjut sampai terakhir kali reference itu dipakai. Sebagai contoh, kode berikut akan terkompilasi karena pemakaian terakhir reference immutable ada di println!, sebelum reference mutable diperkenalkan:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{r1} and {r2}");
    // Variables r1 and r2 will not be used after this point.

    let r3 = &mut s; // no problem
    println!("{r3}");
}

Scope reference immutable r1 dan r2 berakhir setelah println! tempat terakhir kali keduanya dipakai, yaitu sebelum reference mutable r3 dibuat. Scope ini tidak saling tumpang tindih, jadi kode ini diizinkan: compiler bisa melihat bahwa reference sudah tidak dipakai pada titik sebelum akhir scope.

Meski error borrowing kadang membuat frustrasi, ingatlah bahwa yang menunjukkan potensi bug lebih awal adalah Rust compiler (saat kompilasi, bukan saat runtime) dan menunjukkan tepat di mana masalahnya. Jadi, kamu tidak perlu menelusuri mengapa data kamu bukan seperti yang kamu kira.

Reference yang Menggantung

Di bahasa yang memakai pointer, mudah sekali membuat pointer menggantung—pointer yang merujuk ke lokasi memori yang mungkin sudah diberikan ke pihak lain—dengan membebaskan sebagian memori sambil tetap menyimpan pointer ke memori itu. Di Rust, sebaliknya, compiler menjamin reference tidak akan pernah menjadi reference yang menggantung: kalau kamu punya reference ke suatu data, compiler memastikan data itu tidak keluar scope sebelum reference-nya sendiri keluar scope.

Mari kita coba membuat reference yang menggantung untuk melihat bagaimana Rust mencegahnya dengan error waktu kompilasi:

Filename: src/main.rs
fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

Inilah error dari compiler:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
5 | fn dangle() -> &'static String {
  |                 +++++++
help: instead, you are more likely to want to return an owned value
  |
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Pesan error ini menunjuk ke fitur yang belum kita bahas: lifetime. Kita akan membahas lifetime secara detail di Bab 10. Tapi kalau kamu abaikan bagian tentang lifetime, pesan itu tetap memuat kunci mengapa kode ini bermasalah:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from

Mari kita lihat lebih dekat apa yang terjadi di setiap tahap kode dangle kita:

Filename: src/main.rs
fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // dangle returns a reference to a String

    let s = String::from("hello"); // s is a new String

    &s // we return a reference to the String, s
} // Here, s goes out of scope and is dropped, so its memory goes away.
  // Danger!

Karena s dibuat di dalam dangle, begitu kode dangle selesai, s akan didealokasi. Tapi kita mencoba mengembalikan reference ke s. Artinya reference itu akan menunjuk ke String yang tidak valid. Itu buruk! Rust tidak membiarkan kita melakukan itu.

Solusinya di sini adalah mengembalikan String secara langsung:

fn main() {
    let string = no_dangle();
}

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

Cara ini berjalan tanpa masalah apa pun. Ownership dipindahkan keluar, dan tidak ada yang didealokasi.

Aturan Reference

Mari kita rangkum apa yang sudah kita bahas tentang reference:

  • Pada satu waktu, kamu boleh punya satu reference mutable atau berapa pun banyaknya reference immutable.
  • Reference harus selalu valid.

Selanjutnya, kita akan melihat jenis reference lain: slice.