Capitulo 5 C++. Polimorfismo File - 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
APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
136
<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 ellom 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
UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
137
Suma 1
Suma 10
5.2.
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:
APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
138
Estudiante(char *n)
void VerNombre()
{
cout << "Est: " <<
}
};
void main() {
Persona *Pepito = new
Persona *Carlos = new
Carlos->VerNombre();
Pepito->VerNombre();
delete Pepito;
delete Carlos;
}
: Persona(n) {}
nombre << endl;
Estudiante("Jose");
Empleado("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 UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
139
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. 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 herencia‐ se 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: APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
140
Emp: Carlos Est: Jose 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 UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
141
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. ♦
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()
{
APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
142
Base base,*pbase;
Derivada1 primera;
Derivada2 segunda;
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 UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
143
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 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()
{
144
APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
cout<<"¿Marca?:";
cin>>marca;
cout<<"¿Modelo?:";
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-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
145
}
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 APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
146
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. 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>
UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
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();
147
APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
148
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:
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-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
149
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. APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
150
A menudo se mencionan las clases abstractas como tipos de datos abstractos, en inglés: Abstract Data Type, o resumido ADT. 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; }
UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
151
void ModificaNota(float no) { nota = no; }
protected:
float nota;
};
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: APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
152
•
Si el saldo es menor que 50000, se aplica el interés establecido previamente. •
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:
UPM-EUITI-2009. Miguel Hernando.
CAPÍTULO 6. PLANTILLAS.
153
C_CuentaJoven(double unSaldo=0.0, double unInteres=2.0,
double unLimite = 50.0E3) :C_Cuenta(unSaldo, unInteres)
{
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];
};
154
APUNTES DE INFORMÁTICA INDUSTRIAL. PROGRAMACIÓN C++.
UPM-EUITI-2009. Miguel Hernando.