Penuding Pintar Box, Rc dan Arc
Fahami cara `Box` untuk peruntukan timbunan, `Rc` untuk pemilikan bersama dan `Arc` untuk pemilikan bersama yang selamat antara bebenang mengurus data.
Penuding Pintar Box, Rc dan Arc 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 Penuding Pintar?
Sistem pemilikan Rust amat baik untuk keselamatan memori, tetapi kadangkala anda memerlukan lebih banyak fleksibiliti. Di sinilah penuding pintar berguna!
Penuding pintar ialah struktur data yang bertindak seperti penuding, tetapi turut mempunyai metadata dan keupayaan tambahan. Penuding ini mengurus memori, pemilikan dan sumber lain secara automatik.
Box: Menyimpan Data pada Timbunan
Penuding pintar yang paling mudah ialah Box<T>. Ia membolehkan anda menyimpan data pada timbunan, bukannya pada tindanan.
- Tindanan: Data bersaiz tetap yang pantas.
- Timbunan: Data bersaiz fleksibel yang lebih perlahan dan diperuntukkan semasa masa jalan.
Apabila anda meletakkan nilai dalam Box, Box itu sendiri berada pada tindanan, tetapi data yang ditunjuknya berada pada timbunan.
Menggunakan Box untuk Peruntukan Timbunan
Mari kita lihat cara Box memindahkan data ke timbunan. Ini berguna untuk data yang besar atau apabila anda tidak mengetahui saiznya pada masa kompilasi.
Jalankan kod ini untuk memerhatikan nilai yang dimasukkan ke dalam Box.
fn main() {
let x = 5; // x is on the stack
let boxed_x = Box::new(x); // x's value is moved to the heap, boxed_x is on stack
println!("Value on stack: {}", x);
println!("Value in Box (on heap): {}", *boxed_x); // Dereference to get value
}Bila Box Berguna
Anda mungkin menggunakan Box<T> dalam situasi berikut:
- Apabila anda mempunyai jenis yang saiznya tidak dapat diketahui pada masa kompilasi, dan anda perlu menyimpannya di tempat yang mempunyai saiz tetap dan diketahui.
- Apabila anda mempunyai sejumlah besar data dan mahu memindahkan pemilikan tanpa menyalin data itu sendiri.
- Apabila anda mahu memiliki objek trait (contohnya,
Box<dyn Trait>).
Rc: Pemilik Berbilang (Satu Benang)
Peraturan pemilikan Rust bermaksud sesuatu nilai biasanya hanya mempunyai satu pemilik. Tetapi bagaimana jika beberapa bahagian program anda perlu “memiliki” data yang sama?
Rc<T>, atau Berkaunter Rujukan, membolehkan berbilang pemilik bagi data dalam senario satu benang. Ia menjejaki bilangan rujukan yang menunjuk kepada data tersebut.
Apabila kiraan menurun kepada sifar, data itu dibersihkan.
Berkongsi Data dengan Rc
Rc::clone() menambah kiraan rujukan. Ini bukan salinan mendalam; ia hanya mencipta satu lagi penuding kepada data yang sama.
Perhatikan bahawa data itu dikongsi, dan nilainya boleh dicapai daripada “pemilik” yang berbeza.
use std::rc::Rc;
fn main() {
let value = Rc::new(String::from("Shared String"));
println!("Count after creation: {}", Rc::strong_count(&value));
let value_clone_a = Rc::clone(&value); // Increment count
println!("Count after clone A: {}", Rc::strong_count(&value));
{
let value_clone_b = Rc::clone(&value); // Increment count
println!("Count after clone B: {}", Rc::strong_count(&value));
println!("Data from A: {}", value_clone_a);
println!("Data from B: {}", value_clone_b);
} // value_clone_b goes out of scope, count decreases
println!("Count after B goes out of scope: {}", Rc::strong_count(&value));
}Arc: Pemilikan Dikongsi (Berbilang Benang)
Rc<T> berfungsi dengan baik untuk aplikasi satu benang. Walau bagaimanapun, jika anda perlu berkongsi data antara beberapa benang, Rc<T> tidak selamat.
Arc<T>, atau Berkaunter Rujukan Atom, ialah versi Rc<T> yang selamat untuk benang. Ia menggunakan operasi atom untuk mengemas kini kiraan rujukan, sekali gus memastikan keselamatan merentas benang.
Arc mempunyai sedikit overhed prestasi berbanding Rc disebabkan oleh operasi atom.
Berkongsi Data Merentas Benang dengan Arc
Contoh ini menunjukkan cara Arc membolehkan berbilang benang mencapai dan membaca data dikongsi yang sama dengan selamat. Setiap benang mendapat klon `Arc` sendiri.
Benang utama menunggu semua benang yang dicipta selesai.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let mut handles = vec![];
for i in 0..3 {
let data_clone = Arc::clone(&data); // Clone Arc for each thread
let handle = thread::spawn(move || {
println!("Thread {} has data: {:?}", i, *data_clone);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("All threads finished.");
}Box, Rc atau Arc?
Pemilihan penuding pintar yang tepat bergantung pada keperluan anda:
Box<T>: Apabila anda perlu meletakkan data pada timbunan, biasanya untuk pemilikan tunggal atau apabila berurusan dengan jenis rekursif.Rc<T>: Apabila anda memerlukan berbilang pemilik bagi data dalam konteks satu benang.Arc<T>: Apabila anda memerlukan berbilang pemilik bagi data dalam konteks berbilang benang (serentak).
Sentiasa utamakan Box atau Rc jika anda tidak memerlukan keselamatan benang, kerana Arc mempunyai kos prestasi.
Semakan Penuding Pintar
Anda perlu menyimpan fail imej yang besar pada timbunan, dan hanya satu bahagian program anda akan memiliki serta menguruskannya. Penuding pintar yang manakah patut anda gunakan?
Ulang Kaji: Penuding Pintar
Dalam pelajaran ini, anda telah mempelajari tiga penuding pintar Rust yang asas:
Box<T>: Untuk memperuntukkan data pada timbunan dengan pemilikan tunggal.Rc<T>: Untuk membolehkan berbilang pemilik data dalam persekitaran satu benang.Arc<T>: Untuk membolehkan berbilang pemilik data yang selamat untuk benang dalam persekitaran berbilang benang.
Penuding pintar ini memberikan anda lebih banyak kawalan terhadap pengurusan memori sambil terus memanfaatkan jaminan keselamatan Rust.
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
Soalan Lazim
Adakah pelajaran “Penuding Pintar Box, Rc dan Arc” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Penuding Pintar Box, Rc dan Arc”, 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 “Penuding Pintar Box, Rc dan Arc”?
Fahami cara `Box` untuk peruntukan timbunan, `Rc` untuk pemilikan bersama dan `Arc` untuk pemilikan bersama yang selamat antara bebenang mengurus data. 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 “Penuding Pintar Box, Rc dan Arc” 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
- Penuding Pintar Box, Rc dan Arc
- Kebolehubahan Dalaman: RefCell, Cell
- Keserentakan Tanpa Risau dengan Bebenang