Seminario C++ Introducción a la programación orientada a objetos. Parte IV v Cristina Cachero Pedro J. Ponce de León

Transcripción

1 Seminario C++ Introducción a la programación orientada a objetos Parte IV v Cristina Cachero Pedro J. Ponce de León Departamento de Lenguajes y Sistemas Informáticos Universidad de Alicante

2 Indice Herencia simple El destructor abstracto Patrón de diseño singleton Tipos enumerados Declaraciones forward Conversión entre objetos (upcasting/downcasting) DLSI- UA POO

3 Herencia Simple class Base { int atrib1; static int atribestatico; void metodoprivado() {... protected: float atrib2; void metodoprotegido() {... public: char atrib3; void metodopublico() {... static int getatribestatico() {... class Derivada : public Base { int otroatributo; public: void metodopublico() {... // reescrito void otrometodo(); // nuevo en Derivada DLSI- UA POO

4 Herencia Simple // Acceso desde métodos de Derivada a propiedades de Base void Derivada::otroMetodo() { cout << atrib1; // ERROR: privado en Base cout << atrib2; cout << atrib3; cout << atribestatico: // ERROR: privado en Base metodoprivado(); // ERROR: privado en Base metodoprotegido(); metodopublico(); getatribestatico(); // Acceso público int main() { Base b; // Base::Base(); Derivada d; // Base::Base(); Derivada::Derivada(); d.metodopublico(); // Derivada::metodoPublico(); d.base::metodopublico(); // Base::metodoPublico(); d.otrometodo(); d.getatribestatico(); cout << d.atrib3 << endl;

5 Destructor abstracto Clase abstracta en C++: Clase con algún método virtual puro El destructor abstracto (virtual puro) class Base {... public: virtual ~Base() = 0; Base::~Base() { /* El destructor abstracto se debe implementar */

6 El patrón de diseño singleton // Aplicacion.h class Aplicacion { public: static Aplicación * getaplicacion() { if (!aplicacion) aplicacion = new Aplicacion; return aplicacion; private: static Aplicacion* aplicacion; Aplicacion(); Ejemplo: // Aplicacion.cc Aplicacion* Aplicacion::aplicacion=NULL; // main.cc int main() { Aplicacion* app = Aplicacion::getAplicacion();

7 Tipos enumerados Se usan para definir conjuntos de constantes enteras bajo un nuevo tipo, diferente de int. enum color { rojo, verde, azul, rosa A las constantes definidas se les asigna valores enteros consecutivos, comenzando por cero. Esto se puede cambiar asignando valores explícitos a las constantes: enum { rojo, // =0 verde, // =1 azul=20, // =20 rosa, // =21 colorao=0, // =0 verde_oliva=verde+2 // =3

8 Tipos enumerados Los tipos enumerados NO son del todo compatibles con el tipo int. Aunque es posible asignar a un entero un tipo enumerado, lo contrario no lo es. En concreto: color c = 1; // ERROR: conversion int -> enum int i = azul; // OK, i=20, conversion enum -> int Sin embargo, color c2 = color(1); // OK Pero, OJO! Hay resultados de castings que dependen del compilador color c3 = color(100) // c3 =? int i = c3 // i =?? En resumen: NO se deben mezclar enteros y tipos enumerados. Los tipos enumerados se utilizan para variables que solo admiten un pequeño número de valores enteros con un significado concreto.

9 Tipos enumerados Definición de tipos enumerados dentro de una clase. Las constantes del tipo enumerado son exportadas al ámbito de la clase. class A { public: enum bit { uno=1, dos=2, cuatro=4 void metododea() { bit b; // OK b = uno; void f(a* a) { A::bit b; // OK b = A::uno; // OK b = a->dos; // OK

10 Declaraciones forward Sirven para desbloquear dependencias circulares entre clases Ejemplo: Un alumno quiere tener acceso a su lista de asignaturas (navegabilidad Alumno->Asignatura) Una asignatura quiere disponer de la lista de alumnos (navegabilidad Asignatura->Alumno) class Asignatura; // permite declarar punteros o referencias // a objetos de tipo Asignatura class Alumno{... private: Asignatura * asignaturas[10]; class Asignatura{... private: Alumno **alumnos;

11 Declaraciones forward OJO! Una declaración forward NO es una definición: class Asignatura; class Alumno {... private: Asignatura asignaturas[10]; // ERROR Para poder hacer esto, Asignatura debería estar definida antes de usarla. Sólo se pueden declarar punteros o referencias a clases declaradas que aún no han sido definidas.

12 Declaraciones forward Declaraciones forward vs. #include Tipicamente en los archivos.h se DEFINEN las clases. Asignatura.h: class Alumno; class Asignatura { private: Alumno *alumnos[100]; // OK puntero a Alumno (aun no def.) Alumno.h: #include Asignatura.h class Alumno { private: Asignatura asignaturas[10]; // OK. Asignatura ya está definida.

13 Conversión entre objetos Sólo cuando pertenecen a la misma jerarquía de herencia Upcasting Base * pb; Derivada* d = new Derivada; // upcasting (automático): pb = d; pb = new Derivada; Downcasting (estático) Derivada* pd; Base* pb = new Derivada; pb->metodopublico(); // Base::metodoPublico() pd = (Derivada*)pb; pd->metodopublico(); //Derivada::metodoPublico()