Composição

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 55 de 61.

Muitas linguagens orientadas a objetos dependem fortemente de herança para compartilhar funcionalidades entre tipos. Rust adota uma abordagem diferente: composição. Em vez de herdar comportamento de um tipo pai, você cria tipos complexos incluindo outros tipos como campos.

Considere modelar um carro. Em vez de criar uma classe base Vehicle e herdá-la, você compõe um Car a partir de componentes menores e especializados:

struct Engine {
    horsepower: u32,
}

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

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

Car não herda de Engine nem de Wheels. Ele tem esses componentes. Essa relação de "tem-um" é composição. Você acessa os componentes inner por meio de seus fields e pode chamar seus method diretamente:

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

impl Car {
    fn start(&self) {
        self.engine.start();  // Delega para o componente interno
    }
}

Esse padrão mantém cada struct focada em uma única responsabilidade. Precisa mudar como os motores funcionam? Modifique apenas a struct Engine. Quer reutilizar Wheels para uma motocicleta? Basta incluí-la em uma nova struct. A composição oferece flexibilidade sem o forte acoplamento que a herança costuma criar.

Desafio

Fácil

Vamos criar um sistema de computador usando composição! Em vez de criar uma única struct enorme, você vai compor um Computer a partir de componentes menores e focados: uma CPU e uma Memory. Cada componente saberá como descrever a si mesmo, e o Computer delegará essa tarefa às suas partes.

Você organizará seu código em três arquivos:

cpu.rs: Defina uma struct pública CPU com dois campos públicos: cores (u32) para o número de núcleos e speed_ghz (f32) para a velocidade do clock. Adicione um método specs que retorne uma String descrevendo a CPU no formato {cores}-core @ {speed_ghz}GHz.
memory.rs: Defina uma struct pública Memory com um campo público size_gb (u32) para o tamanho da memória. Adicione um método specs que retorne uma String no formato {size_gb}GB RAM.
main.rs: Inclua ambos os módulos e crie uma struct pública Computer que tenha um campo cpu do tipo CPU e um campo memory do tipo Memory. Implemente um método system_info em Computer que delegue aos seus componentes e exiba a especificação completa do sistema. Use as entradas fornecidas para criar um Computer e exibir suas informações.

O método system_info deve exibir:

System: {cpu_specs} | {memory_specs}

Por exemplo, com as entradas 8, 3.5 e 16:

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

E com as entradas 4, 2.8 e 32:

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

Você receberá três entradas: núcleos da CPU (faça o parse como u32), velocidade da CPU (faça o parse como f32) e tamanho da memória (faça o parse como u32).

Experimente você mesmo

mod cpu;
mod memory;

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

// TODO: Defina uma struct pública Computer com dois campos públicos:
// - cpu: CPU
// - memory: Memory

// TODO: Implemente um método system_info em Computer que:
// - Delega para cpu.specs() e memory.specs()
// - Imprime: 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: Crie instâncias de CPU e Memory usando as entradas analisadas
    
    // TODO: Crie uma instância de Computer com a CPU e a Memory
    
    // TODO: Chame system_info() no computer para imprimir o resultado
}