38 Derivación múltiple

C++ permite crear clases derivadas a partir de varias clases base. Este proceso se conoce como derivación múltiple. Los objetos creados a partir de las clases así obtenidas, heredarán los datos y funciones de todas las clases base.

Sintaxis:

<clase_derivada>(<lista_de_parámetros>) : 
   <clase_base1>(<lista_de_parámetros>)
     [, <clase_base2>(<lista_de_parámetros>)] {}

Pero esto puede producir algunos problemas. En ocasiones puede suceder que en las dos clases base exista una función con el mismo nombre. Esto crea una ambigüedad cuando se invoca a una de esas funciones.

Veamos un ejemplo:

#include <iostream>
using namespace std;

class ClaseA {
   public:
     ClaseA() : valorA(10) {}
     int LeerValor() const { return valorA; }
   protected:
     int valorA;
};

class ClaseB {
   public:
     ClaseB() : valorB(20) {}
     int LeerValor() const { return valorB; }
   protected:
     int valorB;
};

class ClaseC : public ClaseA, public ClaseB {};

int main() {
   ClaseC CC;

   // cout << CC.LeerValor() << endl;
   // Produce error de compilación por ambigüedad.
   cout << CC.ClaseA::LeerValor() << endl;
   
   return 0;
}

Una solución para resolver la ambigüedad es la que hemos adoptado en el ejemplo. Pero existe otra, también podríamos haber redefinido la función "LeerValor" en la clase derivada de modo que se superpusiese a las funciones de las clases base.

#include <iostream>
using namespace std;

class ClaseA {
   public:
     ClaseA() : valorA(10) {}
     int LeerValor() const { return valorA; }
   protected:
     int valorA;
};

class ClaseB {
   public:
     ClaseB() : valorB(20) {}
     int LeerValor() const { return valorB; }
   protected:
     int valorB;
};

class ClaseC : public ClaseA, public ClaseB {
   public:
    int LeerValor() const { return ClaseA::LeerValor(); }
};

int main() {
   ClaseC CC;

   cout << CC.LeerValor() << endl;
   
   return 0;
}

Constructores de clases con herencia múltiple

Análogamente a lo que sucedía con la derivación simple, en el caso de derivación múltiple el constructor de la clase derivada deberá llamar a los constructores de las clases base cuando sea necesario. Por ejemplo, añadiremos constructores al ejemplo anterior:

#include <iostream>
using namespace std;

class ClaseA {
   public:
     ClaseA() : valorA(10) {}
     ClaseA(int va) : valorA(va) {}
     int LeerValor() const { return valorA; }
   protected:
     int valorA;
};

class ClaseB {
   public:
     ClaseB() : valorB(20) {}
     ClaseB(int vb) : valorB(vb) {}
     int LeerValor() const { return valorB; }
   protected:
     int valorB;
};

class ClaseC : public ClaseA, public ClaseB {
   public:
     ClaseC(int va, int vb) : ClaseA(va), ClaseB(vb) {};
     int LeerValorA() const { return ClaseA::LeerValor(); }
     int LeerValorB() const { return ClaseB::LeerValor(); }
};

int main() {
   ClaseC CC(12,14);

   cout << CC.LeerValorA() << "," 
        << CC.LeerValorB() << endl;
   
   return 0;
}

Sintaxis:

<clase_derivada>(<lista_parámetros> : 
   <clase_base1>(<lista_parámetros>) 
     [, <clase_base2>(<lista_parámetros>)] {}

Herencia virtual

Supongamos que tenemos una estructura de clases como ésta:

Herencia
Derivación ambigua

La ClaseD heredará dos veces los datos y funciones de la ClaseA, con la consiguiente ambigüedad a la hora de acceder a datos o funciones heredadas de ClaseA.

Para solucionar esto se usan las clases virtuales. Cuando derivemos una clase partiendo de una o varias clases base, podemos hacer que las clases base sean virtuales. Esto no afectará a la clase derivada. Por ejemplo:

class ClaseB : virtual public ClaseA {};

Desde el punto de vista de la ClaseB, no hay ninguna diferencia entre ésta declaración y la que hemos usado hasta ahora. La diferencia estará cuando declaramos la ClaseD. Veamos el ejemplo completo:

class ClaseB : virtual public ClaseA {};
class ClaseC : virtual public ClaseA {};
class ClaseD : public ClaseB, public ClaseC {};

Ahora, la ClaseD sólo heredará una vez la ClaseA. La estructura quedará así:

Herencia
Derivación no ambigua

Cuando creemos una estructura de este tipo, deberemos tener cuidado con los constructores, el constructor de la ClaseA deberá ser invocado desde el de la ClaseD, ya que ni la ClaseB ni la ClaseC lo harán automáticamente.

Veamos esto con el ejemplo de la clase "Persona". Derivaremos las clases "Empleado" y "Estudiante", y crearemos una nueva clase "Becario" derivada de estas dos últimas. Además haremos que la clase "Persona" sea virtual, de modo que no se dupliquen sus funciones y datos.

#include <iostream>
#include <cstring>
using namespace std;

class Persona {
   public:
     Persona(char *n) { strcpy(nombre, n); }
     const char *LeeNombre() const { return nombre; }
   protected:
     char nombre[30];
};

class Empleado : virtual public Persona {
   public:
     Empleado(char *n, int s) : Persona(n), salario(s) {}
     int LeeSalario() const { return salario; }
     void ModificaSalario(int s) { salario = s; }
   protected:
     int salario;
};

class Estudiante : virtual public Persona {
   public:
     Estudiante(char *n, float no) : Persona(n), nota(no) {}
     float LeeNota() const { return nota; }
     void ModificaNota(float no) { nota = no; }
   protected:
     float nota;
};

class Becario : public Empleado, public Estudiante {
   public:
     Becario(char *n, int s, float no) :
        Empleado(n, s), Estudiante(n, no), Persona(n) {} // (1)
};

int main() {
   Becario Fulanito("Fulano", 1000, 7);

   cout << Fulanito.LeeNombre() << "," 
        << Fulanito.LeeSalario() << "," 
        << Fulanito.LeeNota() << endl;
   
   return 0;
}

Si observamos el constructor de "Becario" en (1), veremos que es necesario usar el constructor de "Persona", a pesar de que el nombre se pasa como parámetro tanto a "Empleado" como a "Estudiante". Si no se incluye el constructor de "Persona", el compilador genera un error.

Funciones virtuales puras

Una función virtual pura es aquella que no necesita ser definida. En ocasiones esto puede ser útil, como se verá en el siguiente punto.

El modo de declarar una función virtual pura es asignándole el valor cero.

Sintaxis:

virtual <tipo> <nombre_función>(<lista_parámetros>) = 0;

Clases abstractas

Una clase abstracta es aquella que posee al menos una función virtual pura.

No es posible crear objetos de una clase abstracta, estas clases sólo se usan como clases base para la declaración de clases derivadas.

Las funciones virtuales puras serán aquellas que siempre se definirán en las clases derivadas, de modo que no será necesario definirlas en la clase base.

A menudo se mencionan las clases abstractas como tipos de datos abstractos, en inglés: Abstract Data Type, o resumido ADT.

Hay varias reglas a tener en cuenta con las clases abstractas:

  • No está permitido crear objetos de una clase abstracta.
  • Siempre hay que definir todas las funciones virtuales de una clase abstracta en sus clases derivadas, no hacerlo así implica que la nueva clase derivada será también abstracta.

Para crear un ejemplo de clases abstractas, recurriremos de nuevo a nuestra clase "Persona". Haremos que ésta clase sea abstracta. De hecho, en nuestros programas de ejemplo nunca hemos declarado un objeto "Persona". Veamos un ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

class Persona {
   public:
     Persona(char *n) { strcpy(nombre, n); }
     virtual void Mostrar() const = 0;
   protected:
     char nombre[30];
};

class Empleado : public Persona {
   public:
     Empleado(char *n, int s) : Persona(n), salario(s) {}
     void Mostrar() const;
     int LeeSalario() const { return salario; }
     void ModificaSalario(int s) { salario = s; }
   protected:
     int salario;
};

void Empleado::Mostrar() const {
    cout << "Empleado: " << nombre 
         << ", Salario: " << salario 
         << endl;
}

class Estudiante : public Persona {
   public:
     Estudiante(char *n, float no) : Persona(n), nota(no) {}
     void Mostrar() const;
     float LeeNota() const { return nota; }
     void ModificaNota(float no) { nota = no; }
   protected:
     float nota;
};

void Estudiante::Mostrar() const {
    cout << "Estudiante: " << nombre 
         << ", Nota: " << nota << endl;
}

int main() {
   Persona *Pepito = new Empleado("Jose", 1000); // (1)
   Persona *Pablito = new Estudiante("Pablo", 7.56);

   Pepito->Mostrar();
   Pablito->Mostrar();
   
   delete Pepito;
   delete Pablito;
   
   return 0;
}

La salida será así:

Empleado: Jose, Salario: 1000
Estudiante: Pablo, Nota: 7.56

En este ejemplo combinamos el uso de funciones virtuales puras con polimorfismo. Fíjate que, aunque hayamos declarado los objetos "Pepito" y "Pablito" de tipo puntero a "Persona" (1), en realidad no creamos objetos de ese tipo, sino de los tipos "Empleado" y "Estudiante"

Uso de derivación múltiple

Una de las aplicaciones de la derivación múltiple es la de crear clases para determinadas capacidades o funcionalidades. Estas clases se incluirán en la derivación de nuevas clases que deban tener dicha capacidad.

Por ejemplo, supongamos que nuestro programa maneja diversos tipos de objetos, de los cuales algunos son visibles y otros audibles, incluso puede haber objetos que tengan las dos propiedades. Podríamos crear clases base para visualizar objetos y para escucharlos, y derivaríamos los objetos visibles de las clases base que sea necesario y además de la clase para la visualización. Análogamente con las clases para objetos audibles.