Belajar Pengaturcaraan Rust · Pelajaran

Berinteraksi dengan Rust Tidak Selamat

Fahami bila dan cara menggunakan blok `unsafe` untuk memintas pemeriksaan keselamatan Rust, sekali gus membolehkan FFI dan operasi memori aras rendah.

Pelajaran 3 daripada 311 langkah

Berinteraksi dengan Rust Tidak Selamat ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Rust Tidak Selamat: Pengenalan

Selamat datang ke Rust Tidak Selamat! Walaupun Rust terkenal dengan jaminan keselamatan memorinya, terdapat situasi tertentu yang mungkin memerlukan anda memintas sebahagian pemeriksaan ini.

Kata kunci unsafe dalam Rust membolehkan anda berbuat demikian. Kata kunci ini bukan cara untuk menulis kod yang 'buruk', sebaliknya alat untuk kes penggunaan lanjutan yang memerlukan kawalan lebih langsung terhadap memori atau perkakasan.

Lima Keupayaan Istimewa Tidak Selamat

Apabila anda menggunakan blok unsafe, anda mendapat akses kepada lima tindakan khas yang biasanya dihalang oleh pengompil Rust:

Menyahrujuk penuding mentah: Mengakses alamat memori secara terus.
Memanggil fungsi atau kaedah unsafe: Melaksanakan fungsi dengan prasyarat yang tidak dapat disahkan oleh pengompil.
Melaksanakan trait unsafe: Mengisytiharkan bahawa jenis anda mengekalkan invarian tertentu.
Mengakses atau mengubah suai pemboleh ubah statik boleh ubah: Berkongsi keadaan boleh ubah secara global, yang berisiko menyebabkan perlumbaan data.
Mengakses medan union: Membaca daripada union, yang mungkin merupakan jenis tidak sah untuk data semasa.

Menyahrujuk Penuding Mentah

Penuding mentah ialah alamat memori tanpa jaminan keselamatan biasa Rust. Anda boleh menciptanya daripada rujukan (&T, &mut T), tetapi penyahrujukannya memerlukan blok unsafe.

Ini bermaksud anda, sebagai pengatur cara, bertanggungjawab memastikan penuding itu sah dan menunjuk kepada memori yang diperuntukkan.

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 Selamat

Sesetengah fungsi ditandai sebagai unsafe fn. Ini bermaksud fungsi tersebut mempunyai prasyarat yang tidak dapat dijamin oleh pengompil Rust. Contohnya, fungsi mungkin menjangkakan alamat memori yang sah tetapi tidak dapat mengesahkannya.

Panggilan kepada fungsi sedemikian mesti dibungkus dalam blok unsafe, yang menunjukkan bahawa anda sebagai pemanggil memastikan semua prasyarat dipenuhi.

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.");
}

Pemboleh Ubah Statik Boleh Ubah

Rust menghalang keadaan global yang boleh diubah secara lalai untuk mengelakkan perlumbaan data. Walau bagaimanapun, anda boleh mengisytiharkan pemboleh ubah statik boleh ubah menggunakan static mut.

Mengakses atau mengubah suai pemboleh ubah ini dianggap unsafe kerana berbilang utas mungkin cuba mengaksesnya serentak, lalu menyebabkan tingkah laku tidak ditakrifkan. Penyegerakan yang betul ialah tanggungjawab 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);
  }
}

Melaksanakan Trait Tidak Selamat

Sesetengah trait dalam Rust ditandai sebagai unsafe trait. Ini menandakan bahawa pelaksanaannya memerlukan pematuhan kepada invarian tertentu yang tidak dapat diperiksa oleh pengompil.

Contoh lazim ialah trait Send dan Sync, yang berkaitan dengan keselamatan utas. Jika anda melaksanakan unsafe trait secara manual, anda mesti menggunakan unsafe impl Trait for Type dan menjamin sifat keselamatannya.

Bagi kebanyakan pemula, anda akan jarang menemuinya kerana Rust biasanya mengendalikannya secara automatik atau melalui pengabstrakan yang selamat.

Mengakses Medan Union

union ialah jenis khas yang boleh menyimpan nilai daripada *satu* variannya pada bila-bila masa, tetapi semua varian berkongsi lokasi memori yang sama. Ia serupa dengan union dalam C.

Mengakses medan union memerlukan blok unsafe kerana pengompil tidak dapat mengetahui medan yang sedang aktif. Membaca medan yang tidak aktif boleh menyebabkan tingkah laku tidak ditakrifkan atau tafsiran data yang salah.

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);
  }
}

Situasi Tidak Selamat yang Praktikal

Walaupun unsafe harus digunakan secara berhemat, ciri ini penting untuk beberapa tugasan pengaturcaraan lanjutan:

Antara Muka Fungsi Asing (FFI): Berinteraksi dengan kod yang ditulis dalam bahasa lain (seperti pustaka C/C++).
Pengoptimuman Prestasi: Kadangkala, memintas pemeriksaan Rust boleh memberikan peningkatan prestasi kecil dalam bahagian kritikal (tetapi ukur dahulu!).
Pemprograman Sistem Aras Rendah: Menulis sistem pengendalian, pemacu peranti atau sistem terbenam.
Membina Pengabstrakan Selamat: Melaksanakan struktur data atau API yang selamat di atas primitif tidak selamat (contohnya cara Vec dibina).

Tanggungjawab Anda dengan Unsafe

Apabila anda menggunakan unsafe, anda memikul tanggungjawab untuk mengekalkan jaminan keselamatan Rust secara manual. Ini bermaksud:

Memastikan memori sah dan dijajarkan dengan betul.
Mengelakkan perlumbaan data apabila mengendalikan keadaan boleh ubah yang dikongsi.
Mengelakkan penuding tergantung atau ralat penggunaan selepas pembebasan.
Memastikan semua prasyarat fungsi dipenuhi.

Penyalahgunaan unsafe boleh menyebabkan tingkah laku tidak ditakrifkan, iaitu jenis pepijat yang paling buruk dan boleh menjadi sangat sukar untuk dinyahpepijat.

Semakan Pengetahuan Tidak Selamat

Antara tindakan berikut, yang manakah memerlukan blok unsafe dalam Rust?

Jawab dalam pelajaran interaktif

Imbas Kembali: Rust Tidak Selamat

Anda telah mempelajari Rust Tidak Selamat, ciri berkuasa yang membolehkan anda memintas sebahagian pemeriksaan keselamatan Rust pada masa kompil untuk situasi khusus dan lanjutan.

Ingat bahawa unsafe tidak mematikan pemeriksa pinjaman sepenuhnya, tetapi memindahkan tanggungjawab terhadap keselamatan memori dan invarian sepenuhnya kepada anda, iaitu pengatur cara. Gunakannya dengan pertimbangan dan amat berhati-hati, biasanya untuk FFI, pengoptimuman aras rendah atau pembinaan pengabstrakan yang selamat.

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Berinteraksi dengan Rust Tidak Selamat” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Berinteraksi dengan Rust Tidak Selamat”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Berinteraksi dengan Rust Tidak Selamat”?

Fahami bila dan cara menggunakan blok `unsafe` untuk memintas pemeriksaan keselamatan Rust, sekali gus membolehkan FFI dan operasi memori aras rendah. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Berinteraksi dengan Rust Tidak Selamat” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Belajar Pengaturcaraan Rust