Tema 6: Programación Orientada a Objetos en C++ Programación Orientada a Objetos Curso 2013/2014

Transcripción

1 Tema 6: Programación Orientada a Objetos en C++ Programación Orientada a Objetos Curso 2013/2014

2 Contenido (1/3) Introducción. Definición de clases. Visibilidad y clases amigas. Espacios de nombres. Tipos del lenguaje. Constructores y destructores. Semántica de los objetos. Semántica de los operadores de asignación e igualdad. Operadores. Redefinición. Instancia actual. Métodos y mensajes. Paso de parámetros. Función main. Curso 2013/2014 Programación Orientada a Objetos 2

3 Contenido (2/3) Herencia en C++ Diferencias entre herencia C++ y Java. Tipos de herencia: pública y privada. Herencia y constructores. Redefinición y métodos virtuales. Polimorfismo y ligadura (dinámica y estática). Conversión de tipos. Clases abstractas. Herencia múltiple. Curso 2013/2014 Programación Orientada a Objetos 3

4 Contenido (3/3) Genericidad en C++ Templates Corrección y Robustez en C++ Excepciones Asertos Curso 2013/2014 Programación Orientada a Objetos 4

5 Introducción Creado por Bjarne Stroustrup en los 80. Diseñado como una extensión de C que incluye características orientadas a objetos. Es un lenguaje híbrido. Ha sido inspiración de lenguajes de programación posteriores como Java y C#. A finales de los 90 fue estandarizado: ISO C++ Las librerías del lenguaje son escasas. La librería más notable es STL (Standard Template Library). Actualmente, sigue siendo un lenguaje de programación importante en algunos dominios. Curso 2013/2014 Programación Orientada a Objetos 5

6 Clases Los elementos que definen una clase son: Atributos, Métodos y Constructores. A diferencia de Java: Se separa: Definición de una clase (fichero cabecera.h) Implementación (fichero código fuente.cpp). No es obligatorio que los ficheros fuente correspondan con las clases. Un fichero puede implementar varias clases. Para poder utilizar o implementar una clase hay que importar su cabecera: #include Cuenta.h Curso 2013/2014 Programación Orientada a Objetos 6

7 Clase Cuenta - Especificación Cuenta.h Definición de la clase cuenta Banco.cpp Cuenta.cpp #include Cuenta.h utiliza Cuenta #include Cuenta.h implementa Cuenta Curso 2013/2014 Programación Orientada a Objetos 7

8 Cuenta.h (1/2) #include Persona.h class Cuenta { public: void reintegro(double cantidad); void ingreso(double cantidad); double getsaldo() const; Persona* gettitular() const; double* getultimasoperaciones(int n) const; static int getnumeroctas(); Curso 2013/2014 Programación Orientada a Objetos 8

9 Cuenta.h (2/2) private: const static int MAX_OPERACIONES = 20; const static double SALDO_MINIMO = 100; Persona* const titular; double saldo; int codigo; static int ultimocodigo; double* ultimasoperaciones; bool puedosacar(double cantidad); }; Curso 2013/2014 Programación Orientada a Objetos 9

10 Cuenta.cpp int Cuenta::ultimoCodigo = 0; void Cuenta::reintegro(double cantidad){ if (puedosacar(cantidad)) { saldo = saldo - cantidad; } } void Cuenta::ingreso(double cantidad){ saldo = saldo + cantidad; } bool Cuenta::puedoSacar(double cantidad){ return (saldo >= cantidad); } Curso 2013/2014 Programación Orientada a Objetos 10

11 Clases Los miembros de una clase pueden ser de instancia (por defecto) o de clase, utilizando el modificador static ( = Java). Las constantes se declaran const static. Método de consulta que no va a modificar el estado se marca utilizando también el modificador const. Ejemplo: double getsaldo() const; En la implementación, los nombres de los miembros son calificados con la clase: Ejemplo: Cuenta::ingreso Curso 2013/2014 Programación Orientada a Objetos 11

12 Modificador const en los atributos El modificador const se utiliza para proteger los atributos, el estado de los objetos o ambos. Persona* const titular; const protege el atributo. titular es un atributo de sólo lectura (= final de Java) const Persona* titular; const protege el objeto apuntado por el atributo. El objeto Persona no puede cambiar de estado. const Persona* const titular; Se protege tanto el atributo como el objeto. Curso 2013/2014 Programación Orientada a Objetos 12

13 Modificador const en los atributos Persona* const titular; codigo titular saldo ultimasoperaciones Pepito Curso 2013/2014 Programación Orientada a Objetos 13

14 Modificador const en los atributos const Persona* titular; codigo titular saldo ultimasoperaciones Pepito Curso 2013/2014 Programación Orientada a Objetos 14

15 Modificador const en los atributos const Persona* const titular; codigo titular saldo ultimasoperaciones Pepito Curso 2013/2014 Programación Orientada a Objetos 15

16 Visibilidad de las declaraciones El nivel de visibilidad se especifica para un grupo de miembros (declaraciones): public: visible para todo el código. private: visible sólo para la clase. Clases amigas: En C++ no se existe el concepto de paquete. En la declaración de una clase podemos indicar el nombre de otras clases con acceso total a la clase. El privilegio de amistad de una clase no es transitivo ni hereditario. Curso 2013/2014 Programación Orientada a Objetos 16

17 Clases amigas class NodoArbol { friend class Arbol; private: int valor; NodoArbol decha; NodoArbol izda; }; class Arbol{ private: NodoArbol *raiz;... raiz->valor = 50;... }; Curso 2013/2014 Programación Orientada a Objetos 17

18 Espacios de nombres Un espacio de nombres (namespace) es un mecanismo para agrupar un conjunto de elementos (clases, enumerados, funciones, etc.) relacionados. Evita la colisión de los nombres de identificadores. El orden de declaración de elementos es relevante. Puede estar definido en varios ficheros. Es un concepto diferente a los paquetes de Java: No hay relación con el sistema de ficheros. No proporcionan privilegio de visibilidad. Curso 2013/2014 Programación Orientada a Objetos 18

19 Espacios de nombres Para utilizar un elemento definido en un espacio de nombres (opciones): Se utiliza el nombre calificado del elemento: gestioncuentas::cuenta Se declara el uso del espacio de nombres: using namespace gestioncuentas; No existen elementos privados en un espacio de nombres. Curso 2013/2014 Programación Orientada a Objetos 19

20 Espacios de nombres En Cuenta.h En Banco.h namespace gestioncuentas{ class Cuenta { }; } namespace gestioncuentas{ class Banco { }; } Curso 2013/2014 Programación Orientada a Objetos 20

21 Tipos del lenguaje Tipos de datos primitivos: byte, short, int, long,float, double,char, bool, etc. Enumerados: enum Estado {OPERATIVA, INMOVILIZADA, NUM_ROJOS}; Objetos. Punteros: Cuenta* es el tipo puntero a Cuenta Una variable de tipo Cuenta* puede contener la dirección de un objeto de tipo Cuenta. Un puntero a un objeto es un concepto similar a una referencia Java. Curso 2013/2014 Programación Orientada a Objetos 21

22 Arrays En la declaración de un array se indica su tamaño ( = C): int array[10]; Si el tipo es una clase, es necesario que la clase tenga un constructor sin parámetros: Posicion posiciones[4]; La declaración y uso de un array al estilo Java sería: Cuenta** cuentas = new Cuenta*[10]; Importante: los punteros del array no están inicializados. No se controla el acceso incorrecto al array. Curso 2013/2014 Programación Orientada a Objetos 22

23 Enumerados Es un tipo que puede almacenar un conjunto de valores. El enumerado define un conjunto de constantes de tipo entero. Por defecto los valores se asignan de forma creciente desde 0. El tipo de cada uno de los elementos es el del enumerado. Curso 2013/2014 Programación Orientada a Objetos 23

24 Enumerados Definición namespace banco{ enum EstadoCuenta{ OPERATIVA, INMOVILIZADA, NUM_ROJOS //OPERATIVA == 0, INMOVILIZADA == 1, NUM_ROJOS == 2 }; } class Cuenta { private: EstadoCuenta estado; }; Curso 2013/2014 Programación Orientada a Objetos 24

25 Enumerados Uso En Cuenta.cpp #include "Cuenta.h" using namespace banco; void Cuenta::reintegro(double cantidad){ } if (estado!=inmovilizada && puedosacar(cantidad)){ } saldo = saldo - cantidad; Para referenciar un valor del enumerado no tiene que ir precedido por el nombre del enumerado. Curso 2013/2014 Programación Orientada a Objetos 25

26 Constructores No se puede asignar un valor inicial a los atributos en el momento de la declaración a menos que sean const y static (constantes). Por tanto, no podemos asegurar que los atributos tengan un valor inicial. Es necesario definir constructores. Curso 2013/2014 Programación Orientada a Objetos 26

27 Constructores Método especial con el mismo nombre que la clase y sin valor de retorno ( = Java). Está permitida la sobrecarga (= Java). Si no existe ningún constructor en la clase, el compilador proporciona el constructor por defecto (= Java). Los atributos const se tienen que inicializar en línea. class Cuenta { public: Cuenta (Persona *titular); Cuenta (Persona *titular, double saldoinicial); }; Curso 2013/2014 Programación Orientada a Objetos 27

28 Constructores - Clase Cuenta Cuenta::Cuenta (Persona *persona, double saldoinicial) :titular(persona) { } codigo = ++ultimocodigo; saldo = saldoinicial; ultimasoperaciones = new double[cuenta::max_operaciones]; numoperaciones = 0; estado = OPERATIVA; Inicialización en línea Cuenta::Cuenta (Persona *persona) :titular(persona) { } Curso 2013/2014 Programación Orientada a Objetos 28

29 Constructores A diferencia de Java, no se utiliza la palabra clave this para la reutilización de constructores. Soluciones: Utilizar un método privado que sea invocado desde los constructores. Utilizar argumentos por defecto para los constructores. Curso 2013/2014 Programación Orientada a Objetos 29

30 Reutilización de constructores Cuenta::Cuenta (Persona *persona): titular(persona) { inicializa(cuenta::saldo_minimo); } Cuenta::Cuenta (Persona *persona, double saldoinicial) :titular(persona) { inicializa(saldoinicial); } Invoca método privado void Cuenta::inicializa(double saldoinicial) { codigo = ++ultimocodigo; saldo = saldoinicial; ultimasoperaciones = new double[cuenta::max_operaciones]; estado = OPERATIVA; } Curso 2013/2014 Programación Orientada a Objetos 30

31 Reutilización de constructores En cualquier función, método o constructor podemos declarar argumentos con valores por defecto. Los argumentos por defecto deben aparecer juntos al final de la lista de argumentos. Los valores por defecto de los argumentos se indican en la declaración de la función (fichero.h) Ejemplo: Cuenta Definimos un único constructor. Para el argumento saldoinicial establecemos un valor por defecto. Curso 2013/2014 Programación Orientada a Objetos 31

32 Reutilización de constructores Fichero cabecera: class Cuenta { public: Cuenta (Persona *titular, double saldoinicial = SALDO_MINIMO); }; Las siguientes creaciones son válidas utilizando el constructor anterior: Cuenta(titular); Toma como valor del saldo el valor por defecto (100) Cuenta (titular, 200); El parámetro establece el valor del saldo a 200 Curso 2013/2014 Programación Orientada a Objetos 32

33 Destructores A diferencia de Java, no existe un mecanismo automático de liberación de memoria dinámica. Hay que definir destructores de objetos. Un destructor es un método sin argumentos con el mismo nombre de la clase, precedido por ~. Se invoca automáticamente cada vez que se libera la memoria del objeto. Libera memoria y recursos adquiridos por el objeto: El uso habitual es liberar la memoria adquirida en el constructor. Curso 2013/2014 Programación Orientada a Objetos 33

34 Destructor Clase Cuenta Cuenta.h: class Cuenta { public: Cuenta (Persona *titular, double saldoinicial= SALDO_MINIMO); ~Cuenta(); }; Cuenta.cpp: Cuenta::~Cuenta(){ delete[] ultimasoperaciones; } Curso 2013/2014 Programación Orientada a Objetos 34

35 Semántica de los objetos Los objetos pueden declararse de dos modos: Por referencia: se declara un puntero a un objeto. Los objetos se crean con el operador new (= Java). Cuenta* cuenta; Por valor: la declaración del objeto reserva la memoria y lo inicializa (llama a un constructor). Cuenta cuenta(persona); Curso 2013/2014 Programación Orientada a Objetos 35

36 Semántica de los objetos Semántica referencia: Cuenta* cuenta; cuenta = new Cuenta(persona, 1000); El valor null de Java está definido como una constante en C++: NULL. El objeto se destruye con el operador delete: delete cuenta; Semántica valor: Cuenta cuenta(persona, 1000); En la declaración de la variable también se construye el objeto. Los objetos por valor NO se liberan con el operador delete. Curso 2013/2014 Programación Orientada a Objetos 36

37 Arrays y semántica de objetos Array Semántica valor Semántica valor Semántica referencia Semántica referencia Contenido del array Semántica valor Semántica referencia Semántica valor Semántica referencia Declaración/Creación del array Posicion tabla[3]; Posicion* tabla[3]; Posicion* tabla; tabla = new Posicion[3]; Posicion** tabla; tabla = new Posicion*[3]; Curso 2013/2014 Programación Orientada a Objetos 37

38 Objetos embebidos La semántica valor permite definir objetos embebidos dentro de otros objetos. codigo titular saldo autorizado ultimasoperaciones María Pepito Curso 2013/2014 Programación Orientada a Objetos 38

39 Objetos embebidos La declaración del atributo autorizado es un objeto embebido. class Cuenta { public: private: int codigo; Persona* const titular; double saldo; Persona autorizado; }; Curso 2013/2014 Programación Orientada a Objetos 39

40 Objetos embebidos La declaración de objetos embebidos sólo es posible si se cumple una de las siguiente condiciones: La clase del objeto embebido tiene un constructor sin argumentos. Se realiza una inicialización en línea en el constructor. Curso 2013/2014 Programación Orientada a Objetos 40

41 Objetos embebidos El objeto se inicializa en línea: Cuenta::Cuenta (Persona* persona, { } string nombreaut, string dniaut, double saldoinicial):autorizado(nombreaut, dniaut), codigo = ++ultimocodigo; titular(persona) La inicialización en línea es obligatoria si la clase del objeto embebido no tiene constructor sin argumentos. Curso 2013/2014 Programación Orientada a Objetos 41

42 Operador de asignación (=) Cuenta* cta1; Cuenta* cta2; Cuenta cta3; Cuenta cta4; Semántica: cta1 = cta2; copia de punteros (= Java) cta3 = cta4; copia campo a campo de los valores de cta4 en cta3 (copia superficial) Curso 2013/2014 Programación Orientada a Objetos 42

43 Asignación con semántica valor codigo titular saldo codigo titular saldo cuenta cuenta2 Pepito Juanito cuenta1 = cuenta2 Curso 2013/2014 Programación Orientada a Objetos 43

44 Asignación con semántica valor codigo titular saldo cuenta1.codigo = cuenta2.codigo Pepito codigo titular saldo cuenta cuenta2 cuenta1.titular = cuenta2.titular Juanito cuenta1 = cuenta2 Curso 2013/2014 Programación Orientada a Objetos 44

45 Operador de asignación y atributos const Problema: Cuenta cuenta1(persona1); Cuenta cuenta2(persona2); cuenta1 = cuenta2; En la clase Cuenta el atributo titular se ha declarado de sólo lectura (const). Al hacer una asignación entre objetos cuenta con semántica valor, por defecto, se hace una copia superficial de los atributos. Se intentaría hacer una copia de los titulares. Esto es, cambiar el valor del atributo titular de cuenta1 por el valor del atributo titular de cuenta2. La asignación da un error en tiempo de compilación. Curso 2013/2014 Programación Orientada a Objetos 45

46 Asignación con semántica valor y atributo const cuenta1 = cuenta2 codigo titular saldo codigo titular saldo cuenta cuenta2 Pepito ERROR!! cuenta1.titular = cuenta2.titular cuenta1.titular está protegido. Juanito Curso 2013/2014 Programación Orientada a Objetos 46

47 Constructor de copia Si está definido, se utiliza en la inicialización de un objeto con semántica valor: Cuenta cuenta2 = cuenta1; También se aplica en el paso de parámetros (se estudia más adelante). Ejemplo: Cuenta::Cuenta(const Cuenta& orig): titular(orig.titular){ } this->saldo = orig.saldo; Curso 2013/2014 Programación Orientada a Objetos 47

48 Operador de igualdad (==) Cuenta* cta1; Cuenta* cta2; Cuenta cta3; Cuenta cta4; Semántica: cta1 == cta2; igualdad de punteros, identidad (= Java) cta3 == cta4; Por defecto no está definido Curso 2013/2014 Programación Orientada a Objetos 48

49 Redefinir copia e igualdad de objetos El operador de asignación entre objetos con semántica valor realiza una copia superficial. Cómo se puede definir una copia diferente? La igualdad entre objetos con semántica valor no está definida. Cómo se puede definir la igualdad entre objetos? SOLUCIÓN: Redefinir los operadores = y == Para objetos con semántica valor Curso 2013/2014 Programación Orientada a Objetos 49

50 Operadores Gran parte de los operadores del lenguaje (=, ==,!=, <, <=, etc.) pueden ser redefinidos para su aplicación sobre objetos. Ejemplo: utilizar + para sumar matrices. Se definen utilizando como nombre de método operator seguido del operador. Ejemplos: operator= operator== operator<< Un operador puede definirse dentro o fuera de una clase. En algunos casos (por ejemplo, <<) deben ser externos. Curso 2013/2014 Programación Orientada a Objetos 50

51 Operador = en Cuenta Cuenta& Cuenta::operator=(const Cuenta& otracuenta){ if (this!= &otracuenta){ // son el mismo objeto? codigo = ++ultimocodigo; titular = otracuenta.titular; saldo = otracuenta.saldo; delete [] ultimasoperaciones; ultimasoperaciones = new double[cuenta::max_operaciones]; } return (*this); } Curso 2013/2014 Programación Orientada a Objetos 51

52 Operador == en Cuenta bool Cuenta::operator==(const Cuenta& otracuenta){ } return (codigo == otracuenta.codigo); bool Cuenta::operator!=(const Cuenta& otracta){ } return!(*this == otracta); Implementar!= a partir de == para evitar inconsistencias. Curso 2013/2014 Programación Orientada a Objetos 52

53 Operador externo << en Cuenta ostream& banco::operator<<(ostream& salida, const Cuenta& cuenta){ salida <<"Cuenta [codigo = "<<cuenta.getcodigo() <<", titular = "<<(cuenta.gettitular())->getnombre() <<", estado = "<<cuenta.getestado() <<", saldo = "<<cuenta.getsaldo() <<"]"<<endl; return salida; } ostream& banco::operator<<(ostream& salida, const Cuenta* cta){ salida<<(*cta); return salida; } Curso 2013/2014 Programación Orientada a Objetos 53

54 Operador externo << para el Enumerado ostream& banco::operator <<(ostream& salida, const EstadoCuenta& estado){ switch(estado){ case OPERATIVA: salida<<"operativa"; return salida; case INMOVILIZADA: salida<<"inmovilizada"; return salida; case NUM_ROJOS: salida<<"numeros ROJOS"; return salida; } return salida; } Curso 2013/2014 Programación Orientada a Objetos 54

55 Declaración de operadores namespace banco{ class Cuenta { public: bool operator==(const Cuenta& otracta); bool operator!=(const Cuenta& otracta); Cuenta& operator=(const Cuenta& otracta); }; //Externos ostream& operator<<(ostream& salida, const EstadoCuenta& estado); ostream& operator<<(ostream& salida, const Cuenta& cuenta); ostream& operator<<(ostream& salida, const Cuenta* cuenta); } Curso 2013/2014 Programación Orientada a Objetos 55

56 Instancia actual Al igual que en Java, se define la palabra reservada this que es un puntero a la instancia actual. void Cuenta::ingreso(double cantidad) { this->saldo = this->saldo + cantidad; } Curso 2013/2014 Programación Orientada a Objetos 56

57 Métodos y mensajes Al igual que en Java, los métodos definidos en una clase son los mensajes aplicables sobre los objetos de la clase. Está permitida la sobrecarga de métodos declarados dentro de la misma clase. La aplicación de un mensaje varía según si el objeto es manejado por valor o referencia:. (notación punto) el receptor es un objeto por valor -> (notación flecha) el receptor es un puntero a objeto Si no se indica el objeto receptor, la llamada se realiza sobre la instancia actual. Curso 2013/2014 Programación Orientada a Objetos 57

58 Mensajes Cuenta objcta; Cuenta* ptrocta; Notación punto para objetos objcta.reintegro(1000); (*ptrcta).reintegro(1000); Notación flecha para punteros: ptrocta->reintegro(1000); (&objcta)->reintegro(1000); Curso 2013/2014 Programación Orientada a Objetos 58

59 Paso de parámetros void Cuenta::reintegro(double cantidad) { } double v = ; cuenta.reintegro(6000.0); cuenta.reintegro(v); Parámetro formal Parámetro real Paso por valor el parámetro formal es una copia del parámetro real ( = Java ). Paso por referencia el parámetro formal referencia al parámetro real. Además, hay que tener en cuenta que los objetos pueden tener semántica valor o semántica referencia. Curso 2013/2014 Programación Orientada a Objetos 59

60 Paso por valor con semántica referencia void Banco::transferencia1(Cuenta* emisor, Cuenta* receptor, double cantidad){ } emisor->reintegro(cantidad); receptor->ingreso(cantidad); emisor = new Cuenta(emisor->getTitular()); banco.transferencia(cuenta1, cuenta2, ); Paso por valor del puntero ( = Java). El estado de cuenta1 y cuenta2 cambia. El nuevo puntero de emisor no afecta al parámetro real (cuenta1) que se pasa como parámetro (es una copia). Curso 2013/2014 Programación Orientada a Objetos 60

61 Paso por valor con semántica valor void Banco::transferencia2(Cuenta emisor, Cuenta receptor, double cantidad){ emisor.reintegro(cantidad); receptor.ingreso(cantidad); } banco.transferencia(cuenta1, cuenta2, ); El estado de los parámetros reales cuenta1 y cuenta2 no cambia. emisor y receptor son una copia de los objetos con semántica valor que se pasan como parámetro. En el paso de parámetros se utiliza el constructor de copia si está definido. Si no, se realiza copia superficial. Curso 2013/2014 Programación Orientada a Objetos 61

62 Paso por referencia con semántica referencia void Banco::transferencia3(Cuenta* emisor, Cuenta*& receptor, double cantidad){ } emisor->reintegro(cantidad); receptor->ingreso(cantidad); receptor = new Cuenta(receptor->getTitular()); banco.transferencia(cuenta1, cuenta2, ); Paso por referencia del puntero. El cambio del puntero en el parámetro formal (receptor) afecta al parámetro real (cuenta2). Curso 2013/2014 Programación Orientada a Objetos 62

63 Paso por referencia con semántica valor void Banco::transferencia4(Cuenta* emisor, Cuenta& receptor, double cantidad){ } emisor->reintegro(cantidad); receptor.ingreso(cantidad); Cuenta otracuenta; receptor = otracuenta; banco.transferencia(cuenta1, cuenta2, ); Paso por referencia del objeto con semántica valor cuenta2. El cambio en receptor (estado y parámetro) afecta a cuenta2. Curso 2013/2014 Programación Orientada a Objetos 63

64 Parámetros const Pasar un objeto grande por referencia es más eficiente que pasarlo por valor, pero se corre el riesgo de modificar el objeto. Solución: utilizar la palabra reservada const para indicar que no se puede modificar el estado del objeto. Curso 2013/2014 Programación Orientada a Objetos 64

65 Parámetros const void transferencia(cuenta* emisor, const Cuenta& receptor, double cantidad); Se protege el estado del objeto cuenta receptor. Opción recomendable cuando se quiere pasar un objeto con semántica valor y se quiere proteger la variable pasada por referencia. Curso 2013/2014 Programación Orientada a Objetos 65

66 Paso de parámetros - recomendaciones Paso de un objeto con semántica referencia (puntero): Cuenta* receptor: interesa cuando queremos que el método modifique el estado del objeto. const Cuenta* receptor: cuando el método SÓLO consulta el estado del objeto. Paso de un objeto con semántica valor: Cuenta receptor: queremos proporcionar una copia del objeto al método. const Cuenta& receptor: alternativa eficiente, que evita la copia y protege el estado. En general, se utiliza el paso por referencia (&) cuando queremos que el método modifique la variable empleada en la llamada. Curso 2013/2014 Programación Orientada a Objetos 66

67 Función main Sólo puede haber un punto de entrada en el espacio raíz. Sólo exige declarar una función con nombre main, y valor de retorno int. Opcionalmente puede tener los argumentos del programa. Ejemplos: int main(int argc, char** argv) int main() Curso 2013/2014 Programación Orientada a Objetos 67

68 Herencia La herencia en C++ es diferente a Java en varios aspectos: Herencia múltiple: una clase puede heredar de varias clases. Herencia privada: heredar de una clase sólo el código, pero no el tipo. Ligadura de métodos: los métodos pueden ser invocados por ligadura dinámica y estática. No existe el tipo Object raíz de la jerarquía de clases. Curso 2013/2014 Programación Orientada a Objetos 68

69 Clase Deposito class Deposito { private: Persona* titular; double capital; int plazodias; double tipointeres; public: Deposito( ); double liquidar(); double getintereses(); double getcapital(); int getplazodias(); double gettipointeres(); Persona* gettitular(); }; Curso 2013/2014 Programación Orientada a Objetos 69

70 Clase Deposito Estructurado class DepositoEstructurado : public Deposito { private: double tipointeresvariable; double capitalvariable; public: DepositoEstructurado(Persona titular,, double capitalvariable); double getinteresesvariable(); void settipointeresvariable(double interesvariable); double gettipointeresvariable(); double getcapitalvariable(); }; Curso 2013/2014 Programación Orientada a Objetos 70

71 Tipos de herencia Herencia pública (= Java): class B: public A La clase hereda los atributos y métodos de la clase padre. La visibilidad de las declaraciones heredadas puede aumentar y disminuir al declararlas en el fichero cabecera. Herencia privada: class B: private A Las declaraciones visibles para la clase hija cambian su visibilidad a privada. Se puede aumentar la visibilidad en el fichero cabecera. No se hereda el tipo: los objetos de la clase no pueden ser asignados a variables polimórficas cuyo tipo estático sea la clase padre. Curso 2013/2014 Programación Orientada a Objetos 71

72 Niveles de visibilidad Al igual que en Java, los niveles de visibilidad son incrementales public public todo el código protected protected clase + subclases private private clase Curso 2013/2014 Programación Orientada a Objetos 72

73 Herencia y constructores Los constructores no se heredan ( = Java ) El constructor de la clase hija tiene que invocar al de la clase padre. DepositoEstructurado::DepositoEstructurado(Persona titular, double capital, int plazodias, } double tipointeres, double tipointeresvariable, double capitalvariable): Deposito(titular, capital, plazodias, tipointeres) { this.tipointeresvariable = tipointeresvariable; this.capitalvariable = capitalvariable; Curso 2013/2014 Programación Orientada a Objetos 73

74 Redefinición de métodos Cualquier método que sea visible puede redefinirse en una subclase. Método virtual: método que al redefinirse en las subclases puede resolverse por ligadura dinámica (modificador virtual). Para redefinir un método (virtual o normal): Hay que declararlo en la subclase (fichero cabecera) con la misma signatura e implementarlo en el fichero de implementación. No existe palabra clave super para llamar a la versión del padre, hay que especificar el nombre de la clase NombreClase::NombreMetodo Ejemplo: Deposito::getCapital() Curso 2013/2014 Programación Orientada a Objetos 74

75 Redefinición de métodos class Deposito { private: Persona* titular; double capital; int plazodias; double tipointeres; public: Deposito( ); double liquidar(); virtual double getintereses(); virtual double getcapital(); int getplazodias(); double gettipointeres(); Persona* gettitular(); }; Curso 2013/2014 Programación Orientada a Objetos 75

76 Redefinición de métodos Métodos redefinidos en DepositoEstructurado: //Override double DepositoEstructurado::getIntereses() { return Deposito::getIntereses() + getinteresesvariable(); } //Override double DepositoEstructurado::getCapital() { return Deposito::getCapital() + getcapitalvariable(); } Llaman a las versiones de la clase Deposito. Curso 2013/2014 Programación Orientada a Objetos 76

77 Polimorfismo y ligadura El polimorfismo está permitido para entidades (variables) con semántica valor y referencia. Para objetos con semántica valor, puede haber pérdida de información. Ligadura dinámica: Sólo es posible para métodos virtuales. La entidad polimórfica debe ser de tipo referencia. Ligadura estática: Se aplica la versión del método asociada al tipo estático de la variable. Curso 2013/2014 Programación Orientada a Objetos 77

78 Polimorfismo y ligadura con semántica valor Deposito deposito( ); DepositoEstructurado de( ); // Asignación polimórfica entre objetos valor // Se pierde información! deposito = de; deposito.getcapital(); deposito tiene semántica valor se aplica ligadura estática Se ejecuta la versión de getcapital disponible en el tipo estático Deposito::getCapital Curso 2013/2014 Programación Orientada a Objetos 78

79 Polimorfismo y ligadura con semántica referencia Deposito* ptrdeposito = new Deposito( ); DepositoEstructurado* ptrde = new DepositoEstructurado( ); ptrdeposito = ptrde; ptrdeposito->getcapital(); // Ligadura dinámica ptrdeposito->liquidar(); // Ligadura estática ptrdeposito tiene semántica referencia se aplica ligadura estática o dinámica getcapital() método virtual ligadura dinámica Se ejecuta DepositoEstruturado::getCapital liquidar() no es virtual ligadura estática Se ejecuta Deposito::liquidar Curso 2013/2014 Programación Orientada a Objetos 79

80 Conversión de tipos Operador dynamic_cast<tipo*>(ptro) Convierte el ptro en el puntero a Tipo ptro debe ser una entidad polimórfica (su clase debe tener algún método virtual) Al igual que en Java, el tipo de la conversión debe ser compatible. Si la conversión falla, devuelve el puntero NULL Curso 2013/2014 Programación Orientada a Objetos 80

81 Conversión de tipos Ejemplo: Establecer interés variable a depósitos estructurados. Deposito** depositos; depositos = new Deposito*[MAX_DEPOSITOS]; DepositoEstructurado* depest; for (int i =0; i < MAX_DEPOSITOS; i++){ depest = dynamic_cast<depositoestructurado*>(depositos[i]); if (depest!= NULL) depest->settipointeresvariable(0.05); } Curso 2013/2014 Programación Orientada a Objetos 81

82 Compatibilidad de tipos Ejemplo: Calcula el número de depósitos garantizados. int numgarantizados = 0; for (int i =0; i < MAX_DEPOSITOS; i++){ if (dynamic_cast<depositogarantizado*>(depositos[i])) ++numgarantizados; } Equivalente al instanceof de Java. Curso 2013/2014 Programación Orientada a Objetos 82

83 Clases abstractas En C++ una clase es abstracta si tiene algún método virtual puro : sin implementación. No existe una palabra clave para definir una clase abstracta. class ProductoFinanciero{ private: Persona* titular; public: ProductoFinanciero(Persona* titular); virtual double getbeneficio()=0; double getimpuestos(); Persona* gettitular(); }; Curso 2013/2014 Programación Orientada a Objetos 83

84 Interfaces C++ no define el concepto de interfaz de Java. No es necesario, ya que el lenguaje ofrece herencia múltiple. Si una clase quiere ser compatible con varias clases, basta con que herede públicamente de esas clases. El equivalente a las interfaces de Java sería una clase totalmente abstracta sólo con métodos virtuales puros. Curso 2013/2014 Programación Orientada a Objetos 84

85 Herencia múltiple En C++ es posible que una clase tenga más de una clase padre. Problemas: Herencia repetida: una clase se hereda dos veces, duplicando los atributos y código. Colisión de nombres: la clase hija hereda dos métodos con la misma signatura. Curso 2013/2014 Programación Orientada a Objetos 85

86 Herencia múltiple Caso de estudio Curso 2013/2014 Programación Orientada a Objetos 86

87 Herencia múltiple problemas La clase CuentaRemunerada hereda dos veces de la clase ProductoFinanciero. Por defecto, se duplican todos los atributos heredados. titular atributos Deposito titular atributos Cuenta Problemas herencia repetida at. CtaRemunerada Curso 2013/2014 Programación Orientada a Objetos 87

88 Herencia repetida problemas Problema: el método gettitular() se hereda dos veces (colisión de nombres). Al aplicarlo sobre un objeto CuentaRemunerada existe ambigüedad. Solución: se resuelve la ambigüedad calificando la versión que queremos aplicar: CuentaRemunerada* cr = new CuentaRemunerada( ); cr->cuenta::gettitular(); Curso 2013/2014 Programación Orientada a Objetos 88

89 Herencia repetida ambigüedad Problema: la asignación polimórfica a una referencia de tipo ProductoFinanciero es ambigua ProductoFinanciero* pf; CuentaRemunerada* cr = new CuentaRemunerada( ); pf = cr; // Error Solución: habría que indicar la ruta de herencia ProductoFinanciero* pf; CuentaRemunerada* cr = new CuentaRemunerada( ); pf = (Cuenta*)cr; Curso 2013/2014 Programación Orientada a Objetos 89

90 Herencia virtual La herencia virtual es una solución a los problemas la herencia repetida: Es útil en las jerarquías tipo rombo, como el caso de estudio. Una clase que aplica herencia virtual de su clase padre evita la repetición de atributos y código en las clases descendientes. La herencia virtual no es transparente para las clases descendientes: Deben llamar explícitamente al constructor de la clase sobre la que se ha aplicado herencia virtual. Curso 2013/2014 Programación Orientada a Objetos 90

91 Herencia virtual class ProductoFinanciero{ }; class Deposito: virtual public ProductoFinanciero { }; class Cuenta: virtual public ProductoFinanciero { }; class CuentaRemunerada: public Cuenta, public Deposito{ }; Curso 2013/2014 Programación Orientada a Objetos 91

92 Herencia virtual Constructores El constructor de la clase CuentaRemunerada tiene que llamar al constructor de ProductoFinanciero aunque no sea una clase de la que hereda directamente. CuentaRemunerada::CuentaRemunerada(Persona* p, double s, int plazodias,double tipointeres) : ProductoFinanciero(p), { } Cuenta(p,s), Deposito(p, s, plazodias, tipointeres) Curso 2013/2014 Programación Orientada a Objetos 92

93 Herencia múltiple Colisión de nombres Problema: la aplicación del métodogetbeneficio() es ambigua si se aplica sobre una variable de tipo CuentaRemunerada Se heredan dos implementaciones (Cuenta y Deposito) CuentaRemunerada* cr = new CuentaRemunerada( ); cr->getbeneficio(); // Error Curso 2013/2014 Programación Orientada a Objetos 93

94 Herencia múltiple Colisión de nombres Solución: se evita al redefinir el método eligiendo una de las versiones ( fusiona implementaciones ) class CuentaRemunerada: public Cuenta, public Deposito{ public: CuentaRemunerada( ); double getbeneficio(); // Redefine el método }; double CuentaRemunerada::getBeneficio(){ return Deposito::getBeneficio(); // Elige Depósito } Curso 2013/2014 Programación Orientada a Objetos 94

95 Herencia múltiple Método dominante Si un método de la clase ProductoFinanciero se define o redefine sólo en una de las clases hijas, no existe ambigüedad. Se dice que la versión redefinida domina sobre la versión original. En el caso de una asignación polimórfica se ejecutará la versión dominante. Curso 2013/2014 Programación Orientada a Objetos 95

96 Genericidad en C++ La clases genéricas en C++ se conocen como templates. Ejemplo: Contenedor template <class T> class Contenedor{ private: T contenido; public: T getcontenido(); void setcontenido (T elem); }; Curso 2013/2014 Programación Orientada a Objetos 96

97 Genericidad Implementación La implementación de la clase genérica debe realizarse en el fichero de cabecera: template<class T> T Contenedor<T>::getContenido(){ } return contenido; template<class T> void Contenedor<T>::setContenido(T elem){ } contenido = elem; Curso 2013/2014 Programación Orientada a Objetos 97

98 Genericidad Uso Se indica el tipo de la clase genérica en la declaración y construcción. Puede ser aplicada a tipos primitivos. Persona* titular = new Persona("juan", " "); Cuenta* cuenta = new Cuenta(titular); Contenedor<Cuenta*> contenedor; contenedor.setcontenido(cuenta); Cuenta* cta = contenedor.getcontenido(); Contenedor<int> centero; centero.setcontenido(10); Curso 2013/2014 Programación Orientada a Objetos 98

99 Genericidad Críticas C++ no implementa un auténtico sistema de genericidad. Cuando se usa una clase genérica, se realiza un reemplazo del texto del parámetro en la declaración de la clase. Por tanto, se genera código para cada uno de los tipos a los que se instancie la clase genérica. Curso 2013/2014 Programación Orientada a Objetos 99

100 Genericidad restringida No se puede restringir la genericidad. Está permitido aplicar cualquier método y operador sobre las entidades del tipo genérico (tipo T en el ejemplo). Es problemático determinar la sintaxis de los mensajes, ya que se puede instanciar a tipos por valor o referencia. Si la operación no está disponible sobre el tipo genérico, el error será detectado en tiempo de compilación. Curso 2013/2014 Programación Orientada a Objetos 100

101 Corrección y robustez en C++ Al igual que Java, C++ ofrece excepciones y asertos para garantizar la corrección y robustez del código. C++ es diferente a Java en varios aspectos: Cualquier dato puede ser utilizado para notificar una excepción. No hay distinción entre excepciones comprobadas y no comprobadas. El compilador no controla ninguna excepción. Curso 2013/2014 Programación Orientada a Objetos 101

102 Lanzamiento de excepciones Se utiliza la palabra reservada throw Aunque es posible notificar como error cualquier dato, se recomienda utilizar objetos. void Cuenta::ingreso(double cantidad) { if (cantidad < 0) throw invalid_argument( Cantidad negativa"); if (estado!= OPERATIVA) throw logic_error("estado incorrecto"); saldo = saldo + cantidad; } Curso 2013/2014 Programación Orientada a Objetos 102

103 Excepciones biblioteca estándar Existe un conjunto de excepciones predefinidas en el espacio de nombres std (<stdexcept.h>) Todas ellas heredan de la clase exception. No es obligatorio que las excepciones del programador hereden de alguna excepción predefinida. Curso 2013/2014 Programación Orientada a Objetos 103

104 Excepciones biblioteca estándar Curso 2013/2014 Programación Orientada a Objetos 104

105 Uso excepciones estándares Para el control de precondiciones se lanzan excepciones compatibles con logic_error void Cuenta::ingreso(double cantidad) { if (cantidad < 0) throw invalid_argument( Cantidad negativa"); if (estado!= OPERATIVA) throw logic_error("estado incorrecto"); saldo = saldo + cantidad; } Curso 2013/2014 Programación Orientada a Objetos 105

106 Excepciones de usuario Para notificar una situación de error se recomienda crear una clase que herede de runtime_error: class RedNoDisponible: public runtime_error{ public: RedNoDisponible(const char* msg); }; RedNoDisponible::RedNoDisponible(const char* msg): runtime_error(msg) {} Las excepciones que heredan de exception disponen del método what() que retorna el mensaje de error. Curso 2013/2014 Programación Orientada a Objetos 106

107 Declaración de excepciones Se utiliza también la palabra reservada throw. Se puede especificar el conjunto de excepciones que puede lanzar un método. void f(int a) throw (E1, E2); f puede lanzar excepciones compatibles con los tipos E1 y E2, pero no otras. Si no se dice nada, significa que podría lanzar cualquier excepción. int f(); Se puede indicar que un método no lanzará ninguna excepción. int f() throw(); Curso 2013/2014 Programación Orientada a Objetos 107

108 Declaración de excepciones El compilador no controla el tratamiento de excepciones en tiempo de compilación. Si en tiempo de ejecución se intenta lanzar una excepción no declarada, se detecta la violación y termina la ejecución. En cambio, el compilador controla la redefinición de un método para que no pueda lanzar más excepciones que las especificadas en el método de la clase padre (= Java). Curso 2013/2014 Programación Orientada a Objetos 108

109 Tratamiento de excepciones Al igual que en Java, las excepciones pueden ser tratadas en bloques try-catch. A diferencia de Java, el compilador no obliga a dar tratamiento a las excepciones. Las excepciones son pasadas al manejador (catch) por referencia. Cuando ocurre una excepción se evalúan los tipos definidos en los manejadores y se ejecuta el primero cuyo tipo sea compatible ( = Java). Se puede definir un manejador para cualquier tipo de excepción: catch( ) Es posible relanzar una misma excepción que se está manejando: throw; Curso 2013/2014 Programación Orientada a Objetos 109

110 Tratamiento de excepciones void Navegador::visualiza(string url) { Conexion* conexion; int intentos = 0; while (intentos < 20) { try { conexion = new Conexion(url); break; } catch (RedNoDisponible& e) { intentos++; if (intentos == 20) throw; //relanza } Si al crear la conexión ocurre la excepción RecursoNoEncontrado (no manejada) pasará al cliente. Curso 2013/2014 Programación Orientada a Objetos 110

111 Asertos C++ permite el uso de asertos llamando a la macro assert() definida en <assert.h> assert() evalúa una expresión y llama a abort() si el resultado es cero (false). void Cuenta::ingreso(double cantidad){ assert(cantidad > 0); assert(estado == OPERATIVA); saldo = saldo + cantidad; } Curso 2013/2014 Programación Orientada a Objetos 111

112 Asertos Antes de abortar, assert escribe en la salida de error el nombre del archivo fuente y la línea donde se produjo el error. Si se define la macro NDEBUG, se desactiva la comprobación de todos los asertos. Curso 2013/2014 Programación Orientada a Objetos 112

113 Asertos Limitaciones Los asertos de C++ tienen los mismos problemas que en Java. No se recomienda evaluar las precondiciones con asertos, ya que se pueden desactivar. Curso 2013/2014 Programación Orientada a Objetos 113