Komposisi

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Rust di Coddy. Pelajaran 55 dari 61.

Banyak bahasa berorientasi objek sangat mengandalkan pewarisan untuk berbagi fungsionalitas antar tipe. Rust menggunakan pendekatan yang berbeda: komposisi. Alih-alih mewarisi perilaku dari parent, kamu membangun tipe yang kompleks dengan menyertakan tipe lain sebagai field.

Pertimbangkan untuk memodelkan sebuah mobil. Alih-alih membuat class dasar Vehicle lalu mewarisinya, kamu menyusun Car dari komponen-komponen yang lebih kecil dan terfokus:

struct Engine {
    horsepower: u32,
}

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

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

Car tidak mewarisi Engine atau Wheels. Car memiliki keduanya. Hubungan "has-a" ini disebut komposisi. Kamu mengakses komponen di dalamnya melalui field-nya dan dapat langsung memanggil method-nya:

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

impl Car {
    fn start(&self) {
        self.engine.start();  // Delegasikan ke komponen di dalamnya
    }
}

Pola ini menjaga setiap struct tetap berfokus pada satu tanggung jawab. Perlu mengubah cara kerja engine? Ubah hanya struct Engine. Ingin menggunakan kembali Wheels untuk sepeda motor? Cukup sertakan di struct baru. Komposisi memberimu fleksibilitas tanpa keterikatan erat yang sering ditimbulkan oleh pewarisan.

Tantangan

Mudah

Mari bangun sistem komputer menggunakan komposisi! Alih-alih membuat satu struct besar, kamu akan menyusun Computer dari komponen yang lebih kecil dan terfokus: CPU dan Memory. Setiap komponen akan mengetahui cara mendeskripsikan dirinya sendiri, dan Computer akan mendelegasikan tugas kepada komponennya.

Kamu akan mengatur kodemu dalam tiga file:

cpu.rs: Definisikan struct CPU publik dengan dua field publik: cores (u32) untuk jumlah core, dan speed_ghz (f32) untuk kecepatan clock. Tambahkan method specs yang mengembalikan String untuk mendeskripsikan CPU dalam format {cores}-core @ {speed_ghz}GHz.
memory.rs: Definisikan struct Memory publik dengan field publik size_gb (u32) untuk ukuran memori. Tambahkan method specs yang mengembalikan String dalam format {size_gb}GB RAM.
main.rs: Gunakan kedua module dan buat struct Computer publik yang memiliki field cpu bertipe CPU dan field memory bertipe Memory. Implementasikan method system_info pada Computer yang mendelegasikan tugas kepada komponennya dan mencetak spesifikasi sistem lengkap. Gunakan input yang diberikan untuk membuat Computer dan menampilkan informasinya.

Method system_info harus mencetak:

System: {cpu_specs} | {memory_specs}

Contohnya, dengan input 8, 3.5, dan 16:

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

Dan dengan input 4, 2.8, dan 32:

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

Kamu akan menerima tiga input: jumlah core CPU (parse sebagai u32), kecepatan CPU (parse sebagai f32), dan ukuran memori (parse sebagai u32).

Coba sendiri

mod cpu;
mod memory;

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

// TODO: Definisikan struct Computer publik dengan dua field publik:
// - cpu: CPU
// - memory: Memory

// TODO: Implementasikan method system_info pada Computer yang:
// - Mendelegasikan ke cpu.specs() dan memory.specs()
// - Mencetak: 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: Buat instance CPU dan Memory menggunakan input yang sudah di-parse
    
    // TODO: Buat instance Computer dengan CPU dan Memory
    
    // TODO: Panggil system_info() pada computer untuk mencetak hasilnya
}