Herencia y Polimorfismo en C++

Transcripción

1 Herencia y Polimorfismo en C++ Informática II Fundamentos de Programación 1 Herencia Concepto de "herencia" herencia": Una clase -clase derivada- puede definirse a partir de otra clase ya existente (clase base), de la que hereda sus variables y funciones miembro. La clase derivada puede añadir y/o redefinir nuevas variables y/o funciones miembro. La clase base suele ser más general que la clase derivada. Ésta añade nuevas determinaciones o especificaciones (nuevas variables y/o funciones miembro). A su vez, la clase derivada puede ser clase base de una nueva clase derivada, que hereda sus variables y funciones miembro. Se puede constituir una jerarquía de clases. Además de public y private,, C++ permite también definir miembros protected. Los miembros protected, al igual que los private, no son accesibles desde fuera de la clase. En una clase base, los miembros protected se diferencian de los private en que sí pueden ser accesibles para las clases derivadas de dicha clase base. Para la clase derivada,, la clase base se puede heredar como pública o como privada: La clase derivada no tiene acceso a los miembros private de la clase base. Sí tiene acceso a los miembros public y protected. Si la clase base se hereda como public, la clase derivada hereda los miembros public y protected de la clase base como miembros public y protected, respectivamente. Si la clase base se hereda como private, la clase derivada hereda todos los miembros de la clase base como private. 2

2 Ej. de herencia: clase "empleado" Supóngase que un departamento de una empresa utiliza tres tipos de empleados: subcontratado: cobra por horas. vendedor: cobra por horas, más una comisión de las ventas. encargado: cobra una cantidad fija por mes. y que se desea hacer una función llamada calcular_pago() que calcule lo que hay que pagar cada mes a cada empleado. Se puede pensar en una jerarquía de empleados de la forma indicada en la figura: Subcontratado Encargado Vendedor Los principios de esta jerarquía son los siguientes: Enc_ ventas Todos son empleados. Los vendedores cobran por horas como los subcontratados (de hecho son un tipo especial de subcontratados), pero tienen además una comisión, por lo que pueden ser considerados como una particularización de éstos. Los encargados sólo tienen en común con los demás el hecho de ser empleados. 3 Ej. de herencia (cont( Clase base empleado: class empleado private: char nombre[31]; empleado(); empleado(const char *nom); char *devolver_nombre(); float calcular_pago() return 0.0; Clase derivada subcontratado: Clase derivada vendedor: class subcontratado : public empleado class vendedor : public subcontratado private: private: float tarifa; float comision; float no_horas; float ventas_realizadas; vendedor(const char *nom); subcontratado(const char *nom); void fijar_comision(float com); void fijar_tarifa(float tar); void contar_ventas(float ventas); void contar_horas(float horas); float calcular_pago(); float calcular_pago(); Obsérvese la forma en que, en cada clase derivada, se define la forma en que se hereda la clase base como public o private. 4

3 Ej. de herencia (cont( Definición de la clase derivada encargado: class encargado : public empleado private: float sueldo_mensual; encargado(const char *nom); void fijar_sueldo(float sueldo); float calcular_pago(); Recuérdese que cada una de las clase derivadas hereda todos los miembros de la clase base correspondiente. La clase vendedor hereda los miembros de las clases subcontratado y empleado. La clase derivada no puede acceder directamente a las variables miembro privadas de la clase base: hay que utilizar las funciones públicas de la clase base. Una clase derivada puede redefinir (definir una función diferente con el mismo nombre) alguna de las funciones miembro de la clase base. La función de la clase base es accesible en la clase derivada por medio del operador (::). La función redefinida es utilizable directamente en la clase derivada. 5 Ej. de herencia (cont( Definición de la función calcular_pago() en cada una de las clases: float subcontratado::calcular_pago() return tarifa * no_horas; float vendedor::calcular_pago() return (subcontratado::calcular_pago() + comision * ventas_realizadas); float encargado::calcular_pago() return sueldo_mensual; No sería correcto utilizar las definiciones: float vendedor::calcular_pago() return (tarifa * no_horas + comision * ventas_realizadas); float vendedor::calcular_pago() return (calcular_pago() + comision * ventas_realizadas); pues vendedor::calcular_pago() no tiene acceso a las variables privadas de subcontratado. La función calcular_pago() de vendedor no debe llamarse a sí misma, sino a la de subcontratado. 6

4 Constructores de clases derivadas Un objeto de una clase derivada contiene todos los miembros de la clase base. El constructor de la clase derivada debe llamar al de la clase base. Cuando se define un constructor para una clase derivada, se debe especificar un inicializador base (llamada al constructor de la clase base). El inicializador base se especifica poniendo, a continuación de los argumentos del constructor, el carácter (:) y un constructor de la clase base seguido de una lista de argumentos entre paréntesis. Por ejemplo: // constructor para la clase subcontratado subcontratado::subcontratado(const char *nom) : empleado(nom) tarifa = 0.0; no_horas = 0.0; Al declarar un objeto de la clase derivada, se ejecuta primero el constructor de la clase base y luego el de la clase derivada. El inicializador base puede ser omitido si la clase base tiene un constructor por defecto. El constructor de una clase derivada debe disponer de valores para sus propias variables y para el constructor de la clase base. 7 Herencia múltiple. Clases base virtuales Una clase derivada puede heredar variables y funciones miembro de varias clases base. Por ejemplo, la clase encargado_ventas puede heredar los miembros de las clases encargado y vendedor. Se definiría en la forma: class encargado_ventas : public encargado, public vendedor... // definición de variables y funciones miembro Una clase base no puede figurar directamente más de una vez en la definición de la clase derivada. Sin embargo, indirectamente una clase puede ser clase base más de una vez de una clase derivada. Por ejemplo, la clase empleado es clase base por duplicado de la clase encargado_ventas. La clase encargado_ventas tiene por duplicado los miembros de la clase base empleado. Se puede utilizar el operador (::). Al llamar a la función devolver_nombre() dará error de ambigüedad, ya que no sabe cual de las dos utilizar (por encargado o por vendedor). Para evitar esto, la clase base empleado debe ser declarada clase base virtual. En las definiciones de las clases derivadas hay que hacer: class subcontratado : public virtual empleado... class encargado : public virtual empleado... El constructor de la clase base virtual (empleado) siempre se llama antes que los constructores de las clases base no virtuales (encargado o subcontratado), por lo tanto en hay que llamar primero al constructor de empleado: vendedor(..,..,..) : empleado(..), subcontratado(...) ; 8

5 Conversiones entre objetos de clases base y clases derivadas Es posible realizar conversiones o asignaciones entre un objeto de una clase derivada a un objeto de la clase base (se puede ir de lo más particular a lo más general, aunque se pueda perder información). Es posible hacer: un_empleado = un_encargado; un_subcontratado = un_vendedor; No son posibles las conversiones en sentido contrario (de lo más general a lo más particular, pues no se dispone de valores para todas las variables miembro de la clase derivada y habría variables que quedarían sin inicializar). De forma análoga, se puede convertir un puntero a una clase derivada en un puntero a la clase base. Un puntero a la clase base puede almacenar la dirección de un objeto de cualquiera de las clases derivadas de esa clase base. Se puede hacer referencia a un objeto de una clase derivada con un puntero a la clase base. Cuando se hace referencia a un objeto por medio de un puntero, el tipo de puntero determina la función miembro que se aplica a dicho objeto, en el caso de que dicha función esté definida en las clases base y derivada. 9 Punteros a la clase base para manejo de objetos de clases derivadas En una jerarquía de clases con funciones del mismo nombre definidas en todas las clases, el tipo de objeto determina la función que se aplica. por ejemplo, con nombres de objetos: vendedor1.calcular_pago(); operario3.calcular_pago(); y con punteros a objetos: encargado *pntr1; pntr1->calcular_pago(); A una función que espera un puntero a la clase base se le puede pasar un puntero a cualquiera de sus clases derivadas (por las leyes de conversión de punteros). De esta forma, una lista de objetos de distintas clases puede tratarse con la interface -con las funciones miembro- de la clase base. Este tratamiento es genérico, sin tener en cuenta las peculiaridades de las clases derivadas, pues si se utiliza un puntero a una clase base con un objeto de una clase derivada, se utiliza la función de la clase base. El tratamiento personalizado con punteros genéricos (a objetos de la clase base) se consigue por medio del polimorfismo. 10

6 Polimorfismo y funciones virtuales La palabra polimorfismo hace referencia a la capacidad de llamar a funciones miembro: con un único nombre y análoga pero diferente misión, que actúen sobre objetos distintos de una jerarquía de clases, que se llamen del modo preciso sin tener que especificar el tipo exacto de los objetos. Operario for (i=0; i<n_empleados; i++) pempleado[i]->calcular_pago(); Oficial Tecnico Directivo La función calcular_pago() debe actuar correctamente con cada objeto de las clases derivadas de la clase, sin tener que pasar el tipo de objeto. Esto se hace: con punteros genéricos a la clase base : *pempleado; cantidad = pempleado->calcular_pago(); declarando calcular_pago() como función virtual en la clase base. si la función no se declara como virtual se utiliza siempre la función de la clase base ::calcular_pago(). Si una clase no tiene definida una función, utiliza la heredada de la clase base. 11 Polimorfismo y funciones virtuales (cont( De ordinario, en C++ la llamada a una función determinada se establece en el momento de la compilación (vinculación estática o temprana). Con funciones virtuales esto no es posible, pues no se sabe en ese momento a qué tipo de objeto apuntará el puntero en el instante de la llamada. La función a llamar se determina en tiempo de ejecución (vinculación dinámica o tardía). Con funciones virtuales es posible que un usuario añada nuevas clases a una jerarquía de clases, sin modificar o recompilar el código original (por tanto, sin necesidad de conocer los ficheros fuentes). Las funciones virtuales son algo menos eficientes que las funciones normales: cada clase que utiliza funciones virtuales tiene un vector de punteros (uno por cada función virtual) llamado v-table. cada uno de estos punteros apunta a la función virtual que es apropiada para esa clase, en principio a la propia definición si existe. si una clase no tiene su propia definición de la función virtual, el puntero apunta a la función virtual de su clase base más próxima que tenga una definición propia. cada objeto contiene un puntero oculto a la v-table de su clase. Con el puntero al objeto se accede a la v-table de la clase y a través de ella se accede a la definición adecuada de la función virtual. Éste es el trabajo extra. 12

7 Funciones virtuales puras Una función virtual debe estar definida en la clase base de la jerarquía, aunque no se vaya a utilizar nunca: porque no existen objetos de esa clase, porque cada clase derivada tiene su propia definición de esa función. Una función virtual de la clase base que no se va a utilizar nunca no necesita ser definida: basta declararla como función virtual pura. Una función virtual pura se declara en la forma: virtual float calcular_pago() const = 0; // virtual pura En este caso: no hace falta definir el código de empleado::calcular_pago(). no se pueden definir objetos de la clase base empleado, pues las funciones virtuales puras no pueden ser llamadas. sí se pueden definir punteros a la clase empleado, pues a través de ellos pueden manejarse objetos de clases derivadas. Es necesario redefinir la función como const: float calcular_pago() const... Clases abstractas: A las clases que declaran funciones virtuales puras se les llama clases abstractas, pues no tienen objetos concretos de esa clase. Si una clase derivada no redefine una función virtual pura heredada, la clase derivada la hereda como función virtual pura y se convierte también en clase abstracta. 13 Func.. virtuales puras (cont( Es habitual utilizar jerarquías de clases en las que las clases superiores son clases abstractas, que definen funciones virtuales puras que las clases concretas derivadas redefinen del modo adecuado. El constructor de la clase base se llama antes que el constructor de la clase derivada. Los destructores se llaman en orden opuesto a los constructores: primero el de la clase derivada y luego el de la clase base. Problema que puede presentarse: con reserva dinámica de memoria, si delete se aplica a un puntero de la clase base, se llama al destructor de la clase base, aunque dicho puntero apunte a un objeto de una clase derivada (se debería llamar primero al destructor de la clase derivada). la solución es declarar el destructor de la clase base como virtual: virtual ~empleado(); esto hace que los destructores de las clases derivadas sean virtuales, aunque tengan nombres diferentes. así, si delete se aplica a un puntero de la clase base, el destructor adecuado se aplica según el objeto de que se trate. si se define una clase con funciones virtuales, conviene definir un destructor virtual aunque la clase no lo necesite (puede haber clases derivadas que lo necesiten) No hay constructores virtuales. empleado *emp1 = new encargado("carla",2500); delete emp1; Al eliminar el objeto con delete, sólo se ejecutará el destructor de la clase base, si éste no es declarado como virtual. 14

8 Ejemplo 1 // Fichero.h // ejemplo de funciones virtuales #include <iostream.h> class virtual void imprime_cargo() cout << "es un cargo no definido\n"; class Directivo : public void imprime_cargo() cout << "es un directivo\n"; class Operario : public void imprime_cargo() cout << "es un operario\n"; class Oficial : public Operario void imprime_cargo() cout << "es un oficial\n"; class Tecnico : public Operario void imprime_cargo() cout << "es un tecnico\n"; Operario Directivo Oficial Tecnico 15 Ejemplo 1 (cont( // Fichero dpto.cpp #include "empleado.h" #include <string.h> void main(void) Rafa; Directivo Mario; Operario Anton; Oficial Luis; Tecnico Pablo; // El tipo del objeto determina la función que se llama cout << "Primero con nombres de objetos:" << endl; cout << "Rafa "; Rafa.imprime_cargo(); cout << "Mario "; Mario.imprime_cargo(); cout << "Anton "; Anton.imprime_cargo(); cout << "Luis "; Luis.imprime_cargo(); cout << "Pablo "; Pablo.imprime_cargo(); *pe; cout << "\ny ahora con punteros:" << endl; pe = &Rafa; cout << "Rafa "; pe->imprime_cargo(); pe = &Mario; cout << "Mario "; // continúa a la dcha. Con funciones virtuales, el tipo de objeto apuntado por un puntero a clase base determina la función que es llamada Oficial Operario Tecnico Directivo // cont. pe->imprime_cargo(); pe = &Anton; cout << "Anton "; pe->imprime_cargo(); pe = &Luis; cout << "Luis "; pe->imprime_cargo(); pe = &Pablo; cout << "Pablo "; pe->imprime_cargo(); 16

9 // Fichero empleos.h #include <iostream.h> Ejemplo 2 class empleado protected : char nombre[25]; long salario; empleado(char*, long); virtual void display() cout << "Nada\n"; Operario Directivo class directivo : public empleado private: char titulo[25]; directivo(char*, long, char*); void display() Oficial Tecnico cout << " El directivo " << nombre << " gana " << salario << " y tiene el titulo de " << titulo << endl; class operario : public empleado protected: char puesto[25]; operario(char*, long, char*); void display() cout << " El operario " << nombre << " gana " << salario << " y ocupa un puesto de " << puesto << endl; 17 Ejemplo 2 ( class tecnico : public operario tecnico(char*, long, char*); void display() cout << " El tecnico " << nombre << " gana " << salario << " y ocupa un puesto de " << puesto << endl; Operario Directivo Oficial Tecnico class oficial : public operario oficial(char*, long, char*); void display() cout << " El oficial " << nombre << " gana " << salario << " y ocupa un puesto de " << puesto << endl; 18

10 Ejemplo 2 (cont( // Fichero Empleos.cpp // funciones miembro de clases Directivo y Operario #include "empleos.h" #include <iostream.h> #include <string.h> // definición de los constructores empleado::empleado(char* name = "", long sueldo = 0) : salario(sueldo) strcpy(nombre, name); Operario Directivo Oficial Tecnico directivo::directivo(char* name = "", long sueldo = 0, char* title = "") : empleado(name, sueldo) strcpy(titulo, title); operario::operario(char* name = "", long sueldo = 0, char* job = "") : empleado(name, sueldo) strcpy(puesto, job); tecnico::tecnico(char* name = "", long sueldo = 0, char* job ="") : operario(name, sueldo, job) ; oficial::oficial(char* name = "", long sueldo = 0, char* job ="") : operario(name, sueldo, job) ; 19 Ejemplo 2 (cont( // fichero empresa.cpp // utilización de la clase empleos #include <iostream.h> #include "empleos.h" void main(void) // punteros a objetos de distintas clases directivo *m; operario *j; oficial *k; tecnico *i; // creación de cuatro objetos de distintas clases m = new directivo("maria", , "Ingeniera"); j = new operario("juan", , "Soldador"); k = new oficial("koldo", , "Teniente"); i = new tecnico("ignacio", , "Ingeniero"); Operario Directivo Oficial Tecnico // vector de punteros a la clase base empleado *lista[8]; // se guardan direcciones de objetos de // distintas clases lista[0] = m; lista[1] = j; lista[2] = k; lista[3] = i; lista[4] = new directivo("pedro", , "Economista"); lista[5] = new operario("leire", 25000, "Becaria"); lista[6] = new oficial("jon", , "Entrenador"); lista[7] = new tecnico("mario", , "Electricista"); // Se tratan todos los objetos de las distintas clases de una forma unificada for (int ii=0; ii<8; ii++) lista[ii]->display(); cout << "Ya he terminado." << endl; 20