Petunjuk Cerdas di Rust: Bagaimana Cara Kerjanya?

Manajemen memori adalah salah satu nilai jual Rust, terutama karena keamanannya tidak terganggu. Sistem kepemilikan Rust memungkinkan kompiler untuk menjamin keamanan kode dan kebebasan dari kesalahan memori seperti penunjuk yang menggantung dan kebocoran memori.

Rust juga menyediakan smart pointer dengan metadata tambahan dan kemampuan di luar pointer tradisional. Pointer pintar berguna untuk mengatasi kebocoran memori.

Apa Itu Smart Pointer di Rust?

Pointer pintar adalah salah satu tipe data Rust yang memperluas kemampuan pointer biasa dengan menawarkan fungsionalitas tambahan seperti operator kelebihan beban, destruktor, dan manajemen memori otomatis.

Baca Juga:

Mau Berkarir di Dunia blockchain? Ini Dia 10 Skill yang Harus Kamu Dalami!

Rust menggunakan struct untuk mengeksekusi smart pointer; dengan demikian, smart pointer juga memiliki kemampuan kepemilikan.

Saat Anda menautkan memori yang berisi data yang dialokasikan secara dinamis dengan smart pointer, memori tersebut secara otomatis dibatalkan alokasinya. Pointer pintar menyediakan fungsionalitas untuk mengontrol masa pakai objek Rust, membuatnya berguna untuk mencegah kesalahan seperti dereferensi pointer nol dan kebocoran memori yang populer di bahasa level rendah lainnya seperti C dan C++.

Manfaat Menggunakan Smart Pointer

Berikut adalah beberapa manfaat menggunakan smart pointer:

1. Manajemen Memori Otomatis: Smart pointer menyediakan manajemen memori otomatis, termasuk alokasi dan dealokasi, berbeda dengan manajemen memori manual dengan pointer biasa.
2. Keamanan yang Ditingkatkan: Smart pointer menerapkan semantik kepemilikan, memastikan bahwa hanya satu pemilik yang dapat mengakses sumber daya per waktu, mencegah pelacakan data dan bug terkait konkurensi.
3. Fleksibilitas: Rust menyediakan beberapa smart pointer, masing-masing dengan kumpulan semantik kepemilikan untuk menulis kode yang aman secara fleksibel.
4. Pengelolaan sumber daya: Anda dapat menggunakan penunjuk cerdas untuk mengelola sumber daya lain seperti penangan file dan soket jaringan dengan mengenkapsulasi sumber daya di dalam penunjuk cerdas yang mempermudah pengelolaan siklus hidup mereka dan memastikan bahwa mereka ditutup dan dirilis dengan benar setelah digunakan.
5. Peningkatan Kinerja: Penunjuk pintar membantu meningkatkan kinerja dengan mengurangi penyalinan dan alokasi memori—mengurangi jejak memori dari penggunaan penunjuk pintar menghasilkan peningkatan kinerja.

Smart pointer cocok untuk aplikasi berukuran sedang hingga besar, terutama dalam kasus di mana manajemen memori sangat penting.

Jenis Smart Pointer

Rust menyediakan berbagai jenis smart pointer, termasuk Kotak, Rc, RefCellDan Mutex.

1. Penunjuk Cerdas Kotak

Itu Kotak Smart Pointer adalah pointer pintar Rust yang paling sederhana dan paling umum. Itu Kotak smart pointer membantu mengalokasikan nilai pada heap dan membuat pointer kotak untuk aksesibilitas.

Itu Kotak Smart Pointer berguna untuk alokasi memori dinamis saat Anda perlu memastikan bahwa memori secara otomatis dibatalkan alokasinya saat pointer berada di luar jangkauan.

Inilah cara Anda dapat mendeklarasikan dan menggunakan a Kotak petunjuk:

 fn main(){
    
    let x = Box::new(5);
    println!(x)
}
 

Itu Kotak type adalah bagian dari pendahuluan Rust, jadi Anda tidak perlu mengimpor jenisnya, tidak seperti smart pointer lainnya.

Itu X variabel adalah a Kotak pointer menunjuk ke 5 nilai integer. Rust mengalokasikan memori untuk nilai di heap dan secara otomatis membatalkan alokasi ketika variabel berada di luar cakupan.

2. Penunjuk Cerdas Rc

Itu Rc (Referensi Dihitung) smart pointer menyediakan fungsionalitas untuk menciptakan nilai kepemilikan bersama. Itu Rc smart pointer melacak jumlah referensi ke suatu nilai dan membatalkan alokasi nilai saat referensi terakhir berada di luar cakupan.

Itu Rc smart pointer berguna saat Anda perlu berbagi kepemilikan nilai untuk aksesibilitas di beberapa bagian program Anda.

Untuk mendeklarasikan suatu Rc smart pointer, Anda akan mengimpor Rc struct dari pustaka standar, nyatakan yang baru Rc penunjuk dengan baru fungsi, dan mengkloning variabel pointer dengan klon variabel.

 use std::rc::Rc;
fn main() {
    
    let x = Rc::new(5);
    let y = Rc::clone(&x);
    println!("x = {}, y = {}", x, y);
}
 

Itu X variabel adalah Rc variabel pointer, dan the y variabel adalah tiruan dengan akses ke nilai dalam memori. Jumlah referensi adalah dua, dan nilainya tidak dialokasikan dari memori saat variabel berada di luar cakupan.

3. Penunjuk Cerdas RefCell

Itu RefCell smart pointer menyediakan mutabilitas interior yang memungkinkan referensi yang tidak dapat diubah dan dapat diubah untuk hidup berdampingan selama ada satu referensi yang dapat diubah per waktu tertentu.

Itu RefCell smart pointer berguna saat memutasi nilai yang dimiliki oleh referensi yang bisa berubah.

Itu Refsel function bukan bagian dari pendahuluan Rust, jadi Anda harus mengimpor struct dari pustaka standar untuk menggunakan smart pointer.

 use std::cell::RefCell;
fn main(){
    
    let x = RefCell::new(5);
    let y = x.borrow();
    let z = x.borrow_mut();
    println!("y = {}", *y);
    println!("z = {}", *z);
} 
 

Itu Refsel smart pointer berisi nilai, dan y variabel adalah referensi abadi ke nilai. Itu pinjam_mut fungsi membuat referensi nilai yang bisa berubah.

Program aman jika hanya ada satu referensi yang dapat diubah pada satu waktu.

4. Penunjuk Cerdas Mutex

Itu Mutex smart pointer memberikan pengecualian bersama. Itu Mutex smart pointer berguna untuk menyinkronkan akses ke nilai-nilai di beberapa utas dalam program bersamaan.

Itu Mutex smart pointer memberikan pengecualian timbal balik untuk memastikan bahwa hanya satu utas yang dapat mengakses nilai sambil mencegah pelacakan data.

Anda harus mengimpor Mutex struct dan buat instance baru dengan baru fungsi untuk digunakan Mutex Pointer Cerdas di Rust.

 use std::sync::Mutex;
fn main() {
    
    let counter = Mutex::new(0);
    {
        let mut num = counter.lock().unwrap();
        *num += 1;
    }
    println!("Result: {}", *counter.lock().unwrap());
}
 

Itu menangkal variabel adalah yang baru Mutex contoh. Itu utama fungsi memperoleh kunci pada mutex dengan kunci metode dari Mutex contoh. Kunci memungkinkan modifikasi nilai penghitung yang aman sebelum melepaskan kunci dan mencetak nilainya.

Itu Mutex type menjamin bahwa hanya satu utas yang dapat mengakses sumber daya bersama (dalam hal ini, file menangkal variabel) dan memodifikasi nilainya pada suatu waktu. Pengecualian bersama memastikan akses bersamaan ke sumber daya bersama diserialkan untuk mencegah pelacakan data dan masalah konkurensi lainnya.

Model Kepemilikan Rust Menjamin Keamanan Memori

Smart pointer adalah salah satu pendekatan Rust untuk keamanan dan fleksibilitas memori. Model kepemilikan Rust memastikan bahwa program menggunakan memori dengan aman dengan pemeriksa pinjaman pada waktu kompilasi.

Pemeriksa pinjaman adalah fitur penting dari model kepemilikan Rust yang memberlakukan aturan ketat untuk aksesibilitas dan modifikasi memori.