Repaso de las funciones virtuales

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 en tiempo de ejecución, veamos más a fondo 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 le indica explícitamente al compilador que tienes la intención de 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 fundamental porque detecta errores en tiempo de compilación. Si escribes mal el nombre de la función por accidente 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 ninguna función que sobrescribir
        std::cout << "Meow!" << std::endl;
    }
};

El especificador final impide que se siga sobrescribiendo. Ú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 una función final
};

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

Desafío

Fácil

Vamos a crear un sistema de notificaciones que demuestra el poder de las palabras clave override y final con funciones virtuales. Crearás una jerarquía de controladores de notificaciones en la que algunos métodos se pueden personalizar aún más y otros se bloquean para evitar modificaciones.

Organizarás tu código en tres archivos:

Notifier.h: Define una clase base Notifier que representa cualquier emisor de notificaciones:
- Un miembro protegido std::string recipient
- Un constructor que recibe y almacena el nombre del destinatario
- Un método virtual send(const std::string& message) que imprime: Notifying <recipient>: <message>
- Un método virtual getType() que devuelve la cadena "Generic"
- Un destructor virtual
EmailNotifier.h: Define una clase EmailNotifier que hereda de Notifier:
- Un miembro privado std::string domain
- Un constructor que recibe el destinatario y el dominio, y pasa el destinatario a la clase base
- Anula send() para que imprima: Emailing <recipient>@<domain>: <message>
- Anula getType() y márcalo como final. Debe devolver "Email"
Después, define una clase UrgentEmailNotifier que hereda de EmailNotifier:
- Un constructor que recibe el destinatario y el dominio, y pasa ambos a EmailNotifier
- Anula send() para que imprima: [URGENT] Emailing <recipient>@<domain>: <message>
- Nota: aquí no puedes anular getType() porque se marcó como final en EmailNotifier
main.cpp: Lee tres datos de entrada (cada uno en una línea separada):
1. Nombre del destinatario
2. Dominio del correo electrónico
3. Texto del mensaje
Crea dinámicamente tres objetos notificadores: un Notifier base, un EmailNotifier y un UrgentEmailNotifier: todos con el mismo destinatario (y el mismo dominio cuando corresponda). Guárdalos 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 formato a cada entrada así:
```
Type: <type>
<send output>
```
Imprime una línea en blanco entre cada notificador. Cuando termines, libera los objetos asignados dinámicamente.

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 anular 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 anulados para detectar cualquier incompatibilidad de firmas en tiempo de 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 arreglo de punteros Notifier* con 3 elementos
    
    // TODO: Crea dinámicamente:
    // - Un Notifier base con recipient
    // - Un EmailNotifier con recipient y domain
    // - Un UrgentEmailNotifier con recipient y domain
    
    // TODO: Recorre el arreglo y, para cada notificador:
    // - Imprime "Type: " seguido del resultado de getType()
    // - Llama a send() con message
    // - Imprime una línea en blanco entre notificadores (no después del último)
    
    // TODO: Libera los objetos asignados dinámicamente
    
    return 0;
}