Learn Rust Coding · Pelajaran

Dispatch Statis vs Dinamis

Pertukaran kelebihan dan kekurangan

Dispatch Statis vs Dinamis adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 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.

Dua Cara Melakukan Pengiriman

Saat Anda memanggil metode sifat, Rust harus menentukan implementasi konkret mana yang dijalankan. Ada dua strategi: pengiriman statis (ditentukan saat kompilasi) dan pengiriman dinamis (ditentukan saat runtime).

Pengiriman Statis dengan Generik

Fungsi generik menggunakan pengiriman statis. Kompilator membuat salinan khusus untuk setiap tipe konkret — proses ini disebut monomorfisasi.

trait Area { fn area(&self) -> f64; }
struct Square { s: f64 }
impl Area for Square { fn area(&self) -> f64 { self.s * self.s } }

fn print_area<T: Area>(shape: &T) {
    println!("{}", shape.area());
}

fn main() {
    print_area(&Square { s: 4.0 });
}

Monomorfisasi

Untuk setiap tipe yang Anda gunakan dalam pemanggilan, kompilator membuat versi khusus fungsi tersebut. Pemanggilan metode menjadi pemanggilan langsung tanpa pencarian, sehingga kecepatannya setara dengan kode yang ditulis secara manual.

Pengiriman Dinamis dengan dyn

Objek sifat menggunakan pengiriman dinamis. Satu fungsi menangani semua tipe; alamat metode ditemukan saat runtime melalui tabel v.

trait Area { fn area(&self) -> f64; }
struct Square { s: f64 }
impl Area for Square { fn area(&self) -> f64 { self.s * self.s } }

fn print_area(shape: &dyn Area) {
    println!("{}", shape.area());
}

fn main() {
    print_area(&Square { s: 4.0 });
}

Tabel v

Objek sifat adalah pointer gemuk: satu bagiannya menunjuk ke data, bagian lainnya menunjuk ke tabel v yang mencantumkan alamat metode. Setiap pemanggilan menggunakan indeks ke dalam tabel ini.

Pengalihan tambahan itulah biaya saat runtime.

Pertukaran Kecepatan

Pengiriman statis lebih cepat per pemanggilan dan dapat disisipkan, tetapi menghasilkan lebih banyak kode mesin. Pengiriman dinamis menambahkan sedikit pengalihan, tetapi menjaga ukuran kode tetap kecil.

Bagi sebagian besar aplikasi, perbedaannya dapat diabaikan; pilih berdasarkan fleksibilitas.

Pertukaran Ukuran Kode

Memanggil fungsi generik dengan banyak tipe akan membuat banyak salinan, yang dapat memperbesar berkas biner. Satu fungsi dyn menghindari duplikasi tersebut.

Itulah sebabnya pustaka terkadang memilih objek sifat secara internal.

Pertukaran Fleksibilitas

Generik memaksa satu tipe konkret untuk setiap tempat pemanggilan, sehingga tidak dapat menampung tipe campuran dalam koleksi. Objek sifat bisa melakukannya. Jika Anda memerlukan daftar heterogen, pengiriman dinamis adalah jawabannya.

trait Area { fn area(&self) -> f64; }
struct Square { s: f64 }
struct Rect { w: f64, h: f64 }
impl Area for Square { fn area(&self) -> f64 { self.s * self.s } }
impl Area for Rect { fn area(&self) -> f64 { self.w * self.h } }

fn main() {
    let shapes: Vec<Box<dyn Area>> = vec![Box::new(Square { s: 2.0 }), Box::new(Rect { w: 3.0, h: 4.0 })];
    let total: f64 = shapes.iter().map(|s| s.area()).sum();
    println!("{}", total);
}

Menggabungkan Keduanya

Anda dapat menggabungkan keduanya: fungsi generik mungkin menerima impl Trait pada batas luar dan menyimpan nilai sebagai Box<dyn Trait> secara internal. Gunakan masing-masing pada tempat yang sesuai.

Panduan Pengambilan Keputusan

Aturan singkat:

Satu tipe per pemanggilan, jalur yang sering dijalankan? Gunakan generik (statis).
Tipe campuran dalam koleksi? Gunakan dyn (dinamis).
Khawatir dengan ukuran berkas biner? Lebih condong ke dyn.

Keduanya Tanpa Biaya di Bagian yang Penting

Rust tidak pernah menambahkan beban yang tidak Anda minta. Generik tidak memerlukan biaya saat runtime; objek sifat hanya memerlukan satu pengalihan pointer. Anda memilih pertukarannya secara eksplisit.

Pemeriksaan Singkat

Uji pengetahuan Anda tentang pengiriman.

Rangkuman

Anda telah membandingkan dua gaya pengiriman:

Statis (generik): dimonorfisasi, cepat, berkas biner lebih besar, satu tipe per pemanggilan
Dinamis (dyn): pencarian tabel v, fleksibel, kode lebih kecil, memungkinkan koleksi campuran
Pilih berdasarkan kebutuhan fleksibilitas, kinerja, dan ukuran berkas biner

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dispatch Statis vs Dinamis” gratis?

Ya — teks lengkap “Dispatch Statis vs Dinamis” 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 “Dispatch Statis vs Dinamis”?

Pertukaran kelebihan dan kekurangan 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 3 dari 4.

Berapa lama pelajaran “Dispatch Statis vs Dinamis” 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