Funciones virtuales revisadas

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

Ahora que entendemos la diferencia entre el polimorfismo en tiempo de compilación y el polimorfismo en tiempo de ejecución, veamos más detenidamente las funciones virtuales y la palabra clave override que hace que sean más seguras de usar.

Cuando marcas una función como virtual en una clase base, las clases derivadas pueden proporcionar su propia implementación. El especificador override indica explícitamente al compilador que pretendes sobrescribir una función virtual:

class Animal {
public:
    virtual void speak() {
        std::cout << "Some sound" << std::endl;
    }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

Usar override es crucial porque detecta errores en tiempo de compilación. Si escribes accidentalmente mal el nombre de la función o usas parámetros incorrectos, el compilador te avisará en lugar de crear silenciosamente una función nueva:

class Cat : public Animal {
public:
    void speek() override {  // Error del compilador: no hay función para sobrescribir
        std::cout << "Meow!" << std::endl;
    }
};

El especificador final impide sobrescrituras posteriores. Úsalo cuando una clase derivada deba ser la última en sobrescribir una función determinada:

class Bulldog : public Dog {
public:
    void speak() override final {
        std::cout << "Gruff woof!" << std::endl;
    }
};

class TinyBulldog : public Bulldog {
    void speak() override {}  // Error: no se puede sobrescribir la función final
};

Usa siempre override al sobrescribir funciones virtuales. Documenta tu intención y permite que el compilador verifique que realmente estás sobrescribiendo una función virtual existente.

Desafío

Fácil

Construyamos un sistema de notificaciones que demuestre el poder de las palabras clave override y final con funciones virtuales. Crearás una jerarquía de gestores de notificaciones en la que algunos métodos puedan personalizarse aún más y otros queden bloqueados para evitar modificaciones.

Organizarás tu código en tres archivos:

Notifier.h: Define una clase base Notifier que represente a cualquier emisor de notificaciones:
- Un miembro std::string recipient protegido
- Un constructor que reciba y almacene el nombre del destinatario
- Un método virtual send(const std::string& message) que imprima: Notifying <recipient>: <message>
- Un método virtual getType() que devuelva la cadena "Generic"
- Un destructor virtual
EmailNotifier.h: Define una clase EmailNotifier que herede de Notifier:
- Un miembro privado std::string domain
- Un constructor que reciba el destinatario y el dominio, pasando el destinatario a la clase base
- Redefine send() para imprimir: Emailing <recipient>@<domain>: <message>
- Redefine getType() y márcalo como final. Debe devolver "Email"
Después define una clase UrgentEmailNotifier que herede de EmailNotifier:
- Un constructor que reciba el destinatario y el dominio, pasando ambos a EmailNotifier
- Redefine send() para imprimir: [URGENT] Emailing <recipient>@<domain>: <message>
- Nota: Aquí no puedes redefinir getType() porque se marcó como final en EmailNotifier
main.cpp: Lee tres entradas, cada una en una línea independiente:
1. Nombre del destinatario
2. Dominio del correo electrónico
3. Texto del mensaje
Crea dinámicamente tres objetos de notificación: un Notifier base, un EmailNotifier y un UrgentEmailNotifier, todos usando el mismo destinatario (y el dominio cuando corresponda). Almacénalos en un arreglo de punteros Notifier*.

Recorre el arreglo y, para cada notificador, imprime su tipo usando getType() y después llama a send() con tu mensaje. Da a cada entrada el siguiente formato:
```
Type: <type>
<send output>
```
Imprime una línea en blanco entre cada notificador. Libera los objetos asignados dinámicamente cuando termines.

Por ejemplo, con las entradas Alice, company.com y Meeting at 3pm:

Type: Generic
Notifying Alice: Meeting at 3pm

Type: Email
Emailing Alice@company.com: Meeting at 3pm

Type: Email
[URGENT] Emailing Alice@company.com: Meeting at 3pm

Observa cómo UrgentEmailNotifier puede redefinir send() para personalizar el formato del mensaje, pero hereda el tipo "Email" de EmailNotifier porque getType() se marcó como final. Usa la palabra clave override en todos los métodos redefinidos para detectar cualquier discrepancia en la firma durante la compilación.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Notifier.h"
#include "EmailNotifier.h"

using namespace std;

int main() {
    // Lee las entradas
    string recipient;
    string domain;
    string message;
    
    getline(cin, recipient);
    getline(cin, domain);
    getline(cin, message);
    
    // TODO: Crea un array de punteros Notifier* con 3 elementos
    
    // TODO: Crea dinámicamente:
    // - Un Notifier base con el recipient
    // - Un EmailNotifier con recipient y domain
    // - Un UrgentEmailNotifier con recipient y domain
    
    // TODO: Recorre el array y para cada notifier:
    // - Imprime "Type: " seguido del resultado de getType()
    // - Llama a send() con el message
    // - Imprime una línea en blanco entre notifiers (no después del último)
    
    // TODO: Limpia los objetos asignados dinámicamente
    
    return 0;
}