Polimorfismo em compilação vs. execução

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

Polimorfismo significa "muitas formas" e é um conceito central da OOP que permite que os objetos sejam tratados uniformemente enquanto se comportam de maneiras diferentes. C++ oferece suporte a dois tipos distintos de polimorfismo, cada um resolvido em uma etapa diferente da execução do programa.

Polimorfismo em tempo de compilação (também chamado de polimorfismo estático) é resolvido pelo compilador antes que o programa seja executado. O compilador determina exatamente qual função chamar com base na assinatura da função. Isso inclui sobrecarga de funções e templates:

void print(int x) { std::cout << "Integer: " << x << std::endl; }
void print(double x) { std::cout << "Double: " << x << std::endl; }

print(5);      // O compilador escolhe print(int)
print(3.14);   // O compilador escolhe print(double)

Polimorfismo em tempo de execução (também chamado de polimorfismo dinâmico) é resolvido enquanto o programa está em execução. A decisão sobre qual função chamar depende do tipo real do objeto, não do tipo do ponteiro ou da referência. Isso é alcançado por meio de funções virtuais:

class Shape {
public:
    virtual void draw() { std::cout << "Drawing shape" << std::endl; }
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Drawing circle" << std::endl; }
};

Shape* s = new Circle();
s->draw();  // Decidido em tempo de execução: "Drawing circle"

A principal contrapartida: o polimorfismo em tempo de compilação não tem nenhuma sobrecarga em tempo de execução, pois as decisões são tomadas durante a compilação, enquanto o polimorfismo em tempo de execução adiciona um pequeno custo (consulta à vtable), mas oferece maior flexibilidade para trabalhar com objetos cujos tipos não são conhecidos até a execução.

Desafio

Fácil

Vamos construir um sistema de calculadora que demonstre os dois tipos de polimorfismo lado a lado. Você criará um sistema no qual o polimorfismo em tempo de compilação lida com diferentes tipos de entrada por meio da sobrecarga de funções, enquanto o polimorfismo em tempo de execução permite trocar dinamicamente diferentes estratégias de cálculo.

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

Calculator.h: Defina uma classe base Calculator que represente qualquer estratégia de cálculo:
- Um método virtual calculate(int a, int b) que retorna um int e imprime: Base calculation: <a> ? <b> (retornando 0)
- Um destrutor virtual
Operations.h: Defina duas classes de calculadora derivadas que sobrescrevam o comportamento de cálculo:
- Adder: Sobrescreva calculate() para imprimir Adding: <a> + <b> e retornar a soma
- Multiplier: Sobrescreva calculate() para imprimir Multiplying: <a> * <b> e retornar o produto
Ambas as classes devem usar a palavra-chave override.
main.cpp: Crie um sistema que demonstre os dois tipos de polimorfismo. Leia duas entradas inteiras (cada uma em uma linha separada).
Primeiro, demonstre o polimorfismo em tempo de compilação criando três funções display() sobrecarregadas:
- display(int x) imprime: Integer value: <x>
- display(double x) imprime: Double value: <x>
- display(const std::string& x) imprime: String value: <x>
Em seguida, demonstre o polimorfismo em tempo de execução criando um array de ponteiros Calculator* contendo um Calculator base, um Adder e um Multiplier. Percorra o array e chame calculate() em cada elemento com seus valores de entrada, imprimindo o resultado após cada cálculo.

Estruture sua saída da seguinte forma:
```
=== Compile-Time Polymorphism ===
<display outputs for int, double, string>

=== Runtime Polymorphism ===
<calculate outputs with results>
```
Para a seção de tempo de compilação, chame display() com a primeira entrada como um inteiro, depois como um double (o mesmo valor com .5 adicionado) e, por fim, como a string "Result". Libere as calculadoras alocadas dinamicamente quando terminar.

Por exemplo, com as entradas 10 e 3:

=== Compile-Time Polymorphism ===
Integer value: 10
Double value: 10.5
String value: Result

=== Runtime Polymorphism ===
Base calculation: 10 ? 3
Result: 0
Adding: 10 + 3
Result: 13
Multiplying: 10 * 3
Result: 30

Observe como o compilador seleciona a sobrecarga correta de display() com base no tipo do argumento (decisão em tempo de compilação), enquanto o método calculate() correto é determinado pelo tipo real do objeto em tempo de execução por meio do mecanismo de vtable.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Calculator.h"
#include "Operations.h"

// TODO: Crie três funções display() sobrecarregadas:
// 1. display(int x) - prints "Integer value: <x>"
// 2. display(double x) - imprime "Double value: <x>"
// 3. display(const std::string& x) - imprime "String value: <x>"



int main() {
    // Lê duas entradas inteiras
    int a, b;
    std::cin >> a;
    std::cin >> b;
    
    // === Compile-Time Polymorphism ===
    std::cout << "=== Compile-Time Polymorphism ===" << std::endl;
    // TODO: Chame display() com:
    // - a como um inteiro
    // - a como um double (adicione 0.5 a ele)
    // - a string "Result"
    
    
    std::cout << std::endl;
    
    // === Runtime Polymorphism ===
    std::cout << "=== Runtime Polymorphism ===" << std::endl;
    // TODO: Crie um array de ponteiros Calculator* com 3 elementos:
    // - a base Calculator
    // - um Adder
    // - um Multiplier
    
    // TODO: Percorra o array, chame calculate(a, b) em cada,
    // e imprima "Result: <return_value>" após cada cálculo
    
    
    // TODO: Limpe a memória alocada dinamicamente
    
    
    return 0;
}