Composição vs. Herança

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 76 de 104.

Ao projetar relacionamentos entre classes, você tem duas opções principais: herança ("é-um") e composição ("tem-um"). Escolher a abordagem certa impacta significativamente a flexibilidade e a manutenibilidade do seu código.

Herança cria um forte acoplamento entre classes. Um Car que herda de Vehicle fica permanentemente vinculado a esse relacionamento:

class Vehicle {
public:
    virtual void start() { std::cout << "Starting vehicle\n"; }
};

class Car : public Vehicle {
public:
    void start() override { std::cout << "Starting car\n"; }
};

Composição incorpora objetos como membros, criando um relacionamento mais flexível. Um Car tem um Engine em vez de ser um motor:

class Engine {
public:
    void start() { std::cout << "Engine running\n"; }
};

class Car {
private:
    Engine engine;  // Car TEM um Engine
public:
    void start() { engine.start(); }
};

A principal vantagem da composição é a flexibilidade. Você pode facilmente trocar componentes, alterar o comportamento em tempo de execução ou combinar vários recursos sem as limitações de uma hierarquia rígida de classes. O design moderno de C++ favorece a composição em vez da herança na maioria dos casos.

Use herança quando houver uma relação genuína de "is-a" e você precisar de polimorfismo. Use composição quando quiser reutilizar funcionalidades ou quando a relação for melhor descrita como "has-a" ou "uses-a".

Desafio

Fácil

Vamos criar um simulador de sistema de computador que demonstra quando usar composição em vez de herança. Você modelará um computador que tem componentes (composição), em vez de ser um componente, mostrando como a composição oferece flexibilidade para trocar peças em tempo de execução.

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

Components.h: Defina os componentes individuais que um computador pode conter.
Crie uma classe CPU com um std::string model privado e um int cores. Forneça um construtor que receba ambos os valores, um método process() que exiba CPU [model] processing with [cores] cores e um método getModel().

Crie uma classe Memory com um int sizeGB privado. Forneça um construtor, um método load() que exiba Loading data into [sizeGB]GB RAM e um método getSize().

Crie uma classe Storage com um std::string type privado (como "SSD" ou "HDD") e um int capacityGB. Forneça um construtor, um método read() que exiba Reading from [capacityGB]GB [type] e métodos getter para ambos os campos.
Computer.h: Defina uma classe Computer que use composição para combinar componentes.
Sua classe Computer deve ter objetos-membro privados: um CPU, uma Memory e um Storage. Use a lista de inicialização do construtor para inicializar esses componentes a partir dos parâmetros.

Implemente estes métodos:
- boot(): exibe Booting computer... e, em seguida, chama load() na memória, read() no armazenamento e process() na CPU, cada um em uma linha separada
- specs(): exibe as especificações do computador neste formato:
```
Computer Specs:
- CPU: [model] ([cores] cores)
- RAM: [size]GB
- Storage: [capacity]GB [type]
```
main.cpp: Leia seis entradas (cada uma em uma linha separada):
1. Nome do modelo da CPU (string)
2. Número de núcleos da CPU (inteiro)
3. Tamanho da memória em GB (inteiro)
4. Tipo de armazenamento (string, por exemplo, "SSD")
5. Capacidade do armazenamento em GB (inteiro)
6. Um comando: "boot" ou "specs"
Crie os objetos dos componentes e, em seguida, crie um Computer usando composição. Com base no comando, chame boot() ou specs().

Por exemplo, com as entradas Intel i7, 8, 16, SSD, 512 e boot:

Booting computer...
Loading data into 16GB RAM
Reading from 512GB SSD
CPU Intel i7 processing with 8 cores

Com as entradas AMD Ryzen, 6, 32, HDD, 1000 e specs:

Computer Specs:
- CPU: AMD Ryzen (6 cores)
- RAM: 32GB
- Storage: 1000GB HDD

Observe como a classe Computer não herda de nenhum componente. Ela os contém. Esse relacionamento de "tem um" significa que você poderia criar facilmente computadores com diferentes combinações de componentes ou até mesmo trocar componentes posteriormente se adicionasse métodos setter. Essa flexibilidade é a principal vantagem da composição sobre a herança.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Computer.h"

using namespace std;

int main() {
    // Ler entradas
    string cpuModel;
    getline(cin, cpuModel);  // Nome do modelo da CPU (pode conter espaços)
    
    int cpuCores;
    cin >> cpuCores;  // Número de núcleos da CPU
    
    int memorySize;
    cin >> memorySize;  // Tamanho da memória em GB
    
    string storageType;
    cin >> storageType;  // Tipo de armazenamento (ex.: "SSD")
    
    int storageCapacity;
    cin >> storageCapacity;  // Capacidade de armazenamento em GB
    
    string command;
    cin >> command;  // Comando: "boot" ou "specs"

    // TODO: Criar objetos de componentes (CPU, Memory, Storage)
    
    // TODO: Criar um objeto Computer usando composição
    
    // TODO: Com base no comando, chame boot() ou specs()

    return 0;
}