Tema 5. Programación Orientada a Objetos en C++ Programación Orientada a Objetos Curso 2010/2011

Transcripción

1 Tema 5 Programación Orientada a Objetos en C++ Programación Orientada a Objetos Curso 2010/2011

2 Contenido Introducción Clases y objetos Herencia Herencia múltiple Genericidad Colecciones Definición de estrategias. Punteros a función. Corrección y robustez en C++ Asertos Mecanismo de excepciones Curso 2010/2011 Programación Orientada a Objetos 2

3 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 2010/2011 Programación Orientada a Objetos 3

4 Clases y Objetos en C++ Este apartado trata: 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. Instancia actual. Métodos y mensajes. Paso de parámetros. Función main. Curso 2010/2011 Programación Orientada a Objetos 4

5 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 2010/2011 Programación Orientada a Objetos 5

6 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 2010/2011 Programación Orientada a Objetos 6

7 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 2010/2011 Programación Orientada a Objetos 7

8 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 2010/2011 Programación Orientada a Objetos 8

9 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 2010/2011 Programación Orientada a Objetos 9

10 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 2010/2011 Programación Orientada a Objetos 10

11 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 2010/2011 Programación Orientada a Objetos 11

12 Modificador const en los atributos Persona* const titular; codigo titular saldo ultimasoperaciones Pepito Curso 2010/2011 Programación Orientada a Objetos 12

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

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

15 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 2010/2011 Programación Orientada a Objetos 15

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

17 Estructuras Unidad modular heredada de C. En C++ equivale al concepto de clase salvo: Cambia la palabra class por struct Por defecto todos los miembros son públicos excepto que se diga lo contrario. struct Cuenta{ void ingreso (double cantidad); void reintrego (double cantidad); private: }; int codigo; Persona* const titular; double saldo; Curso 2010/2011 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 entre la estructura lógica y física. No proporcionan privilegio de visibilidad. Curso 2010/2011 Programación Orientada a Objetos 18

19 Espacios de nombres Para utilizar un elemento definido en un espacio de nombres: 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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; } Cuenta::Cuenta (Persona *persona) :titular(persona) { } Curso 2010/2011 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 2010/2011 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); } void Cuenta::inicializa(double saldoinicial) { codigo = ++ultimocodigo; saldo = saldoinicial; ultimasoperaciones = new double[cuenta::max_operaciones]; estado = OPERATIVA; } Curso 2010/2011 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 2010/2011 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 equivalentes: 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 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 2010/2011 Programación Orientada a Objetos 36

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

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

39 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 2010/2011 Programación Orientada a Objetos 39

40 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 2010/2011 Programación Orientada a Objetos 40

41 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) cta1 = &cta3; copia de punteros Curso 2010/2011 Programación Orientada a Objetos 41

42 Asignación con semántica valor codigo titular saldo codigo titular saldo cuenta cuenta2 Pepito Juanito cuenta1 = cuenta2 Curso 2010/2011 Programación Orientada a Objetos 42

43 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 2010/2011 Programación Orientada a Objetos 43

44 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 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 2010/2011 Programación Orientada a Objetos 44

45 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 2010/2011 Programación Orientada a Objetos 45

46 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 2010/2011 Programación Orientada a Objetos 46

47 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 2010/2011 Programación Orientada a Objetos 47

48 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 2010/2011 Programación Orientada a Objetos 48

49 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 2010/2011 Programación Orientada a Objetos 49

50 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 2010/2011 Programación Orientada a Objetos 50

51 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 2010/2011 Programación Orientada a Objetos 51

52 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. Curso 2010/2011 Programación Orientada a Objetos 52

53 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 2010/2011 Programación Orientada a Objetos 53

54 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 2010/2011 Programación Orientada a Objetos 54

55 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. const se puede utilizar en otras situaciones diferentes. Existen 8 combinaciones de paso de parámetros por valor o por referencia de un objeto con semántica valor o referencia en el que el modificador const protege el objeto o el parámetro. No todas las combinaciones son válidas. Curso 2010/2011 Programación Orientada a Objetos 55

56 Parámetros const en paso por valor con semántica referencia void transferencia11(cuenta* emisor, const Cuenta* receptor, double cantidad); Se protege el estado del objeto cuenta apuntado por receptor. void transferencia12(cuenta* emisor, Cuenta* const receptor, double cantidad); Equivale a los parámetros final de Java. Se protege el parámetro formal. No sería válida la sentencia receptor = NULL; en el cuerpo del método. Curso 2010/2011 Programación Orientada a Objetos 56

57 Parámetros const en paso por valor con semántica valor void transferencia21(cuenta* emisor, const Cuenta receptor, double cantidad); void transferencia22(cuenta* emisor, Cuenta const receptor, double cantidad); Ambas declaraciones son equivalentes puesto que con semántica valor el estado del objeto es equivalente al valor del parámetro. No se puede modificar ni el parámetro ni el estado. Curso 2010/2011 Programación Orientada a Objetos 57

58 Parámetros const en paso por referencia con semántica referencia void transferencia31(cuenta* emisor, const Cuenta*& receptor, double cantidad); Se protege el estado del objeto cuenta apuntado por receptor. void transferencia32(cuenta* emisor, No compila!! Cuenta*& const receptor, double cantidad); No tiene sentido proteger un parámetro que se ha declarado modificable al ser paso por referencia. Curso 2010/2011 Programación Orientada a Objetos 58

59 Parámetros const en paso por referencia con semántica valor void transferencia41(cuenta* emisor, const Cuenta& receptor, double cantidad); Se protege el estado del objeto cuenta receptor. Desde el punto de vista del paso de parámetros, tiene poco sentido pasar un objeto con semántica valor por referencia y utilizar const para evitar la modificación. No obstante, se utiliza por motivos de eficiencia. void transferencia42(cuenta* emisor, No compila!! Cuenta& const receptor, double cantidad); No tiene sentido proteger un parámetro que se ha declarado modificable al ser paso por referencia. Curso 2010/2011 Programación Orientada a Objetos 59

60 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 un parámetro con los argumentos del programa. Ejemplos: int main(char* args[]) int main() Curso 2010/2011 Programación Orientada a Objetos 60

61 Herencia en C++ Este apartado trata: 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. Compatibilidad de tipos. Redefinición de la copia e igualdad de objetos. Operadores. Clases abstractas. Curso 2010/2011 Programación Orientada a Objetos 61

62 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 2010/2011 Programación Orientada a Objetos 62

63 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 2010/2011 Programación Orientada a Objetos 63

64 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 2010/2011 Programación Orientada a Objetos 64

65 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 2010/2011 Programación Orientada a Objetos 65

66 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 2010/2011 Programación Orientada a Objetos 66

67 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 2010/2011 Programación Orientada a Objetos 67

68 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. Para refinar un método en el que es necesario llamar a la versión del padre: NombreClase::NombreMetodo Ejemplo: Deposito::getCapital() Curso 2010/2011 Programación Orientada a Objetos 68

69 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 2010/2011 Programación Orientada a Objetos 69

70 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 2010/2011 Programación Orientada a Objetos 70

71 Polimorfismo y ligadura El polimorfismo de asignación está permitido para entidades (variables) con semántica por valor y referencia. Para objetos por valor, se pierde información en la asignació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 2010/2011 Programación Orientada a Objetos 71

72 Polimorfismo y ligadura con semántica valor Deposito deposito( ); DepositoEstructurado de( ); //Asignación polimórfica entre objetos valor 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 2010/2011 Programación Orientada a Objetos 72

73 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 Es equivalente al método final de Java? Curso 2010/2011 Programación Orientada a Objetos 73

74 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 2010/2011 Programación Orientada a Objetos 74

75 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 2010/2011 Programación Orientada a Objetos 75

76 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 2010/2011 Programación Orientada a Objetos 76

77 Copia e igualdad de objetos No existe una clase raíz como la clase Object de Java. No existen métodos como clone o equals. Los operadores de asignación y copia entre objetos con semántica referencia se comportan igual que en Java. No se debe cambiar la semántica. 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 = e == Curso 2010/2011 Programación Orientada a Objetos 77

78 Operadores Gran parte de los operadores del lenguaje (=, ==,!=, <, <=, etc.) pueden ser definidos 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 2010/2011 Programación Orientada a Objetos 78

79 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 2010/2011 Programación Orientada a Objetos 79

80 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 2010/2011 Programación Orientada a Objetos 80

81 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 2010/2011 Programación Orientada a Objetos 81

82 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 2010/2011 Programación Orientada a Objetos 82

83 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 2010/2011 Programación Orientada a Objetos 83

84 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 2010/2011 Programación Orientada a Objetos 84

85 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 2010/2011 Programación Orientada a Objetos 85

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

87 Herencia múltiple Caso de estudio Curso 2010/2011 Programación Orientada a Objetos 87

88 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 at. CtaRemunerada Curso 2010/2011 Programación Orientada a Objetos 88

89 Herencia múltiple problemas El método gettitular() se hereda dos veces: colisión de nombres. Al aplicarlo sobre un objeto CuentaRemunerada existe ambigüedad. Se resuelve la ambigüedad calificando la versión que queremos aplicar: CuentaRemunerada* cr = new CuentaRemunerada( ); cr->cuenta::gettitular(); Curso 2010/2011 Programación Orientada a Objetos 89

90 Herencia repetida ambigüedad La asignación polimórfica a una referencia de tipo ProductoFinanciero es ambigua: ProductoFinanciero* pf; CuentaRemunerada* cr = new CuentaRemunerada( ); pf = cr; // Error Habría que indicar la ruta de herencia: ProductoFinanciero* pf; CuentaRemunerada* cr = new CuentaRemunerada( ); pf = (Cuenta*)cr; Curso 2010/2011 Programación Orientada a Objetos 90

91 Herencia repetida ambigüedad La aplicación del métodogetbeneficio() es ambigua si se aplica sobre una variable de tipo CuentaRemunerada: ProductoFinanciero* pf; CuentaRemunerada* cr = new CuentaRemunerada( ); pf = (Cuenta*)cr; pf->gettitular(); pf->getbeneficio(); // Versión clase Cuenta cr->getbeneficio(); // Error Curso 2010/2011 Programación Orientada a Objetos 91

92 Herencia virtual Parte de los problemas de ambigüedad de la herencia repetida pueden resolverse con herencia virtual. Evita que la clase ProductoFinanciero se herede dos veces en la clase CuentaRemunerada. Las clases Cuenta y Deposito aplican herencia virtual de ProductoFinanciero: La herencia virtual indica que si una subclase hereda de ProductoFinanciero por otra rama, los atributos y métodos de esa clase no deben repetirse. Curso 2010/2011 Programación Orientada a Objetos 92

93 Herencia virtual class ProductoFinanciero{ }; class Deposito: virtual public ProductoFinanciero { }; class Cuenta: virtual public ProductoFinanciero { }; class CuentaRemunerada: public Cuenta, public Deposito{ }; Curso 2010/2011 Programación Orientada a Objetos 93

94 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 2010/2011 Programación Orientada a Objetos 94

95 Herencia múltiple Colisión de nombres El método getbeneficio() es definido por Cuenta y Deposito: colisión de implementaciones. Se evita al redefinir el método eligiendo una de las versiones: class CuentaRemunerada: public Cuenta, public Deposito{ public: CuentaRemunerada( ); double getbeneficio(); // Redefine el método }; double CuentaRemunerada::getBeneficio(){ return Deposito::getBeneficio(); // Elige Depósito } Curso 2010/2011 Programación Orientada a Objetos 95

96 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 2010/2011 Programación Orientada a Objetos 96

97 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 2010/2011 Programación Orientada a Objetos 97

98 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 2010/2011 Programación Orientada a Objetos 98

99 Genericidad Uso Se indica el tipo de la clase genérica en su declaració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 2010/2011 Programación Orientada a Objetos 99

100 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 2010/2011 Programación Orientada a Objetos 100

101 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 2010/2011 Programación Orientada a Objetos 101

102 Colecciones en C++ Todas las entidades de la Librería Estándar C++ se han incluido en un único espacio de nombres denominado std. La librería estándar de plantillas, o STL (Standard Template Library), implementa un conjunto de estructuras de datos y algoritmos que conforman una parte sustancial de la Librería Estándar C++. Las estructuras de datos genéricas se denominan contenedores. Los contenedores son clases genéricas (template) pensadas para contener cualquier tipo de objeto. No existe un contenedor común raíz de la jerarquía. Curso 2010/2011 Programación Orientada a Objetos 102

103 Tipos de colecciones Existen dos tipos de contenedores: Secuencias: Almacenan los elementos en orden secuencial. Adecuadas para accesos directos y secuenciales. vector, list, deque (cola de doble terminación), stack Asociaciones: Almacenan pares de valores <clave, valor>. Podría verse como una array en el que el índice no tiene por qué ser un entero. Adecuados para accesos aleatorios mediante claves. map, set Curso 2010/2011 Programación Orientada a Objetos 103

104 Cuenta.h #include <list> using namespace std; class Cuenta { public: list<double>* getoperaciones() const; private: list<double>* operaciones; void anotaroperacion(double cantidad); }; Curso 2010/2011 Programación Orientada a Objetos 104

105 Cuenta.cpp Cuenta::Cuenta (Persona* persona, double saldoinicial){ operaciones = new list<double>(); } list<double>* Cuenta::getOperaciones() const{ return new list<double>(*operaciones); } void Cuenta::anotarOperacion(double cantidad){ operaciones->push_back(cantidad); } Curso 2010/2011 Programación Orientada a Objetos 105

106 Prueba de listas int main () { Cuenta* cuenta = new Cuenta(titular); cuenta->ingreso(100); cuenta->reintegro(300); cuenta->ingreso(1000); list<double>* movimientos; movimientos = cuenta->getoperaciones(); list<double>::const_iterator it; it = movimientos->begin(); for (; it!= movimientos->end() ;++it) cout << (*it) << endl; } exit(0); Curso 2010/2011 Programación Orientada a Objetos 106

107 Prueba de listas La implementación de las listas no ofrece métodos para accesos aleatorios porque serían ineficientes. Sólo dispone de métodos de acceso al principio y al final Se puede utilizar de forma efectiva como una pila Para recorrer las listas se utilizan iteradores. Curso 2010/2011 Programación Orientada a Objetos 107

108 Prueba con vectores int main () { Cuenta* cuenta = new Cuenta(titular); cuenta->ingreso(100); cuenta->ingreso(300); cuenta->reintegro(300); cuenta->ingreso(1000); vector<double>* movimientos; movimientos = cuenta->getoperaciones(); for (int i = 0; i < movimientos->size(); i++) cout << (*movimientos)[i] <<endl; } exit(0); Curso 2010/2011 Programación Orientada a Objetos 108

109 Prueba con vectores Los vectores se utilizan como arrays de tamaño fijo. Aunque tiene operaciones para aumentar el tamaño del vector se desaconseja su uso por ser ineficientes. Acceso fácil y eficiente a los elementos. size() no devuelve el número de elementos sino el tamaño del vector. Curso 2010/2011 Programación Orientada a Objetos 109

110 Estrategias Patrón estrategia: parametrizar una rutina con un algoritmo. C++ permite definir punteros a funciones. Un puntero a función es una variable que guarda la dirección de comienzo de una función. X (*fptr) (A); fptr es un puntero a función que recibe A como argumento y devuelve X Curso 2010/2011 Programación Orientada a Objetos 110

111 Estrategias Ejemplo: En la clase Banco, método de búsqueda de productos financieros. namespace banco{ class Banco { private: ProductoFinanciero** productos; public: Banco(); ProductoFinanciero* buscar( bool (*condicion) (ProductoFinanciero*)); }; //Condiciones de búsqueda bool depositoalto (ProductoFinanciero* producto); } Curso 2010/2011 Programación Orientada a Objetos 111

112 Estrategias El parámetro del método buscar() es una función que recibe como parámetro un puntero a un ProductoFinanciero y devuelve un valor booleano. La función depositoalto podría ser establecida como parámetro del método buscar() : cumple la definición del puntero a función. Curso 2010/2011 Programación Orientada a Objetos 112

113 Estrategias ProductoFinanciero* Banco::buscar( bool (*condicion)(productofinanciero*)){ bool encontrado = false; for (int i =0; i < MAX_PRODUCTOS; i++) if (condicion(productos[i])){ encontrado = true; return productos[i]; } if (!encontrado) return NULL; } Curso 2010/2011 Programación Orientada a Objetos 113

114 Estrategias // Comprueba si el producto es un depósito // y su saldo es mayor que bool banco::depositoalto(productofinanciero* producto){ } Deposito* deposito = dynamic_cast<deposito*>(producto); if (deposito!= NULL) return (deposito->getcapital() > 10000); else return false; Banco banco; ProductoFinanciero* producto = banco.buscar(depositoalto); Curso 2010/2011 Programación Orientada a Objetos 114

115 Estrategias Limitaciones Los punteros a funciones están limitados a: Funciones globales (funciones de C). Métodos de clase. No pueden apuntar a métodos de instancia Sin embargo, en la mayoría de casos el mecanismo de los punteros a función es suficiente. Si fuera necesario, se podría simular la solución de Java basada en interfaces. Curso 2010/2011 Programación Orientada a Objetos 115

116 Corrección y Robustez Este apartado trata: Asertos. Excepciones. Excepciones predefinidas. Definición de excepciones. Declaración de excepciones en métodos. Tratamiento de excepciones. Curso 2010/2011 Programación Orientada a Objetos 116

117 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 2010/2011 Programación Orientada a Objetos 117

118 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 2010/2011 Programación Orientada a Objetos 118

119 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. La verificación de código se realiza con pruebas unitarias: ejemplo, herramienta CPPUnit. Curso 2010/2011 Programación Orientada a Objetos 119

120 Excepciones Mecanismo para notificar que se ha producido una situación excepcional. A diferencia de Java, una excepción no tiene por qué ser un objeto de una clase: Se puede lanzar cualquier dato (un entero, una cadena de texto, ) No existen distintas categorías de excepciones. Curso 2010/2011 Programación Orientada a Objetos 120

121 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 2010/2011 Programación Orientada a Objetos 121

122 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 2010/2011 Programación Orientada a Objetos 122

123 Excepciones biblioteca estándar Curso 2010/2011 Programación Orientada a Objetos 123

124 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 2010/2011 Programación Orientada a Objetos 124

125 Excepciones de usuario Para notificar el fallo de una postcondición 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 2010/2011 Programación Orientada a Objetos 125

126 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 de tipo 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 2010/2011 Programación Orientada a Objetos 126

127 Declaración de excepciones A diferencia de Java, el compilador ignora la declaración de excepciones. 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. Curso 2010/2011 Programación Orientada a Objetos 127

128 Declaración de excepciones void Cuenta::ingreso(double cantidad) throw (invalid_argument, logic_error){ if (cantidad<0) throw invalid_argument("cantidad negativa"); if (estado!= OPERATIVA) throw logic_error("estado incorrecto"); saldo = saldo + cantidad; } Declaramos que el método ingreso() sólo puede lanzar los dos tipos de excepciones. Si en el cuerpo del método se produjese alguna otra excepción sería incompatible con la declaración. Curso 2010/2011 Programación Orientada a Objetos 128

129 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 2010/2011 Programación Orientada a Objetos 129

130 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 2010/2011 Programación Orientada a Objetos 130

131 Seminario de C++ Este tema se completa con el Seminario de C++ que incluye: La instalación del compilador C++ de GNU en Windows. Instalación del entorno de desarrollo Eclipse C++. Creación y ejecución de un proyecto. Curso 2010/2011 Programación Orientada a Objetos 131