5. El Polimorfismo - ELAI-UPM

5.
El Polimorfismo
Con este capítulo se tendrán las herramientas básicas para el desarrollo de un buen
programa en C++. Aún quedaría el uso de plantillas, pero estas pueden ser sustituidas en
muchos casos por el polimorfismo, y desde luego son más difíciles de utilizar por un
programador novel que los mecanismos hasta ahora explicados.
Antes de adentrarse en el concepto de polimorfismo, su utilidad y su casuística, es
necesario aclarar algún concepto en lo que se refiere a la superposición y la sobrecarga:
5.1.
Superposición y sobrecarga
Tal y como se vió en el capítulo anterior 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:
Departamento de Electrónica Automática e Informática Industrial
PROGRAMACIÓN C++ Y COMUNICACIONES.
140
<objeto>.<clase_base>::<método>;
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.h>
class ClaseA
{
public:
void Incrementar() {
void Incrementar(int
};
class ClaseB : public
{
public:
void Incrementar() {
};
cout << "Suma 1" << endl; }
n) { cout << "Suma " << n << endl; }
ClaseA
cout << "Suma 2" << endl; }
int main()
{
ClaseB objeto;
objeto.Incrementar();
objeto.Incrementar(10); //¿Existe este método?
objeto.ClaseA::Incrementar();
objeto.ClaseA::Incrementar(10);
cin.get();
return 0;
}
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. Por ello la línea marcada dará un error de
compilación, puesto que no existe la función incrementar definida en la claseB que reciba
como argumento un tipo de datos al que 10 sea convertible.
Tras corregir el error eliminando esta línea, la salida será:
Suma 2
Suma 1
Suma 10
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
5.2.
141
Polimorfismo
Ha llegado el momento de introducir uno de los conceptos más importantes 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. Como se ha visto, C++ nos permite
acceder a objetos de una clase derivada usando un puntero a la clase base. En eso consiste o
se basa el polimorfismo. Hata ahora sólo podemos 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. Esto es debido a que el compilador decide en tiempo de compilación que
métodos y atributos están disponibles en función del contenedor.
Para ilustrarlo vamos a ver un ejemplo sobre una estructura de clases basado en la
clase "Persona" y dos clases derivadas "Empleado" y "Estudiante":
#include <iostream.h>
#include <string.h>
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()
PROGRAMACIÓN C++ Y COMUNICACIONES.
142
{
cout << "Est: " << nombre << endl;
}
};
void main() {
Persona *Pepito = new Estudiante("Jose");
Persona *Carlos = new Empleado("Carlos");
Carlos->VerNombre();
Pepito->VerNombre();
delete Pepito;
delete Carlos;
}
Por simplificar el código, se ha utilizado memoria estática en vez de dinámica.
Evidentemente este es un error funcional grave puesto que el usuario de la clase puede
provocar un fallo en la ejecución haciendo un uso correcto de los métodos de interfaz. En
cualquier caso, suponiendo que tenemos cuidado, la salida del programa, como es previsible
será la siguiente:
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. Esto es debido a que la
función que se ejecuta se resuelve en tiempo de EJECUCION atendiendo no al tipo de objeto
apuntado, sino al tipo del apuntador.
Por eso, si escribimos:
Estudiante *Pepito=new Estudiante(“Jose”);
Empleado *Carlos=new Empleado(“Carlos”);
Entonces si que se ejecutará el método VerNombre superpuesto.
Esto mismo sucede con las referencias. Las siguientes líneas de código son
totalmente válidas, siendo el efecto análogo al obtenido por medio de punteros:
Estudiante Jose(“Jose”);
Persona &pJose=Jose;
pJose.VerNombre();
Es decir, en este caso, atendiendo al recipiente y no a lo apuntado, se utilizará de
nuevo el método VerNombre de la clase Persona, a pesar de que realmente pJose es un alias
de un objeto de tipo Estudiante. Ya observamos que un objeto se comporta de distinta forma
en función de con que se lo referencie o apunte.
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
143
Sin embargo, parece interesante que cada objeto se comporte como debe
independientemente del recipiente, es decir, independientemente de con que se referencie o
apunte… esto nos lleva al concepto de polimorfismo de la mano de los denominados métodos
virtuales.
Métodos virtuales
Un método virtual es un método de una clase base que puede ser redefinido en cada
una de las clases derivadas de esta, y que una vez redefinido puede ser accedido por medio
de un puntero o una referencia a la clase base, resolviéndose entonces la llamada en función
del objeto referido en vez de en función de con qué se hace la referencia.
Que viene a significar que si en una clase base definimos un método como virtual, si
este método es superpuesto por una clase derivada, al invocarlo utilizando un puntero o una
referencia de la clase base, ¡se ejecutará el método de la clase derivada!.
Cuando una clase tiene algún método virtual –bien directamente, bien por herenciase dice que dicha clase es polimórfica.
Para declarar un método como virtual se utiliza la siguiente sintaxis:
virtual <tipo> <nombre_función>(<lista_parámetros>) [{}];
Como siempre, la mejor forma de entender los conceptos en programación es ver
ejemplos de código con su resultado.
Modifiquemos en el ejemplo anterior la declaración de la clase base "Persona",
haciendo que el método VerNombre sea virtual:
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. Observamos entonces que la salida es
diferente:
Emp: Carlos
Est: Jose
PROGRAMACIÓN C++ Y COMUNICACIONES.
144
Ahora, al llamar a Pepito->VerNombre() se invoca a la función VerNombre de la clase
Estudiante, y al llamar a Carlos->VerNombre() se invoca a la función de la clase Empleado, a
pesar de que tanto Pepito como Carlos son punteros a la clase Persona.
De igual forma ocurrirá si en vez de utilizar punteros, hacemos uso de referencias:
void main()
{
Estudiante Pepito("Jose");
Empleado Carlos("Carlos");
Persona &rPepito = Pepito; // Referencia como Persona
Persona &rCarlos = Carlos; // Referencia como Persona
rCarlos.VerNombre(); //cada objeto ejecuta su método
rPepito.VerNombre(); //en vez de utilizar el de Persona
}
Por tanto, la idea central del polimorfismo es la de poder llamar a funciones distintas
aunque tengan el mismo nombre, según la clase a la que pertenece el objeto al que se
aplican. Esto es imposible utilizando nombres de objetos: siempre se aplica la función
miembro de la clase correspondiente al nombre del objeto, y esto se decide en tiempo de
compilación.
Sin embargo, utilizando punteros puede conseguirse el objetivo buscado. Recuérdese
que un puntero a la clase base puede contener direcciones de objetos de cualquiera de las
clases derivadas.
Antes de ahondar y ver más ejemplos de métodos virtuales se van a establecer
algunas características del mecanismo de virtualidad:
♦
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.
♦
El nivel de acceso no afecta a la virtualidad de las funciones. Es decir, una
función virtual puede declararse como privada en las clases derivadas aun
siendo pública en la clase base, pudiendo por tanto ejecutarse ese método
privado desde fuera por medio de un puntero a la clase base.
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
145
♦
Una llamada a un método virtual se resuelve siempre en función del tipo del
objeto referenciado.
♦
Una llamada a un método normal se resuelve siempre en función del tipo de la
referencia o puntero utilizado.
♦
Una llamada a un método virtual especificando la clase, exige la utilización del
operador de resolución de ámbito ::, lo que suprime el mecanismo de ritualidad.
Evidentemente este mecanismo solo podrá utilizarse para el método de la
misma clase del contenedor o de clases base del mismo.
♦
Por su modo de funcionamiento interno (es decir, por el modo en que realmente
trabaja el ordenador) las funciones virtuales son un poco menos eficientes que
las funciones normales.
Vamos a ver algún ejemplo adicional que ayude a entender el polimorfismo y las
clases polimórficas.
#include <iostream.h>
class Base
{
public:
virtual void ident(){cout<<"Base"<<endl;}
};
class Derivada1:public Base
{
public:
void ident(){cout<<"Primera derivada"<<endl;}
};
class Derivada2:public Base
{
public:
void ident(){cout<<"Segunda derivada"<<endl;}
};
class Derivada3:public Base
{
public:
void ident(){cout<<"Tercera derivada"<<endl;}
};
void main()
{
Base base,*pbase;
Derivada1 primera;
Derivada2 segunda;
PROGRAMACIÓN C++ Y COMUNICACIONES.
146
Derivada3 tercera;
pbase=&base;
pbase->ident();
pbase=&primera;
pbase->ident();
pbase=&segunda;
pbase->ident();
pbase=&tercera;
pbase->ident();
}
Evidentemente, el resultado de ejecutar este código es el siguiente:
Base
Primera derivada
Segunda derivada
Tercera derivada
De nuevo, al ser el método virtual se ejecuta la función del objeto apuntado,
independientemente de que se apunte con un puntero de tipo Base.
Si escribiéramos lo siguiente en el cuerpo del main:
pbase=&base;
pbase->Base::ident();
pbase=&primera;
pbase->Base::ident();
pbase=&segunda;
pbase->Base::ident();
pbase=&tercera;
pbase->Base::ident();
Entonces el resultado de la ejecución sería el siguiente:
Base
Base
Base
Base
Ahora lo que haremos será poner la modificación de virtualidad en la clase
Derivada2, y lo quitamos de la clase Base. En este caso el resultado de la ejecución será de
nuevo cuatro veces Base. Esto es debido a que desde el punto de vista del puntero que
contenedor (de tipo Base) la función ya no es virtual y por tanto se decide en tiempo de
compilación como cualquier método normal. Para poder acceder al método definido por las
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
147
clases derivadas al menos será necesario que utilicemos un puntero de tipo Derivada2 para
aquellas clases que son polimórficas (en este caso sólo lo sería Derivada3).
Por último, si volvemos al programa original, y establecemos que el método ident es
privado en la clase Derivada2, se observa que no afecta para nada al funcionamiento de
nuestro programa.
El polimorfismo hace posible que un usuario pueda añadir nuevas clases a una
jerarquía sin modificar o recompilar el código original. Esto quiere decir que si desea añadir
una nueva clase derivada es suficiente con establecer la clase de la que deriva, definir sus
nuevas variables y funciones miembro, y compilar esta parte del código, ensamblándolo
después con lo que ya estaba compilado previamente.
El siguiente ejemplo es un poco más largo y complicado respecto de los anteriores,
pero es más elocuente ante las posibilidades que nos ofrece el polimorfismo:
#include <iostream.h>
class Vehiculo
{
public:
virtual void muestra(ostream &co){}
virtual void rellena(){}
friend ostream& operator <<(ostream &co,Vehiculo &ve)
{
ve.muestra(co);
return co;
}
};
class Coche:public Vehiculo
{
protected:
char marca[20];
char modelo[20];
public:
void muestra(ostream &co)
{
co<<"Coche marca "<<marca<<" modelo "<<modelo<<endl;
}
void rellena()
{
cout<<"¿Marca?:";
cin>>marca;
cout<<"¿Modelo?:";
PROGRAMACIÓN C++ Y COMUNICACIONES.
148
cin>>modelo;
cin.clear();
}
};
class Camion:public Coche
{
private:
int carga;
public:
void muestra(ostream &co)
{
co<<"Camion marca "<<marca<<" modelo "<<modelo<<endl;
co<<"\tCapacidad de carga: "<<carga<< "Kg."<<endl;
}
void rellena()
{
Coche::rellena();
cout<<"¿Carga máxima?:";
cin>>carga;
cin.clear();
}
};
void main()
{
Vehiculo *flota[4];
int seleccion=0;
for(int i=0;i<3;i++)
{
cout<<"Seleccione tipo del vehiculo "<<i<<":\n";
cout<<"(1-Camión, 2-Coche): ";
while((seleccion<1)||(seleccion>2))
cin>>seleccion;
switch(seleccion)
{
case 1: flota[i]=new Camion;break;
case 2: flota[i]=new Coche;break;
}
seleccion=0;
flota[i]->rellena();
}
cout<<"\n Estos son los vehiculos introducidos:\n";
for(i=0;i<3;i++)cout<<i<<":"<<*flota[i];
}
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
149
Un ejemplo de ejecución de este programa es el siguiente:
Seleccione tipo del vehiculo 0:
(1-Camión, 2-Coche): 1
¿Marca?:SCANIA
¿Modelo?:SuperTruck
¿Carga máxima?:22000
Seleccione tipo del vehiculo 1:
(1-Camión, 2-Coche): 2
¿Marca?:Seat
¿Modelo?:Ibiza
Seleccione tipo del vehiculo 2:
(1-Camión, 2-Coche): 2
¿Marca?:Renault
¿Modelo?:Twingo
Estos son los vehiculos introducidos:
0:Camion marca SCANIA modelo SuperTruck
Capacidad de carga: 22000Kg.
1:Coche marca Seat modelo Ibiza
2:Coche marca Renault modelo Twingo
Se observa entonces como es posible almacenar y tratar los objetos como iguales
atendiendo a que heredan de una misma clase base, y sin embargo, estos mismos objetos son
capaces de realizar acciones distintas o especializadas cuando se ejecutan sus métodos
virtuales. Esto es la potencia del polimorfismo, y tal vez gracias al mismo alguno comienze a
vislumbrar el porque se parecen tanto y a la vez son distintos los programas que se manejan
sobre Windows.
Implementación del mecanismo de virtualidad
A continuación se explica, sin entrar en gran detalle, el funcionamiento de las
funciones virtuales. Cada clase que utiliza funciones virtuales tiene un vector de punteros,
uno por cada función virtual, llamado v-table. Cada uno de los punteros contenidos en ese
vector apunta a la función virtual apropiada para esa clase, que será, habitualmente, la
función virtual definida en la propia clase. En el caso de que en esa clase no esté definida la
función virtual en cuestión, el puntero de v-table apuntará a la función virtual de su clase base
más próxima en la jerarquía, que tenga una definición propia de la función virtual. Esto quiere
decir que buscará primero en la propia clase, luego en la clase anterior en el orden jerárquico
y se irá subiendo en ese orden hasta dar con una clase que tenga definida la función buscada.
PROGRAMACIÓN C++ Y COMUNICACIONES.
150
Cada objeto creado de una clase que tenga una función virtual contiene un puntero
oculto a la v-table de su clase. Mediante ese puntero accede a su v-table correspondiente y a
través de esta tabla accede a la definición adecuada de la función virtual. Es este trabajo extra
el que hace que las funciones virtuales sean menos eficientes que las funciones normales.
5.3.
Virtualidad en destructores y constructores.
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. Si no posiblemente sería necesario definirlo.
Como norma general, el constructor de la clase base se llama antes que el
constructor de la clase derivada. Con los destructores, sin embargo, sucede al revés: el
destructor de la clase derivada se llama antes que el de la clase base.
Por esa razón, en el caso de que se borre, aplicando delete, un puntero a un objeto
de la clase base que apunte a un objeto de una clase derivada, se llamará al destructor de la
clase base, en vez de al destructor de la clase derivada, que sería lo adecuado. La solución a
este problema consiste en declarar como virtual el destructor de la clase base. Esto hace que
automáticamente los destructores de las clases derivadas sean también virtuales, a pesar de
tener nombres distintos. De este modo, al aplicar delete a un puntero de la clase base que
puede apuntar a un objeto de ese tipo o a cualquier objeto de una clase derivada, se aplica el
destructor adecuado en cada caso.
Este problema no se presenta con los constructores y por eso no existe ningún tipo
de constructor virtual o similar. Por eso los constructores no pueden ser virtuales. Esto puede
ser un problema en ciertas ocasiones. Por ejemplo, el constructor de 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:
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
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();
151
PROGRAMACIÓN C++ Y COMUNICACIONES.
152
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:
Est:
Per:
Emp:
Emp:
Per:
Est:
Est:
Carlos
Jose
constructor
constructor
Carlos
constructor
constructor
Jose
copia.
copia.
copia.
copia.
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 creada.
5.4.
Funciones virtuales puras y clases abstractas
Habitualmente las funciones virtuales de la clase base de la jerarquía no se utilizan
porque en la mayoría de los casos no se declaran objetos de esa clase, y/o porque todas las
clases derivadas tienen su propia definición de la función virtual. Sin embargo, incluso en el
caso de que la función virtual de la clase base no vaya a ser utilizada, debe declararse.
De todos modos, si la función no va a ser utilizada no es necesario definirla, y es
suficiente con declararla como función virtual pura. Una función virtual pura se declara así:
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
153
virtual <tipo> <nombre_función>(<lista_parámetros>) = 0;
La única utilidad de esta declaración es la de posibilitar la definición de funciones
virtuales en las clases derivadas. De alguna manera se puede decir que la definición de una
función como virtual pura hace necesaria la definición de esa función en las clases derivadas,
a la vez que imposibilita su utilización con objetos de la clase base.
Al definir una función como virtual pura hay que tener en cuenta que:
♦
No hace falta definir el código de esa función en la clase base.
♦
No se pueden definir objetos de la clase base, ya que no se puede llamar a las
funciones virtuales puras.
♦
Sin embargo, es posible definir punteros a la clase base, pues es a través de
ellos como será posible manejar objetos de las clases derivadas.
Se denomina clase abstracta a aquella que contiene una o más funciones virtuales
puras. El nombre proviene de que no puede existir ningún objeto de esa clase. Si una clase
derivada no redefine una función virtual pura, la clase derivada la hereda como función
virtual pura y se convierte también en clase abstracta. Por el contrario, aquellas clases
derivadas que redefinen todas las funciones virtuales puras de sus clases base reciben el
nombre de clases derivadas concretas, nomenclatura únicamente utilizada para diferenciarlas
de las antes mencionadas.
Aparentemente puede parecer que carece de sentido definir una clase de la que no
va a existir ningún objeto, pero se puede afirmar, sin miedo a equivocarse, que la abstracción
es una herramienta imprescindible para un correcto diseño de la Programación Orientada a
Objetos.
Habitualmente las clases superiores de muchas jerarquías de clases son clases
abstractas y las clases que heredan de ellas definen sus propias funciones virtuales,
convirtiéndose así en funciones concretas.
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.
PROGRAMACIÓN C++ Y COMUNICACIONES.
154
Como consecuencia de lo dicho se pueden resumir dos reglas a tener en cuenta
cuando se utilizan 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() = 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;
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
155
};
void Estudiante::Mostrar() {
cout << "Estudiante: " << nombre
<< ", Nota: " << nota << endl;
}
int main() {
Persona *Pepito = new Empleado("Jose", 1000); (1)
Persona *Pablito = new Estudiante("Pablo", 7.56);
char n[30];
Pepito->Mostrar();
Pablito->Mostrar();
cin.get();
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".
5.5.
Ejemplos
Como ejemplo se puede suponer que la cuenta_joven y la cuenta_empresarial ya
utilizadas y descritas anteriormente, con una forma distinta de abonar mensualmente el
interés al saldo.
•
En la cuenta_joven, no se abonará el interés pactado si el saldo es inferior a
un límite.
•
En la cuenta_empresarial se tienen tres cantidades límite, a las cuales se
aplican factores de corrección en el cálculo del interés. El cálculo de la
cantidad abonada debe realizarse de la siguiente forma:
•
Si el saldo es menor que 50000, se aplica el interés establecido previamente.
PROGRAMACIÓN C++ Y COMUNICACIONES.
156
•
Si el saldo está entre 50000 y 500.000, se aplica 1.1 veces el interés
establecido previamente.
•
Si el saldo es mayor a 500.000, se aplica 1.5 veces el interés establecido
previamente.
El código correspondiente quedaría de la siguiente forma:
class C_Cuenta {
// Variables miembro
private:
double Saldo; // Saldo Actual de la cuenta
double Interes; // Interés calculado hasta el momento, anual,
// en tanto por ciento %
public:
//Constructor
C_Cuenta(double unSaldo=0.0, double unInteres=4.0)
{
SetSaldo(unSaldo);
SetInteres(unInteres);
}
// Acciones Básicas
inline double GetSaldo()
{ return Saldo; }
inline double GetInteres()
{ return Interes; }
inline void SetSaldo(double unSaldo)
{ Saldo = unSaldo; }
inline void SetInteres(double unInteres)
{ Interes = unInteres; }
void Ingreso(double unaCantidad)
{ SetSaldo( GetSaldo() + unaCantidad ); }
virtual void AbonaInteresMensual()
{
SetSaldo( GetSaldo() * ( 1.0 + GetInteres() / 12.0 / 100.0) );
}
// etc...
};
class C_CuentaJoven : public C_Cuenta
{
public:
C_CuentaJoven(double unSaldo=0.0, double unInteres=2.0,
double unLimite = 50.0E3) :C_Cuenta(unSaldo, unInteres)
{
UPM-EUITI-2013. Miguel Hernando.
CAPÍTULO 9. INTRODUCCIÓN LOS SISTEMAS OPERATIVOS
157
Limite = unLimite;
}
virtual void AbonaInteresMensual()
{
if (GetSaldo() > Limite)
SetSaldo( GetSaldo() * (1.0 + GetInteres() / 12.0 / 100.0) );
else
SetSaldo( GetSaldo() );
}
private:
double Limite;
};
class C_CuentaEmpresarial : public C_Cuenta {
public:
C_CuentaEmpresarial(double unSaldo=0.0, double unInteres=4.0)
: C_Cuenta(unSaldo, unInteres)
{
CantMin[0] = 50.0e3;
CantMin[1] = 500.0e3;
}
virtual void AbonaInteresMensual()
{
SetSaldo( GetSaldo() * (1.0 + GetInteres() * CalculaFactor() /
12.0 / 100.0 ));
}
double CalculaFactor()
{
if (GetSaldo() < CantMin[0])
return 1.0;
else if (GetSaldo() < CantMin[1])
return 1.1;
else return 1.5;
}
private:
double CantMin[2];
};
158
UPM-EUITI-2013. Miguel Hernando.
PROGRAMACIÓN C++ Y COMUNICACIONES.