Learn Rust Coding · Ders

Özellik Nesneleri ve dyn

Dinamik dağıtım

Özellik Nesneleri ve dyn, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 4 dersten oluşur.

Sorun: Karışık Türler

Özellik sınırlarına sahip jenerikler, her çağrı tek bir somut tür kullandığında çok iyi çalışır. Peki ya bir özelliği paylaşan farklı türlerden oluşan bir koleksiyon istiyorsanız? Jenerikler karışık türleri barındıramaz.

Özellik nesneleri bu sorunu çözer.

Özellik Nesnesi Nedir?

Özellik nesnesi, dyn anahtar sözcüğüyle birlikte bir işaretçi üzerinden başvurulan değerdir; örneğin &dyn Trait veya Box<dyn Trait>.

Çalışma zamanında birçok somut türü aynı şekilde ele almanızı sağlar.

Bir dyn Trait Kutusu

Box<dyn Trait>, özelliği uygulayan herhangi bir türden yığın üzerindeki bir değerin sahipliğini alır. Somut türü bilmeden özellik yöntemlerini çağırabilirsiniz.

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

Özellik Nesnelerinden Oluşan Bir Vec

Asıl avantaj şudur: tek bir vektör, her biri özelliği uyguladığı sürece birçok farklı türü barındırabilir.

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

Dinamik Dağıtım

Özellik nesnelerinde çağrılacak yöntem, gizli bir tabloda (vtable) aranarak çalışma zamanında seçilir. Buna dinamik dağıtım denir.

Bedeli küçük bir dolaylı erişimdir; karşılığında çalışma zamanında esneklik sağlar.

Özellik Nesnesi Döndüren İşlevler

Somut tür değişebildiğinde bir işlev Box<dyn Trait> döndürebilir. Bu, türü çalışma zamanında belirleyen fabrika işlevleri için kullanışlıdır.

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

Ödünç Alınmış Özellik Nesneleri

Sahipliğe ihtiyaç duymadığınızda &dyn Trait ile ödünç alınmış bir özellik nesnesi de aktarabilirsiniz. Yığın üzerinde bellek ayırma gerçekleşmez.

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

Nesne Güvenliği

Her özellik özellik nesnesi olamaz. Bir özellik nesne açısından güvenli olmalıdır: kabaca, yöntemleri Self değerini değer olarak döndüremez veya jenerik tür parametreleri kullanamaz.

&self alan ve somut türler kullanan yöntemler uygundur.

Nesne Açısından Güvensiz Bir Örnek

Self döndüren bir yönteme sahip özellik dyn olarak kullanılamaz; çünkü bir işaretçinin arkasındaki Self boyutu bilinmez. Özellik nesnesi olarak kullanılacak özellikleri basit tutun.

Eklenti Tarzı Bir Örnek

Özellik nesneleri eklenti sistemlerinde çok kullanışlıdır: işleyicilerden oluşan bir listeyi dyn arkasında saklayabilir ve somut türleri önemsemeden hepsini çalıştırabilirsiniz.

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

dyn Ne Zaman Kullanılmalı?

Farklı türlerden oluşan koleksiyonlara, çalışma zamanında seçilen türlere ihtiyaç duyduğunuzda veya çok sayıda jenerik örneklemeden kaynaklanan kod şişmesini azaltmak istediğinizde özellik nesnelerini kullanın.

Aksi durumda en yüksek hız için jenerikleri tercih edin.

Hızlı Kontrol

Özellik nesnelerini kavrayışınızı sınayın.

Özet

Dinamik dağıtımı öğrendiniz:

Özellik nesneleri bir işaretçinin arkasında dyn kullanır (Box<dyn T>, &dyn T)
Farklı türlerden oluşan koleksiyonlara ve çalışma zamanında seçilen türlere olanak tanırlar
Yöntem çağrıları vtable üzerinden yapılır (dinamik dağıtım)
Özelliklerin bu şekilde kullanılabilmesi için nesne açısından güvenli olması gerekir

Sıkça Sorulan Sorular

“Özellik Nesneleri ve dyn” dersi ücretsiz mi?

Evet — “Özellik Nesneleri ve dyn” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 4 dersten oluşur.

“Özellik Nesneleri ve dyn” dersinde ne öğreneceğim?

Dinamik dağıtım Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Özellik Nesneleri ve dyn” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Learn Rust Coding Sayfasına Dön