Herencia virtual

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

El problema del diamante ocurre cuando una clase hereda de dos clases que comparten una clase base común. Sin un tratamiento especial, la clase derivada acaba teniendo dos copias de la clase base común, lo que provoca ambigüedad y desperdicio de memoria.

class Animal {
public:
    int age;
};

class Mammal : public Animal {};
class Bird : public Animal {};

class Bat : public Mammal, public Bird {};

Bat b;
b.age = 5;  // Error: ambiguo: ¿cuál 'age'?

La clase Bat contiene dos subobjetos Animal separados: uno a través de Mammal y otro a través de Bird. Esto crea el diagrama de herencia en forma de diamante que da nombre al problema.

La herencia virtual resuelve esto al garantizar que solo exista una copia de la clase base común. Añade la palabra clave virtual al heredar de la clase base compartida:

class Animal {
public:
    int age;
    Animal(int a = 0) : age(a) {}
};

class Mammal : virtual public Animal {
public:
    Mammal(int a = 0) : Animal(a) {}
};

class Bird : virtual public Animal {
public:
    Bird(int a = 0) : Animal(a) {}
};

class Bat : public Mammal, public Bird {
public:
    Bat(int a) : Animal(a), Mammal(a), Bird(a) {}
};

Bat b(5);
b.age = 10;  // ¡Funciona! Solo existe un 'age'

Ten en cuenta que Bat debe inicializar directamente Animal en su constructor. Con la herencia virtual, la clase más derivada es responsable de construir la clase base virtual, independientemente de las clases intermedias.

Desafío

Fácil

Vamos a crear un sistema de gestión de trabajadores que demuestre cómo la herencia virtual resuelve el problema del diamante. Crearás una jerarquía en la que TeamLead hereda tanto de Developer como de Manager, que comparten una clase base común, Employee.

Organizarás tu código en cuatro archivos:

Employee.h: Define la clase base común Employee con:
- Un std::string name y un int id protegidos
- Un constructor que recibe ambos valores e imprime: Employee [<name>] hired with ID <id>
- Un método público getInfo() que imprime: Employee: <name> (ID: <id>)
- Un destructor virtual que imprime: Employee [<name>] record closed
Developer.h: Define una clase Developer que usa herencia pública virtual de Employee:
- Un miembro protegido std::string language
- Un constructor que recibe name, id y language: pasa name e id a Employee, almacena language e imprime: Developer [<name>] specializes in <language>
- Un método público code() que imprime: <name> is coding in <language>
- Un destructor que imprime: Developer [<name>] signed off
Manager.h: Define una clase Manager que usa herencia pública virtual de Employee:
- Un miembro protegido int teamSize
- Un constructor que recibe name, id y el tamaño del equipo: pasa name e id a Employee, almacena el tamaño del equipo e imprime: Manager [<name>] leads a team of <teamSize>
- Un método público manage() que imprime: <name> is managing <teamSize> people
- Un destructor que imprime: Manager [<name>] stepped down
main.cpp: Lee cuatro datos de entrada (cada uno en una línea aparte):
1. Nombre (cadena)
2. ID del empleado (entero)
3. Lenguaje de programación (cadena)
4. Tamaño del equipo (entero)
Define una clase TeamLead que herede públicamente tanto de Developer como de Manager:
- Un constructor que recibe los cuatro parámetros y debe inicializar directamente Employee (la base virtual), luego Developer y Manager
- El constructor debe imprimir: TeamLead [<name>] ready to lead and code!
- Un método showRole() que llama a getInfo(), code() y manage(), en ese orden
- Un destructor que imprime: TeamLead [<name>] promoted out
Crea un objeto TeamLead dentro de un ámbito de bloque, llama a showRole() y luego deja que salga del ámbito. Después del bloque, imprime: Organization restructured!

Por ejemplo, con las entradas Alice, 101, C++ y 5:

Employee [Alice] hired with ID 101
Developer [Alice] specializes in C++
Manager [Alice] leads a team of 5
TeamLead [Alice] ready to lead and code!
Employee: Alice (ID: 101)
Alice is coding in C++
Alice is managing 5 people
TeamLead [Alice] promoted out
Manager [Alice] stepped down
Developer [Alice] signed off
Employee [Alice] record closed
Organization restructured!

Observa que solo hay una llamada al constructor de Employee y una llamada al destructor de Employee: la herencia virtual garantiza que exista una sola copia de la base compartida. TeamLead debe inicializar directamente Employee porque, con la herencia virtual, la clase más derivada es responsable de construir la base virtual.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Developer.h"
#include "Manager.h"

using namespace std;

// TODO: Define la clase TeamLead que hereda públicamente tanto de Developer como de Manager
// Recuerda: Con herencia virtual, TeamLead debe inicializar directamente Employee (la clase base virtual)
class TeamLead : public Developer, public Manager {
public:
    // TODO: Implementa un constructor que reciba name, id, language y teamSize
    // Debe inicializar: primero Employee (clase base virtual), luego Developer y después Manager
    // Debe imprimir: TeamLead [<name>] ready to lead and code!
    TeamLead(const std::string& name, int id, const std::string& language, int teamSize)
        : Employee(name, id),
          Developer(name, id, language),
          Manager(name, id, teamSize) {
        // TODO: Imprime el mensaje del constructor
    }

    // TODO: Implementa el método showRole()
    // Debe llamar a getInfo(), code() y manage() en ese orden
    void showRole() {
        // TODO: Llama a los tres métodos
    }

    // TODO: Implementa el destructor
    // Debe imprimir: TeamLead [<name>] promoted out
    ~TeamLead() {
        // TODO: Imprime el mensaje del destructor
    }
};

int main() {
    // Lee las entradas
    string name;
    int id;
    string language;
    int teamSize;

    getline(cin, name);
    cin >> id;
    cin.ignore();
    getline(cin, language);
    cin >> teamSize;

    // TODO: Crea un objeto TeamLead dentro del ámbito de un bloque
    // Llama a showRole() y luego deja que el objeto salga del ámbito
    {
        // TODO: Crea un objeto TeamLead y llama a showRole()
    }

    // Imprime el mensaje final después del bloque
    cout << "Organization restructured!" << endl;

    return 0;
}