Kompozisyon

Coddy'nin Rust Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 55 / 61.

Birçok nesne yönelimli dil, türler arasında işlevselliği paylaşmak için büyük ölçüde kalıtıma dayanır. Rust farklı bir yaklaşım benimser: bileşim. Bir üst türden davranış miras almak yerine, diğer türleri alanlar olarak dahil ederek karmaşık türler oluşturursun.

Bir araba modellemeyi düşünün. Temel bir Vehicle sınıfı oluşturup ondan kalıtım almak yerine, bir Car nesnesini daha küçük ve odaklanmış bileşenlerden oluşturursunuz:

struct Engine {
    horsepower: u32,
}

struct Wheels {
    count: u8,
    diameter: f32,
}

struct Car {
    engine: Engine,
    wheels: Wheels,
    brand: String,
}

Car, Engine veya Wheels'dan miras almaz. Onlara sahiptir. Bu "has-a" ilişkisi bileşimdir. İç bileşenlere alanları aracılığıyla erişebilir ve yöntemlerini doğrudan çağırabilirsiniz:

impl Engine {
    fn start(&self) {
        println!("Engine with {} HP started!", self.horsepower);
    }
}

impl Car {
    fn start(&self) {
        self.engine.start();  // İç bileşene devret
    }
}

Bu desen, her struct'ın tek bir sorumluluğa odaklanmasını sağlar. Motorların çalışma şeklini mi değiştirmek gerekiyor? Yalnızca Engine struct'ını değiştirin. Wheels yapısını bir motosiklet için yeniden kullanmak mı istiyorsunuz? Onu yeni bir struct'a eklemeniz yeterli. Bileşim, kalıtımın sıklıkla oluşturduğu sıkı bağlılık olmadan size esneklik sağlar.

Görev

Kolay

Kompozisyon kullanarak bir bilgisayar sistemi oluşturalım! Tek bir devasa struct oluşturmak yerine, bir Computer nesnesini daha küçük ve odaklanmış bileşenlerden oluşturacaksınız: bir CPU ve Memory. Her bileşen kendisini nasıl açıklayacağını bilecek ve Computer, görevleri parçalarına devredecek.

Kodunuzu üç dosyaya ayıracaksınız:

cpu.rs: İki public alana sahip bir CPU struct'ı tanımlayın: çekirdek sayısı için cores (u32) ve saat hızı için speed_ghz (f32). CPU'yu specs biçiminde açıklayan bir String döndüren {cores}-core @ {speed_ghz}GHz metodu ekleyin.
memory.rs: Bellek boyutu için Memory adlı public alana sahip bir size_gb struct'ı tanımlayın. specs biçiminde bir String döndüren bir {size_gb}GB RAM metodu ekleyin.
main.rs: Her iki modülü de dahil edin ve bir Computer türünde cpu alanına ve CPU türünde memory alanına sahip public bir Memory struct'ı oluşturun. Computer üzerinde, görevleri bileşenlerine devreden bir system_info metodu uygulayın ve tam sistem özelliklerini yazdırın. Bir Computer oluşturmak ve bilgilerini görüntülemek için sağlanan girdileri kullanın.

system_info metodu şunu yazdırmalıdır:

System: {cpu_specs} | {memory_specs}

Örneğin, 8, 3.5 ve 16 girdileriyle:

System: 8-core @ 3.5GHz | 16GB RAM

Ve 4, 2.8 ve 32 girdileriyle:

System: 4-core @ 2.8GHz | 32GB RAM

Üç girdi alacaksınız: CPU çekirdekleri (u32 olarak ayrıştırın), CPU hızı (f32 olarak ayrıştırın) ve bellek boyutu (u32 olarak ayrıştırın).

Kendin dene

mod cpu;
mod memory;

use cpu::CPU;
use memory::Memory;

// TODO: İki public alana sahip public bir Computer struct tanımla:
// - cpu: CPU
// - memory: Memory

// TODO: Computer üzerinde şunları yapan bir system_info metodu uygula:
// - cpu.specs() ve memory.specs() metodlarına delege eder
// - Yazdırır: System: {cpu_specs} | {memory_specs}

fn main() {
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let cores: u32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let speed_ghz: f32 = input.trim().parse().expect("Invalid number");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let size_gb: u32 = input.trim().parse().expect("Invalid number");
    
    // TODO: Ayrıştırılmış girdileri kullanarak CPU ve Memory örnekleri oluştur
    
    // TODO: CPU ve Memory ile bir Computer örneği oluştur
    
    // TODO: Sonucu yazdırmak için computer üzerinde system_info() çağır
}