37 Funciones virtuales:

Redefinición de funciones en clases derivadas:  

En una clase derivada se puede definir una función que ya existía en la clase base, esto se conoce como "overriding", o superposición de una función.

La definición de la función en la clase derivada oculta la definición previa en la clase base.

En caso necesario, es posible acceder a la función oculta de la clase base mediante su nombre completo:

<objeto>.<clase_base>::<método>;

Veamos un ejemplo:

#include <iostream>
using namespace std;

class ClaseA {
  public:
   ClaseA() : datoA(10) {}
   int LeerA() const { return datoA; }
   void Mostrar() { 
      cout << "a = " << datoA << endl; (1)
   }
  protected:
   int datoA;
};

class ClaseB : public ClaseA {
  public:
   ClaseB() : datoB(20) {}
   int LeerB() const { return datoB; }
   void Mostrar() { 
      cout << "a = " << datoA << ", b = " 
           << datoB << endl; (2)
   }
  protected:
   int datoB;
};

int main() {
   ClaseB objeto;
 
   objeto.Mostrar();
   objeto.ClaseA::Mostrar();
   
   cin.get();
   return 0;
}

La salida de este programa es:

a = 10, b = 20
a = 10

La definición de la función "Mostrar" en la ClaseB (1) oculta la definición previa de la función en la ClaseA (2).

Superposición y sobrecarga:  

Cuando se superpone una función, se ocultan todas las funciones con el mismo nombre en la clase base.

Supongamos que hemos sobrecargado la función de la clase base que después volveremos a definir en la clase derivada.

#include <iostream>
using namespace std;

class ClaseA {
  public:
   void Incrementar() { cout << "Suma 1" << endl; }
   void Incrementar(int n) { cout << "Suma " << n << endl; }
};

class ClaseB : public ClaseA {
  public:
   void Incrementar() { cout << "Suma 2" << endl; }
};

int main() {
   ClaseB objeto;

   objeto.Incrementar();
//   objeto.Incrementar(10);
   objeto.ClaseA::Incrementar();
   objeto.ClaseA::Incrementar(10);
   
   cin.get();
   return 0;
}

La salida sería:

Suma 2
Suma 1
Suma 10

Ahora bien, no es posible acceder a ninguna de las funciones superpuestas de la clase base, aunque tengan distintos valores de retorno o distinto número o tipo de parámetros. Todas las funciones "incrementar" de la clase base han quedado ocultas, y sólo son accesibles mediante el nombre completo.

Polimorfismo:  

Por fin vamos a introducir un concepto muy importante de la programación orientada a objetos: el polimorfismo.

En lo que concierne a clases, el polimorfismo en C++, llega a su máxima expresión cuando las usamos junto con punteros o con referencias.

C++ nos permite acceder a objetos de una clase derivada usando un puntero a la clase base. En eso consiste el polimorfismo. Por supuesto, sólo podremos acceder a datos y funciones que existan en la clase base, los datos y funciones propias de los objetos de clases derivadas serán inaccesibles.

Volvamos al ejemplo inicial, el de la estructura de clases basado en la clase "Persona" y supongamos que tenemos la clase base "Persona" y dos clases derivadas: "Empleado" y "Estudiante".

#include <iostream>
#include <cstring>
using namespace std;
 
class Persona {
  public:
   Persona(char *n) { strcpy(nombre, n); }
   void VerNombre() { cout << nombre << endl; }
  protected:
   char nombre[30];
};

class Empleado : public Persona {
  public:
   Empleado(char *n) : Persona(n) {}
   void VerNombre() { 
      cout << "Emp: " << nombre << endl; 
   }
};

class Estudiante : public Persona {
  public:
   Estudiante(char *n) : Persona(n) {}
   void VerNombre() { 
      cout << "Est: " << nombre << endl; 
   }
};

int main() {
   Persona *Pepito = new Estudiante("Jose");
   Persona *Carlos = new Empleado("Carlos");

   Carlos->VerNombre();
   Pepito->VerNombre();
   delete Pepito;
   delete Carlos;
   
   cin.get();
   return 0;
}

La salida es como ésta:

Carlos
Jose

Podemos comprobar que se ejecuta la versión de la función "VerNombre" que hemos definido para la clase base, y no la de las clases derivadas.

Funciones virtuales:  

El ejemplo anterior demuestra algunas de las posibilidades del polimorfismo, pero tal vez sería mucho más interesante que cuando se invoque a una función que se superpone en la clase derivada, se llame a ésta última función, la de la clase derivada.

En nuestro ejemplo, podemos preferir que al llamar a la función "VerNombre" se ejecute la versión de la clase derivada en lugar de la de la clase base.

Esto se consigue mediante el uso de funciones virtuales. Cuando en una clase declaramos una función como virtual, y la superponemos en alguna clase derivada, al invocarla usando un puntero de la clase base, se ejecutará la versión de la clase derivada.

Sintaxis:

virtual <tipo> <nombre_función>(<lista_parámetros>) [{}];

Modifiquemos en el ejemplo anterior la declaración de la clase base "Persona".

class Persona {
  public:
   Persona(char *n) { strcpy(nombre, n); }
   virtual void VerNombre() { 
      cout << nombre << endl; 
   }
  protected:
   char nombre[30];
};

Ahora ejecutemos el programa de nuevo, veremos que la salida es ahora diferente:

Emp: Carlos
Est: Jose

Ahora, al llamar a "Pepito->VerNombre(n)" se invoca a la función "VerNombre" de la clase "Estudiante", y al llamar a "Carlos->VerNombre(n)" se invoca a la función de la clase "Empleado".

Una vez que una función es declarada como virtual, lo seguirá siendo en las clases derivadas, es decir, la propiedad virtual se hereda.

Si la función virtual no se define exactamente con el mismo tipo de valor de retorno y el mismo número y tipo de parámetros que en la clase base, no se considerará como la misma función, sino como una función superpuesta.

Este mecanismo sólo funciona con punteros y referencias, usarlo con objetos no tiene sentido.

Veamos un ejemplo con referencias:

#include <iostream>
#include <cstring>
using namespace std;
 
class Persona {
  public:
   Persona(char *n) { strcpy(nombre, n); }
   virtual void VerNombre() { 
      cout << nombre << endl; 
   }
  protected:
   char nombre[30];
};

class Empleado : public Persona {
  public:
   Empleado(char *n) : Persona(n) {}
   void VerNombre() { 
      cout << "Emp: " << nombre << endl; 
   }
};

class Estudiante : public Persona {
  public:
   Estudiante(char *n) : Persona(n) {}
   void VerNombre() { 
      cout << "Est: " << nombre << endl; 
   }
};

int main() {
   Estudiante Pepito("Jose");
   Empleado Carlos("Carlos");
   Persona &rPepito = Pepito; // Referencia como Persona
   Persona &rCarlos = Carlos; // Referencia como Persona

   rCarlos.VerNombre();
   rPepito.VerNombre();
    
   cin.get();
   return 0;
}

Destructores virtuales:  

Supongamos que tenemos una estructura de clases en la que en alguna de las clases derivadas exista un destructor. Un destructor es una función como las demás, por lo tanto, si destruimos un objeto referenciado mediante un puntero a la clase base, y el destructor no es virtual, estaremos llamando al destructor de la clase base. Esto puede ser desastroso, ya que nuestra clase derivada puede tener más tareas que realizar en su destructor que la clase base de la que procede.

Por lo tanto debemos respetar siempre ésta regla: si en una clase existen funciones virtuales, el destructor debe ser virtual.

Constructores virtuales:  

Los constructores no pueden ser virtuales. Esto puede ser un problema en ciertas ocasiones. Por ejemplo, el constructor copia no hará siempre aquello que esperamos que haga. En general no debemos usar el constructor copia cuando usemos punteros a clases base. Para solucionar este inconveniente se suele crear una función virtual "clonar" en la clase base que se superpondrá para cada clase derivada.

Por ejemplo:

#include <iostream>
#include <cstring>
using namespace std;
 
class Persona {
  public:
   Persona(char *n) { strcpy(nombre, n); }
   Persona(const Persona &p);
   virtual void VerNombre() { 
      cout << nombre << endl; 
   }
   virtual Persona* Clonar() { return new Persona(*this); }
  protected:
   char nombre[30];
};

Persona::Persona(const Persona &p) {
   strcpy(nombre, p.nombre);
   cout << "Per: constructor copia." << endl;
}

class Empleado : public Persona {
  public:
   Empleado(char *n) : Persona(n) {}
   Empleado(const Empleado &e);
   void VerNombre() { 
      cout << "Emp: " << nombre << endl; 
   }
   virtual Persona* Clonar() { return new Empleado(*this); }
};

Empleado::Empleado(const Empleado &e) : Persona(e) {
   cout << "Emp: constructor copia." << endl;
}

class Estudiante : public Persona {
  public:
   Estudiante(char *n) : Persona(n) {}
   Estudiante(const Estudiante &e);
   void VerNombre() { 
      cout << "Est: " << nombre << endl; 
   }
   virtual Persona* Clonar() { 
      return new Estudiante(*this); 
   }
};

Estudiante::Estudiante(const Estudiante &e) : Persona(e) {
   cout << "Est: constructor copia." << endl;
}

int main() {
   Persona *Pepito = new Estudiante("Jose");
   Persona *Carlos = new Empleado("Carlos");
   Persona *Gente[2];

   Carlos->VerNombre();
   Pepito->VerNombre();
   
   Gente[0] = Carlos->Clonar();
   Gente[0]->VerNombre();

   Gente[1] = Pepito->Clonar();
   Gente[1]->VerNombre();
   
   delete Pepito;
   delete Carlos;
   delete Gente[0];
   delete Gente[1];
   
   cin.get();
   return 0;
}

Hemos definido el constructor copia para que se pueda ver cuando es invocado. La salida es ésta:

Emp: Carlos
Est: Jose
Per: constructor copia.
Emp: constructor copia.
Emp: Carlos
Per: constructor copia.
Est: constructor copia.
Est: Jose

Este método asegura que siempre se llama al constructor copia adecuado, ya que se hace desde una función virtual.

Si un constructor llama a una función virtual, ésta será siempre la de la clase base. Esto es debido a que el objeto de la clase derivada aún no ha sido creado.

Palabras reservadas usadas en este capítulo

virtual.