0Pricing
Learn Rust Coding · Pelajaran

Berinteraksi dengan Rust Tidak Aman

Pahami kapan dan bagaimana menggunakan blok `unsafe` untuk melewati pemeriksaan keamanan Rust, sehingga FFI dan operasi memori tingkat rendah dapat dilakukan.

Berinteraksi dengan Rust Tidak Aman adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Rust Tidak Aman: Pengantar

Selamat datang di Rust Tidak Aman! Meskipun Rust terkenal karena jaminan keamanan memorinya, ada situasi tertentu ketika Anda mungkin perlu melewati sebagian pemeriksaan tersebut.

Kata kunci unsafe dalam Rust memungkinkan Anda melakukan hal itu. Ini bukan cara untuk menulis kode yang 'buruk', melainkan alat untuk kasus penggunaan tingkat lanjut yang memerlukan kendali lebih langsung atas memori atau perangkat keras.

Lima Kemampuan Khusus dalam `unsafe`

Saat Anda menggunakan blok unsafe, Anda mendapatkan akses ke lima tindakan khusus yang biasanya dicegah oleh kompiler Rust:

  • Menghapus referensi penunjuk mentah: Mengakses alamat memori secara langsung.
  • Memanggil fungsi atau metode unsafe: Menjalankan fungsi dengan prasyarat yang tidak dapat diverifikasi oleh kompiler.
  • Menerapkan trait unsafe: Menyatakan bahwa tipe Anda memenuhi invarian tertentu.
  • Mengakses atau mengubah variable statis yang dapat diubah: Membagikan keadaan yang dapat diubah secara global, dengan risiko perlombaan data.
  • Mengakses field dari union: Membaca dari union, yang mungkin bukan tipe yang valid untuk data saat ini.

Menghapus Referensi Penunjuk Mentah

Penunjuk mentah adalah alamat memori tanpa jaminan keamanan Rust seperti biasanya. Anda dapat membuatnya dari referensi (&T, &mut T), tetapi menghapus referensinya memerlukan blok unsafe.

Artinya, Anda sebagai pemrogram bertanggung jawab memastikan penunjuk tersebut valid dan menunjuk ke memori yang telah dialokasikan.

fn main() {
  let mut num = 5;
  let r1 = &num as *const i32; // Immutable raw pointer
  let r2 = &mut num as *mut i32; // Mutable raw pointer

  unsafe { // The `unsafe` block starts here
    println!("r1 points to: {}", *r1);
    *r2 = 10; // Modify data through mutable raw pointer
    println!("r2 points to: {}", *r2);
  } // The `unsafe` block ends here

  println!("Num is now: {}", num);
}

Memanggil Fungsi Tidak Aman

Beberapa fungsi ditandai sebagai unsafe fn. Artinya, fungsi tersebut memiliki prasyarat yang tidak dapat dijamin oleh kompiler Rust. Misalnya, sebuah fungsi mungkin mengharapkan alamat memori yang valid, tetapi tidak dapat memverifikasinya.

Pemanggilan fungsi semacam itu harus dibungkus dalam blok unsafe, yang menunjukkan bahwa Anda sebagai pemanggil memastikan semua prasyarat telah terpenuhi.

unsafe fn dangerous_operation() {
  println!("This operation could be dangerous if preconditions aren't met!");
}

fn main() {
  println!("Attempting a dangerous operation...");
  unsafe { // Calling an unsafe function requires `unsafe`
    dangerous_operation();
  }
  println!("Operation completed.");
}

Variable Statis yang Dapat Diubah

Rust secara bawaan mencegah keadaan global yang dapat diubah untuk menghindari perlombaan data. Namun, Anda dapat mendeklarasikan variable statis yang dapat diubah menggunakan static mut.

Mengakses atau mengubah variable ini dianggap unsafe karena beberapa thread dapat mencoba mengaksesnya secara bersamaan, yang dapat menyebabkan perilaku tidak terdefinisi. Sinkronisasi yang tepat merupakan tanggung jawab Anda.

static mut COUNTER: i32 = 0; // A mutable static variable

fn add_to_counter(inc: i32) {
  unsafe { // Modifying `static mut` requires `unsafe`
    COUNTER += inc;
  }
}

fn main() {
  add_to_counter(5);
  unsafe { // Reading `static mut` also requires `unsafe`
    println!("COUNTER after first add: {}", COUNTER);
  }

  add_to_counter(10);
  unsafe {
    println!("COUNTER after second add: {}", COUNTER);
  }
}

Menerapkan Trait Tidak Aman

Beberapa trait dalam Rust ditandai sebagai unsafe trait. Ini menandakan bahwa penerapannya mengharuskan Anda memenuhi invarian tertentu yang tidak dapat diperiksa oleh kompiler.

Contoh umum adalah trait Send dan Sync, yang berkaitan dengan keamanan thread. Jika Anda menerapkan unsafe trait secara manual, Anda harus menggunakan unsafe impl Trait for Type dan menjamin properti keamanannya.

Bagi sebagian besar pemula, Anda akan lebih jarang menemui hal ini karena Rust sering menanganinya secara otomatis atau melalui abstraksi yang aman.

Mengakses Field Union

union adalah tipe khusus yang dapat menyimpan nilai dari *satu* variannya pada waktu tertentu, tetapi semua varian berbagi lokasi memori yang sama. Tipe ini mirip dengan union dalam C.

Mengakses field dari union memerlukan blok unsafe karena kompiler tidak dapat mengetahui field mana yang sedang aktif. Membaca field yang tidak aktif dapat menyebabkan perilaku tidak terdefinisi atau salah tafsir data.

union Data {
  integer: u32,
  float: f32,
}

fn main() {
  let mut d = Data { integer: 42 }; // Initialize with an integer

  unsafe {
    // Accessing 'integer' is safe here
    println!("Integer value: {}", d.integer);

    // Accessing 'float' is unsafe, as 'integer' was initialized.
    // This would interpret the integer's bits as a float.
    // println!("Float value (unsafe): {}", d.float);
  }

  d.float = 3.14; // Now initialize with a float
  unsafe {
    // Accessing 'float' is safe now
    println!("Float value: {}", d.float);
  }
}

Skenario Praktis `unsafe`

Meskipun unsafe sebaiknya digunakan secara terbatas, fitur ini penting untuk beberapa tugas pemrograman tingkat lanjut:

  • Antarmuka Fungsi Asing (FFI): Berinteraksi dengan kode yang ditulis dalam bahasa lain (seperti pustaka C/C++).
  • Optimisasi Kinerja: Terkadang, melewati pemeriksaan Rust dapat menghasilkan sedikit peningkatan kinerja pada bagian kritis (tetapi ukur terlebih dahulu!).
  • Pemrograman Sistem Tingkat Rendah: Menulis sistem operasi, pengandar perangkat, atau sistem tertanam.
  • Membangun Abstraksi Aman: Menerapkan struktur data atau API yang aman di atas primitif yang tidak aman (misalnya, cara Vec dibangun).

Tanggung Jawab Anda terhadap `unsafe`

Saat menggunakan unsafe, Anda mengambil tanggung jawab untuk menjaga jaminan keamanan Rust secara manual. Artinya:

  • Memastikan memori valid dan memiliki penyelarasan yang benar.
  • Mencegah perlombaan data saat menangani keadaan bersama yang dapat diubah.
  • Menghindari penunjuk yang menggantung atau kesalahan penggunaan setelah dealokasi.
  • Memastikan semua prasyarat fungsi terpenuhi.

Penyalahgunaan unsafe dapat menyebabkan perilaku tidak terdefinisi, yang merupakan jenis bug terburuk dan bisa sangat sulit untuk di-debug.

Pemeriksaan Pengetahuan tentang `unsafe`

Tindakan manakah berikut ini yang memerlukan blok unsafe dalam Rust?

Ringkasan: Rust Tidak Aman

Anda telah mempelajari Rust Tidak Aman, fitur yang kuat dan memungkinkan Anda melewati sebagian pemeriksaan keamanan Rust saat kompilasi untuk situasi tertentu yang tingkat lanjut.

Ingatlah bahwa unsafe tidak sepenuhnya menonaktifkan pemeriksa peminjaman, tetapi sepenuhnya mengalihkan tanggung jawab atas keamanan memori dan invarian kepada Anda sebagai pemrogram. Gunakan fitur ini dengan bijaksana dan sangat hati-hati, biasanya untuk FFI, optimisasi tingkat rendah, atau pembangunan abstraksi yang aman.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Berinteraksi dengan Rust Tidak Aman” gratis?

Ya — teks lengkap “Berinteraksi dengan Rust Tidak Aman” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Berinteraksi dengan Rust Tidak Aman”?

Pahami kapan dan bagaimana menggunakan blok `unsafe` untuk melewati pemeriksaan keamanan Rust, sehingga FFI dan operasi memori tingkat rendah dapat dilakukan. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 3.

Berapa lama pelajaran “Berinteraksi dengan Rust Tidak Aman” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Makro Deklaratif (`macro_rules!`)
  2. Makro Prosedural: Derive, Fungsi
  3. Berinteraksi dengan Rust Tidak Aman
← Kembali ke Learn Rust Coding