Objek Trait dan dyn
Penghantaran dinamik
Objek Trait dan dyn ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. 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 4 pelajaran.
Masalah: Jenis Bercampur
Generik dengan had trait berfungsi dengan baik apabila setiap panggilan menggunakan satu jenis konkrit. Tetapi bagaimana jika anda mahu koleksi jenis yang berbeza dan semuanya berkongsi satu trait? Generik tidak boleh menyimpan campuran tersebut.
Objek trait menyelesaikan masalah ini.
Apakah Itu Objek Trait?
Objek trait ialah nilai yang dirujuk melalui penuding bersama kata kunci dyn, seperti &dyn Trait atau Box<dyn Trait>.
Ia membolehkan anda mengendalikan banyak jenis konkrit secara seragam pada masa jalan.
Kotak dyn Trait
Box<dyn Trait> memiliki nilai timbunan daripada sesuatu jenis yang melaksanakan trait tersebut. Anda boleh memanggil kaedah trait tanpa mengetahui jenis konkritnya.
trait Speak { fn say(&self) -> String; }
struct Dog;
impl Speak for Dog { fn say(&self) -> String { String::from("Woof") } }
fn main() {
let animal: Box<dyn Speak> = Box::new(Dog);
println!("{}", animal.say());
}Vec Objek Trait
Faedah utamanya: satu vektor boleh menyimpan banyak jenis yang berbeza selagi setiap satunya melaksanakan trait tersebut.
trait Speak { fn say(&self) -> String; }
struct Dog;
struct Cat;
impl Speak for Dog { fn say(&self) -> String { String::from("Woof") } }
impl Speak for Cat { fn say(&self) -> String { String::from("Meow") } }
fn main() {
let zoo: Vec<Box<dyn Speak>> = vec![Box::new(Dog), Box::new(Cat)];
for animal in &zoo {
println!("{}", animal.say());
}
}Penghantaran Dinamik
Dengan objek ciri, kaedah yang perlu dipanggil dipilih semasa masa jalan dengan mencarinya dalam jadual tersembunyi (jadual kaedah maya). Ini dipanggil penghantaran dinamik.
Kosnya ialah satu tahap pengalamatan tidak langsung yang kecil; manfaatnya ialah fleksibiliti semasa masa jalan.
Fungsi yang Mengembalikan Objek Ciri
Sesuatu fungsi boleh mengembalikan Box<dyn Trait> apabila jenis konkritnya berubah-ubah. Ini berguna untuk fungsi kilang yang menentukan jenis semasa masa jalan.
trait Speak { fn say(&self) -> String; }
struct Dog;
struct Cat;
impl Speak for Dog { fn say(&self) -> String { String::from("Woof") } }
impl Speak for Cat { fn say(&self) -> String { String::from("Meow") } }
fn make(kind: &str) -> Box<dyn Speak> {
if kind == "dog" { Box::new(Dog) } else { Box::new(Cat) }
}
fn main() {
println!("{}", make("cat").say());
}Objek Ciri yang Dipinjam
Anda juga boleh menghantar objek ciri yang dipinjam dengan &dyn Trait apabila anda tidak memerlukan pemilikan. Tiada peruntukan timbunan terlibat.
trait Speak { fn say(&self) -> String; }
struct Dog;
impl Speak for Dog { fn say(&self) -> String { String::from("Woof") } }
fn announce(s: &dyn Speak) {
println!("heard: {}", s.say());
}
fn main() {
let d = Dog;
announce(&d);
}Keselamatan Objek
Tidak semua ciri boleh menjadi objek ciri. Sesuatu ciri mesti selamat untuk objek: secara ringkasnya, kaedahnya tidak boleh mengembalikan Self mengikut nilai atau menggunakan parameter jenis generik.
Kaedah yang menerima &self dan menggunakan jenis konkrit adalah baik.
Contoh yang Tidak Selamat untuk Objek
Ciri dengan kaedah yang mengembalikan Self tidak boleh digunakan sebagai dyn, kerana saiz Self tidak diketahui di sebalik penuding. Pastikan ciri objek ciri mudah.
Contoh Gaya Pemalam
Objek ciri sangat berguna untuk sistem pemalam: simpan senarai pengendali di sebalik dyn dan jalankan semuanya tanpa mengambil berat tentang jenis konkrit.
trait Task { fn run(&self) -> i32; }
struct Add { a: i32, b: i32 }
struct Negate { x: i32 }
impl Task for Add { fn run(&self) -> i32 { self.a + self.b } }
impl Task for Negate { fn run(&self) -> i32 { -self.x } }
fn main() {
let tasks: Vec<Box<dyn Task>> = vec![Box::new(Add { a: 2, b: 3 }), Box::new(Negate { x: 7 })];
let total: i32 = tasks.iter().map(|t| t.run()).sum();
println!("total {}", total);
}Bila Perlu Menggunakan dyn
Gunakan objek ciri apabila anda memerlukan koleksi heterogen, jenis yang dipilih semasa masa jalan, atau ingin mengurangkan pengembangan kod akibat banyak pembentukan contoh generik.
Jika tidak, utamakan generik untuk kelajuan maksimum.
Semakan Pantas
Uji pemahaman anda tentang objek ciri.
Imbas Kembali
Anda telah mempelajari penghantaran dinamik:
- Objek ciri menggunakan
dyndi sebalik penuding (Box<dyn T>,&dyn T) - Objek ini membolehkan koleksi heterogen dan jenis yang dipilih semasa masa jalan
- Panggilan kaedah melalui jadual kaedah maya (penghantaran dinamik)
- Ciri mestilah selamat untuk objek untuk digunakan dengan cara ini
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 “Objek Trait dan dyn” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Objek Trait dan dyn”, 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 4 pelajaran.
Apakah yang akan saya pelajari dalam “Objek Trait dan dyn”?
Penghantaran dinamik 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 2 daripada 4.
Berapa lamakah pelajaran “Objek Trait dan dyn” 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
- Menentukan Trait
- Objek Trait dan dyn
- Penghantaran Statik berbanding Dinamik
- Kaedah Lalai