0
Funciones virtuales
Llegamos ahora a los conceptos más sutiles de la programación orientada a objetos.
La virtualización de funciones y clases nos permite implementar una de las propiedades más potentes de POO: el polimorfismo.
Pero vayamos con calma...
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();
return 0;
} |
La salida de este programa es:
a = 10, b = 20
a = 10
Decimos que 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);
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 esa capacidad es posible 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.
Podemos usar un microscopio como martillo, (probablemente podremos clavar algunos clavos antes de que se rompa y deje de funcionar como tal). Pero mientras sea un martillo, no nos permitirá observar a través de él. Es decir, los métodos propios de objetos de la clase "microscopio" serán inaccesibles mientras usemos una referencia a "martillo" para manejarlo.
De todos modos, no te procupes por el microscopio, no creo que en general usemos jerarquías de clases en las que objetos valiosos y delicados se deriven de otros tan radicalmente diferentes y toscos.
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) { stry(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;
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) { stry(nombre, n); }
virtual void VerNombre() {
cout << nombre << endl;
}
protected:
char nombre[30];
}; |
Si 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".
Volvamos al ejemplo del microscopio usado como martillo. Supongamos que quien diseño el microscopio se ha dado cuenta de que a menudo se usan esos aparatos como martillos, y decide protegerlos, añadiendo una funcionalidad específica (y, por supuesto, virtual) que permite clavar clavos sin que el microscopio se deteriore.
Cada vez que alguien use un microscopio para clavar un clavo, se activará esa función, y el clavo quedará bien clavado, al mismo tiempo que el microscopio queda intacto.
Por muy bruto que sea el que use el microscopio, nunca podrá acceder a la función "Clavar" de la clase base "martillo", ya que es virtual, y por lo tanto el microscopio sigue protegido.
Pero vayamos más lejos. La función virtual en la clase derivada no tiene por qué hacer lo mismo que en la clase base. Así, nuestro diseñador, puede diseñar la función "clavar" de modo que de una descarga de alta tensión al que la maneje, o siendo más civilizado, que emita un mensaje de error. :)
Lástima que esto no sea posible en la vida real...
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(const char *n) { stry(nombre, n); }
virtual void VerNombre() {
cout << nombre << endl;
}
protected:
char nombre[30];
};
class Empleado : public Persona {
public:
Empleado(const char *n) : Persona(n) {}
void VerNombre() {
cout << "Emp: " << nombre << endl;
}
};
class Estudiante : public Persona {
public:
Estudiante(const 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();
return 0;
} |
Ejecutar este código en codepad.
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(const char *n) { stry(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) {
stry(nombre, p.nombre);
cout << "Per: constructor copia." << endl;
}
class Empleado : public Persona {
public:
Empleado(const 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(const 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];
return 0;
}
|
Ejecutar este código en codepad.
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.
| Nota: como puedes ver, C++ lleva algunos años de adelanto sobre la ingeniería genética, y ya ha resuelto el problema de clonar personas. :-). |
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.
Ir al Principio
Comentarios