Belajar Pengaturcaraan Rust · Pelajaran

Memahami Model Pemilikan Rust

Fahami peraturan teras pemilikan, semantik pemindahan dan cara peraturan ini mencegah ralat memori lazim seperti pembebasan berganda.

Pelajaran 1 daripada 312 langkah

Memahami Model Pemilikan Rust ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 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.

Apakah Pemilikan Rust?

Sistem pemilikan Rust ialah sekumpulan peraturan yang mengurus cara program anda menggunakan memori. Ini ialah konsep teras yang membantu Rust mencapai keselamatan memori tanpa pengutip sampah.

Tiada penuding tergantung.
Tiada ralat pembebasan berganda.
Tiada perlumbaan data dalam kod serentak.

Rust menyemak peraturan ini pada masa kompilasi!

Memori Tindanan berbanding Timbunan

Program menggunakan dua kawasan memori utama: tindanan dan timbunan.

Tindanan: Data bersaiz tetap yang lebih pantas (seperti integer, boolean dan jenis yang saiznya diketahui). Data ditambah dan dikeluarkan mengikut turutan.
Timbunan: Data bersaiz berubah yang lebih perlahan (seperti String dan Vec). Data diminta dan dikembalikan oleh pengagih memori.

Pemilikan mengurus terutamanya data pada timbunan, bagi memastikan penggunaannya dan pembersihannya selamat.

Peraturan 1: Setiap Nilai Mempunyai Pemilik

Peraturan pertama pemilikan adalah mudah: setiap nilai dalam Rust mempunyai pemboleh ubah yang dipanggil pemiliknya.

Bayangkan ia seperti label pada sebuah kotak. Pemboleh ubah s di bawah ialah pemilik teks "hello".

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

Peraturan 2: Hanya Satu Pemilik pada Satu-satu Masa

Peraturan kedua menyatakan: pada bila-bila masa, hanya boleh ada satu pemilik bagi sesuatu nilai. Ini penting untuk mencegah masalah memori.

Apabila anda menetapkan nilai kompleks (seperti String, yang berada pada timbunan) daripada satu pemboleh ubah kepada pemboleh ubah lain, pemilikan dipindahkan, bukannya disalin.

Pemindahan Pemilikan dalam Tindakan

Lihat perkara yang berlaku apabila nilai s1 ditetapkan kepada s2. Cuba jalankan kod tersebut.

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

Memahami Semantik "Pemindahan"

Selepas let s2 = s1;, s1 tidak lagi dianggap sah. Rust menghalang anda daripada menggunakan s1 sekali lagi.

Ini dipanggil pemindahan. Penuding, panjang dan kapasiti pada tindanan disalin, tetapi data pada timbunan itu sendiri tidak disalin.
Jika s1 masih sah, kedua-dua s1 dan s2 akan cuba membebaskan memori yang sama apabila kedua-duanya keluar daripada skop (suatu ralat pembebasan berganda).

Sistem pemilikan Rust menghalang perkara ini pada masa kompilasi!

Pemilikan dan Panggilan Fungsi

Meluluskan nilai kepada fungsi berfungsi sama seperti menetapkannya kepada pemboleh ubah lain: pemilikan dipindahkan ke dalam fungsi.

Apabila fungsi selesai, pemilik nilai tersebut (parameter fungsi) keluar daripada skop dan nilai itu dilupuskan.

Demonstrasi Pemilikan Fungsi

Perhatikan cara nilai String dipindahkan ke dalam takes_ownership, kemudian gives_ownership mengembalikan String baharu.

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

Peraturan 3: Skop dan Pelupusan

Peraturan terakhir: apabila pemilik keluar daripada skop, nilai tersebut akan dilupuskan.

Skop ialah julat dalam program yang menjadikan sesuatu item sah, biasanya ditentukan oleh kurungan kerinting {}.
Apabila pemboleh ubah keluar daripada skop, Rust memanggil fungsi khas yang dipanggil drop secara automatik.

Ini memastikan memori dibersihkan secara automatik dan selamat, tanpa pengutip sampah.

Mencegah Ralat Memori

Peraturan pemilikan bekerjasama untuk menjamin keselamatan memori:

Satu pemilik: Menghalang beberapa bahagian kod anda daripada cuba membebaskan memori yang sama.
Pelupusan pada akhir skop: Memastikan memori dibebaskan tepat sekali dan pada masa yang betul.

Ini menghapuskan pepijat biasa seperti ralat pembebasan berganda dan ralat penggunaan selepas pembebasan pada masa kompilasi, lalu memberikan anda ketenangan fikiran!

Semakan Pemilikan

Teliti kod Rust berikut. Apakah yang akan berlaku apabila anda cuba mengompil dan menjalankannya?

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

Jawab dalam pelajaran interaktif

Ulang Kaji: Asas Pemilikan

Syabas! Anda telah mempelajari peraturan asas sistem pemilikan Rust:

Setiap nilai mempunyai pemilik.
Hanya boleh ada satu pemilik pada satu-satu masa.
Apabila pemilik keluar daripada skop, nilai tersebut dilupuskan.

Sistem ini mencegah ralat memori biasa tanpa pengutip sampah. Seterusnya, kita akan meneroka peminjaman untuk berkongsi data tanpa memindahkan pemilikan.

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 “Memahami Model Pemilikan Rust” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Memahami Model Pemilikan Rust”, 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 “Memahami Model Pemilikan Rust”?

Fahami peraturan teras pemilikan, semantik pemindahan dan cara peraturan ini mencegah ralat memori lazim seperti pembebasan berganda. 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 1 daripada 3.

Berapa lamakah pelajaran “Memahami Model Pemilikan Rust” 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

Memahami Model Pemilikan Rust
Penjelasan tentang Rujukan dan Peminjaman
Jangka Hayat untuk Rujukan Selamat

← Kembali ke Belajar Pengaturcaraan Rust