Menu
CoddyTech

Polimorfismo en compilación y en tiempo de ejecución

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 56 de 104.

Polimorfismo significa «muchas formas» y es un concepto fundamental de la POO que permite tratar los objetos de manera uniforme mientras se comportan de forma diferente. C++ admite dos tipos distintos de polimorfismo, cada uno resuelto en una etapa diferente de la ejecución del programa.

El polimorfismo en tiempo de compilación (también llamado polimorfismo estático) se resuelve en el compilador antes de que se ejecute el programa. El compilador determina exactamente qué función llamar según la firma de la función. Esto incluye la sobrecarga de funciones y las plantillas:

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

print(5);      // El compilador elige print(int)
print(3.14);   // El compilador elige print(double)

El polimorfismo en tiempo de ejecución (también llamado polimorfismo dinámico) se resuelve mientras se ejecuta el programa. La decisión sobre qué función llamar depende del tipo real del objeto, no del tipo del puntero o de la referencia. Esto se logra mediante funciones virtuales:

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();  // Se determina en tiempo de ejecución: "Drawing circle"

La principal disyuntiva: el polimorfismo en tiempo de compilación no tiene ningún costo adicional en tiempo de ejecución, ya que las decisiones se toman durante la compilación, mientras que el polimorfismo en tiempo de ejecución añade un pequeño costo (búsqueda en la tabla virtual), pero ofrece mayor flexibilidad para trabajar con objetos cuyos tipos no se conocen hasta la ejecución.

challenge icon

Desafío

Fácil

Construyamos un sistema de calculadora que demuestre ambos tipos de polimorfismo uno al lado del otro. Crearás un sistema en el que el polimorfismo en tiempo de compilación maneja diferentes tipos de entrada mediante la sobrecarga de funciones, mientras que el polimorfismo en tiempo de ejecución permite intercambiar dinámicamente distintas estrategias de cálculo.

Organizarás tu código en tres archivos:

  • Calculator.h: Define una clase base Calculator que representa cualquier estrategia de cálculo:
    • Un método virtual calculate(int a, int b) que devuelve un int e imprime: Base calculation: <a> ? <b> (y devuelve 0)
    • Un destructor virtual
  • Operations.h: Define dos clases de calculadora derivadas que sobrescriben el comportamiento de cálculo:
    • Adder: Sobrescribe calculate() para imprimir Adding: <a> + <b> y devolver la suma
    • Multiplier: Sobrescribe calculate() para imprimir Multiplying: <a> * <b> y devolver el producto
    Ambas clases deben usar la palabra clave override.
  • main.cpp: Crea un sistema que muestre ambos tipos de polimorfismo. Lee dos entradas enteras (cada una en una línea separada).

    Primero, demuestra el polimorfismo en tiempo de compilación creando tres funciones display() sobrecargadas:

    • display(int x) imprime: Integer value: <x>
    • display(double x) imprime: Double value: <x>
    • display(const std::string& x) imprime: String value: <x>

    Después, demuestra el polimorfismo en tiempo de ejecución creando un arreglo de punteros Calculator* que contenga una clase base Calculator, una clase Adder y una clase Multiplier. Recorre el arreglo y llama a calculate() en cada elemento con tus valores de entrada, imprimiendo el resultado después de cada cálculo.

    Estructura la salida de la siguiente manera:

    === Compile-Time Polymorphism ===
    <display outputs for int, double, string>
    
    === Runtime Polymorphism ===
    <calculate outputs with results>

    Para la sección de tiempo de compilación, llama a display() con la primera entrada como entero, después como número de punto flotante (el mismo valor con .5 sumado) y luego como la cadena "Result". Libera las calculadoras asignadas dinámicamente cuando termines.

Por ejemplo, con las entradas 10 y 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

Observa cómo el compilador selecciona la sobrecarga correcta de display() según el tipo del argumento (decisión en tiempo de compilación), mientras que el método calculate() correcto se determina por el tipo real del objeto en tiempo de ejecución mediante el mecanismo de la tabla virtual.

Pruébalo tú mismo

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

// TODO: Crea tres funciones display() sobrecargadas:
// 1. display(int x) - imprime "Integer value: <x>"
// 2. display(double x) - imprime "Double value: <x>"
// 3. display(const std::string& x) - imprime "String value: <x>"



int main() {
    // Lee dos valores enteros de entrada
    int a, b;
    std::cin >> a;
    std::cin >> b;
    
    // === Compile-Time Polymorphism ===
    std::cout << "=== Compile-Time Polymorphism ===" << std::endl;
    // TODO: Llama a display() con:
    // - a como entero
    // - a como double (súmale 0.5)
    // - la cadena "Result"
    
    
    std::cout << std::endl;
    
    // === Runtime Polymorphism ===
    std::cout << "=== Runtime Polymorphism ===" << std::endl;
    // TODO: Crea un arreglo de punteros Calculator* con 3 elementos:
    // - un Calculator base
    // - un Adder
    // - un Multiplier
    
    // TODO: Recorre el array y llama a calculate(a, b) en cada elemento,
    // e imprime "Result: <return_value>" después de cada cálculo
    
    
    // TODO: Libera la memoria asignada dinámicamente
    
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online