Learn Rust Coding · Pelajaran

Objek Trait dan dyn

Dispatch dinamis

Objek Trait dan dyn adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. 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 4 pelajaran total.

Masalahnya: Tipe Campuran

Generik dengan batas trait bekerja dengan baik ketika setiap pemanggilan menggunakan satu tipe konkret. Namun, bagaimana jika Anda ingin memiliki koleksi berbagai tipe yang semuanya menggunakan trait yang sama? Generik tidak dapat menampung campuran tersebut.

Objek trait menyelesaikan masalah ini.

Apa Itu Objek Trait?

Objek trait adalah nilai yang dirujuk melalui pointer ditambah kata kunci dyn, seperti &dyn Trait atau Box<dyn Trait>.

Objek ini memungkinkan Anda memperlakukan banyak tipe konkret secara seragam saat program berjalan.

Box Berisi dyn Trait

Box<dyn Trait> memiliki nilai di heap dari suatu tipe yang mengimplementasikan trait tersebut. Anda dapat memanggil metode trait tanpa mengetahui tipe konkretnya.

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 Berisi Objek Trait

Manfaat utamanya: satu vektor dapat menampung banyak tipe berbeda selama masing-masing mengimplementasikan 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());
    }
}

Pengiriman Dinamis

Dengan objek sifat, metode yang dipanggil dipilih saat runtime dengan mencarinya di tabel tersembunyi (tabel v). Ini disebut pengiriman dinamis.

Biayanya adalah satu tingkat pengalihan kecil; manfaatnya adalah fleksibilitas saat runtime.

Fungsi yang Mengembalikan Objek Sifat

Sebuah fungsi dapat mengembalikan Box<dyn Trait> ketika tipe konkretnya bervariasi. Ini berguna untuk fungsi pabrik yang menentukan tipe saat runtime.

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 Sifat yang Dipinjam

Anda juga dapat meneruskan objek sifat yang dipinjam dengan &dyn Trait jika Anda tidak memerlukan kepemilikan. Tidak ada alokasi heap yang 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);
}

Keamanan Objek

Tidak semua sifat dapat menjadi objek sifat. Sebuah sifat harus aman untuk objek: secara umum, metodenya tidak boleh mengembalikan Self berdasarkan nilai atau menggunakan parameter tipe generik.

Metode yang menerima &self dan menggunakan tipe konkret tidak masalah.

Contoh yang Tidak Aman untuk Objek

Sifat dengan metode yang mengembalikan Self tidak dapat digunakan sebagai dyn, karena ukuran Self tidak diketahui di balik pointer. Buat sifat objek tetap sederhana.

Contoh Bergaya Plugin

Objek sifat sangat berguna untuk sistem plugin: simpan daftar penangan di balik dyn dan jalankan semuanya tanpa memedulikan tipe konkretnya.

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

Kapan Menggunakan dyn

Gunakan objek sifat ketika Anda memerlukan koleksi heterogen, tipe yang dipilih saat runtime, atau ingin mengurangi pembengkakan kode akibat banyak instansiasi generik.

Jika tidak, pilih generik untuk kecepatan maksimum.

Pemeriksaan Singkat

Uji pemahaman Anda tentang objek sifat.

Rangkuman

Anda telah mempelajari pengiriman dinamis:

Objek sifat menggunakan dyn di balik pointer (Box<dyn T>, &dyn T)
Objek sifat memungkinkan koleksi heterogen dan tipe yang dipilih saat runtime
Pemanggilan metode dilakukan melalui tabel v (pengiriman dinamis)
Sifat harus aman untuk objek agar dapat digunakan dengan cara ini

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Objek Trait dan dyn” gratis?

Ya — teks lengkap “Objek Trait dan dyn” 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 4 pelajaran total.

Apa yang akan aku pelajari di “Objek Trait dan dyn”?

Dispatch dinamis 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 2 dari 4.

Berapa lama pelajaran “Objek Trait dan dyn” 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

← Kembali ke Learn Rust Coding