Composition

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 55 sur 61.

De nombreux langages orientés objet reposent largement sur l’héritage pour partager des fonctionnalités entre les types. Rust adopte une approche différente : la composition. Au lieu d’hériter du comportement d’un parent, vous construisez des types complexes en incluant d’autres types comme champs.

Imaginez la modélisation d’une voiture. Plutôt que de créer une classe de base Vehicle et d’en hériter, vous composez une Car à partir de composants plus petits et ciblés :

struct Engine {
    horsepower: u32,
}

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

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

La Car n’hérite pas de Engine ou de Wheels. Elle les possède. Cette relation « possède-un » est une composition. Vous accédez aux composants internes par leurs fields et pouvez appeler directement leurs method :

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

impl Car {
    fn start(&self) {
        self.engine.start();  // Déléguer au composant interne
    }
}

Ce modèle permet de garder chaque structure axée sur une seule responsabilité. Besoin de modifier le fonctionnement des moteurs ? Modifiez uniquement la structure Engine. Vous souhaitez réutiliser Wheels pour une moto ? Il suffit de l’inclure dans une nouvelle structure. La composition vous offre de la flexibilité sans le couplage étroit que l’héritage crée souvent.

Défi

Facile

Construisons un système informatique en utilisant la composition ! Au lieu de créer une structure massive, vous allez composer un Computer à partir de composants plus petits et spécialisés : un CPU et une Memory. Chaque composant saura se décrire lui-même, et le Computer délèguera cette tâche à ses composants.

Vous allez organiser votre code sur trois fichiers :

cpu.rs : définissez une structure publique CPU avec deux champs publics : cores (u32) pour le nombre de cœurs, et speed_ghz (f32) pour la fréquence d’horloge. Ajoutez une méthode specs qui renvoie une chaîne String décrivant le CPU au format {cores}-core @ {speed_ghz}GHz.
memory.rs : définissez une structure publique Memory avec un champ public size_gb (u32) pour la capacité mémoire. Ajoutez une méthode specs qui renvoie une chaîne String au format {size_gb}GB RAM.
main.rs : incluez les deux modules et créez une structure publique Computer qui possède un champ cpu de type CPU et un champ memory de type Memory. Implémentez une méthode system_info sur Computer qui délègue aux composants et affiche les spécifications complètes du système. Utilisez les entrées fournies pour construire un Computer et afficher ses informations.

La méthode system_info doit afficher :

System: {cpu_specs} | {memory_specs}

Par exemple, avec les entrées 8, 3.5 et 16 :

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

Et avec les entrées 4, 2.8 et 32 :

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

Vous recevrez trois entrées : le nombre de cœurs du CPU (à analyser comme u32), la fréquence du CPU (à analyser comme f32) et la capacité mémoire (à analyser comme u32).

Essayez vous-même

mod cpu;
mod memory;

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

// TODO: Définis une structure publique Computer avec deux champs publics :
// - cpu: CPU
// - memory: Memory

// TODO: Implémente une méthode system_info sur Computer qui :
// - Délègue à cpu.specs() et memory.specs()
// - Affiche : 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: Crée des instances de CPU et Memory en utilisant les entrées analysées
    
    // TODO: Crée une instance de Computer avec le CPU et la Memory
    
    // TODO: Appelle system_info() sur le computer pour afficher le résultat
}