1. Herencia: Reutilizar sin Duplicar Código

La herencia permite crear una clase derivada (hija) que absorbe todos los atributos y métodos de una clase base (padre), añadiendo sus propias especializaciones.

herencia_personajes.cpp

CPP

#include <iostream>
#include <string>
 
// Clase Base
class Personaje {
protected:
    std::string nombre;
    int salud;
 
public:
    Personaje(std::string n, int s) : nombre(n), salud(s) {}
 
    void recibirDanio(int danio) {
        salud -= danio;
        std::cout << nombre << " recibió " << danio << " de daño. Salud restante: " << salud << "\n";
    }
};
 
// Clase Derivada (Hereda de Personaje)
class Mago : public Personaje {
private:
    int mana;
 
public:
    Mago(std::string n, int s, int m) : Personaje(n, s), mana(m) {}
 
    void lanzarHechizo() {
        std::cout << nombre << " lanza Bola de Fuego consumiendo 20 de mana!\n";
        mana -= 20;
    }
};

💡 ¿Por qué usamos protected?

Si los atributos fueran private en Personaje, ni siquiera la clase hija Mago podría acceder a nombre. Con protected, quedan protegidos del mundo exterior pero accesibles para sus clases hijas.

2. Polimorfismo Dinámico: La Magia de `virtual` y `override`

El polimorfismo te permite tratar a objetos diferentes a través de un mismo puntero a la clase base, ejecutando la versión especializada de cada uno en tiempo de ejecución.

🔮 ¿Por qué es obligatoria la palabra clave virtual?

Por defecto, C++ enlaza las llamadas a métodos en tiempo de compilación según el tipo del puntero. Al marcar una función como virtual, C++ activa la vtable (tabla de métodos virtuales), averiguando el tipo real del objeto en tiempo de ejecución.

polimorfismo_videojuego.cpp

CPP

#include <iostream>
#include <vector>
 
class Enemigo {
public:
    virtual void atacar() const {
        std::cout << "Ataque genérico del enemigo.\n";
    }
    // Destructor virtual obligatorio para liberar memoria limpia:
    virtual ~Enemigo() = default;
};
 
class Dragon : public Enemigo {
public:
    void atacar() const override {
        std::cout << "¡El Dragón escupe fuego devastador! 🔥\n";
    }
};
 
class Zombie : public Enemigo {
public:
    void atacar() const override {
        std::cout << "El Zombie muerde al jugador... 🧟\n";
    }
};
 
int main() {
    // Vector polimórfico de punteros a la base:
    std::vector<Enemigo*> horda;
    horda.push_back(new Dragon());
    horda.push_back(new Zombie());
 
    // El bucle principal no sabe qué criatura es, solo sabe que puede atacar:
    for (Enemigo* e : horda) {
        e->atacar(); // Ejecuta el ataque correcto de cada criatura
    }
 
    // Limpieza de memoria:
    for (Enemigo* e : horda) delete e;
    return 0;
}

3. ⚠️ El Destructor Virtual: Previniendo Fugas de Memoria

Si eliminas un objeto derivado a través de un puntero a la clase base (delete e;), y la clase base no tiene un destructor virtual, ¡solo se ejecutará el destructor de la base y la memoria de la clase hija quedará filtrada en la RAM!

virtual ~ClaseBase() = default; // Agrega esto siempre a tus clases base

Ejercicio de Cierre del Curso

Diseña una clase base abstracta Figura con un método virtual puro virtual double calcularArea() const = 0;. Implementa dos clases derivadas: Rectangulo (ancho, alto) y Circulo (radio). Crea un vector de punteros a Figura y muestra el área de cada figura en un bucle polimórfico.

Ver solución completa

Código

CPP

#include <iostream>
#include <vector>
 
class Figura {
public:
    virtual double calcularArea() const = 0; // Virtual pura
    virtual ~Figura() = default;
};
 
class Rectangulo : public Figura {
private:
    double ancho, alto;
public:
    Rectangulo(double a, double h) : ancho(a), alto(h) {}
    double calcularArea() const override { return ancho * alto; }
};
 
class Circulo : public Figura {
private:
    double radio;
public:
    Circulo(double r) : radio(r) {}
    double calcularArea() const override { return 3.14159 * radio * radio; }
};
 
int main() {
    std::vector<Figura*> figuras = {
        new Rectangulo(4.0, 5.0),
        new Circulo(3.0)
    };
 
    for (Figura* f : figuras) {
        std::cout << "Área de figura: " << f->calcularArea() << "\n";
        delete f;
    }
    return 0;
}

Contenido

📚 Cursos de Café y Código

10. Pilares de POO: Herencia y Polimorfismo Dinámico 🏛️⚡

1. Herencia: Reutilizar sin Duplicar Código

2. Polimorfismo Dinámico: La Magia de `virtual` y `override`

🔮 ¿Por qué es obligatoria la palabra clave virtual?

3. ⚠️ El Destructor Virtual: Previniendo Fugas de Memoria

Ejercicio de Cierre del Curso

Comprueba lo que Has Aprendido 🧠

¡Hecho con mucho cariño! ☕

10. Pilares de POO: Herencia y Polimorfismo Dinámico 🏛️⚡

1. Herencia: Reutilizar sin Duplicar Código

2. Polimorfismo Dinámico: La Magia de virtual y override

🔮 ¿Por qué es obligatoria la palabra clave virtual?

3. ⚠️ El Destructor Virtual: Previniendo Fugas de Memoria

Ejercicio de Cierre del Curso

Comprueba lo que Has Aprendido 🧠

2. Polimorfismo Dinámico: La Magia de `virtual` y `override`