Pauta Lectura 1 CC51H: Programación Orientada a Objetos

Transcripción

1 Pauta Lectura 1 CC51H: Programación Orientada a Objetos Profesora: Nancy Hitschfeld Kahler. Ayudante: Diego Díaz Espinoza May 2, Pregunta uno (ver código fuente adjunto) La principal diferencia es la sobrecarga de operadores que en Java no está presente. Esto hace del código Java más verboso (diferencia entre a + b y Complex.sum(a, b) o alternativamente a.sum(b)). Sin embargo en Java se hace en más fácil interpretar código ajeno y hacer debugging, puesto que al hacer Complex.sum(a, b) se expresa claramente que se están sumando dos objetos de la clase Complex; a diferencia de C++ donde a + b requiere de un conocimiento previo del tipo de a y b. Para aplicaciones científicas C++ se hace más atractivo puesto que la suma se puede considerar como una operación abstracta (al ser redefinible). También está la diferencia para los métodos friend de C++. Java tiene varios tipos de protección de miembros de clase (no tiene friend): public, private, protected, package. (a) private: Estrictamente sólo para la clase (igual que C++). (b) protected: Estrictamente sólo para clases derivadas y clases del mismo package. (c) package: Estrictamente para clases de un mismo paquete (si se deja sin precedente para un miembro entonces se asume package). (d) public: Sin restricción. Esto le da a Java un mayor manejo de quién puede acceder a miembros privados de una clase. C++ permite acceso a todas las clases o a ninguna, Java permite acceso a todas, algunas y ninguna. 1

2 C++ permite asignaciones como Complex a = 2.3. En Java se debe inicializar obligatoriamente con el constructor de la clase. Por último, C++ permite redefinición de operador == para comparar dos objetos, casting, operador de indexamiento [], operador de entrada y salida y, operador de incremento += entre otros. 2. Pregunta dos En este caso se aplica la siguiente ley: definición de un conjunto de operaciones para un tipo y restricción de acceso a dichas operaciones. (a) Inicialización y Finalización. Inicialización de variables ocultas al momento de la creación e instanciación. Limpiar variables para dejar el estado actual igual al previo a la instanciación de la clase. (b) Asignación y copia. Inicializar un objeto a través de otro y clonar un objeto desde otro. (c) Parametrización de tipos. Variables de clase de un tipo especificado en tiempo de ejecución. (d) Manejo de excepciones. Manejo de errores en tiempo de ejecución. (e) Coerción. Mezcla de tipos compatibles con una clase. (f) Iteradores. Manejo de loops de forma independiente de la implementación. /* PARAMETRIZACION DE TIPOS */ template<class T> class Bolsa private: /* VARIABLES DE CLASE */ list<t> elements; unsigned int position; public: /* INICIALIZACION Y FINALIZACION */ 2

3 Bolsa(); //CONSTRUCTOR VACIO Bolsa(T element); //CONSTRUCTOR CON UN ELEMENTO virtual ~Bolsa(); //DESTRUCTOR /* PSEUDO ITERADOR */ T getnext(); unsigned int size(); ; /* SOBRECARGA DE OPERADORES */ /* -OPERADORES DEFINIDOS FUERA DE LA CLASE * - LAS OPERACIONES SERAN METODOS ESTATICOS * - COMO ESTAN FUERA DE LA CLASE DEBEN SER FRIEND, * PARA QUE TENGAN ACCESO A LAS VARIABLES * PROTEGIDAS * */ Bolsa<T> & operator =(const Bolsa<T>& bolsa); //ASIGNACION Y COPIA Bolsa<T> operator +(const Bolsa<T>& bolsa1, const Bolsa<T>& bolsa1) //UNION Bolsa<T> operator -(const Bolsa<T>& bolsa1, const Bolsa<T>& bolsa1) //DIFERENCIA Bolsa<T> n(const Bolsa &bolsa1, const Bolsa &bolsa2); //INTERSECCION 3. Pregunta tres Figure 1: Diagrama de especialización. Conjunto hereda todas las propiedades de una Bolsa. Todo Conjunto es una Bolsa. 3

4 class Conjunto: public Bolsa public: Conjunto(); Conjunto(R element); virtual ~Conjunto(); ; friend Conjunto operator +(const Conjunto& conjunto1, const Conjunto& conjunto2); friend Conjunto operator n(const Conjunto& conjunto1, const Conjunto& conjunto2); Los constructores llaman a los contructores de Bolsa, al igual que el destructor. Se redefine la operación de unión para que se descarten elementos repetidos al momento de unir. En la diferencia no se necesita reimplementar puesto que de esta operación no pueden quedar elementos repetidos (si es que los dos operandos no tienen elementos repetidos). La intersección no se necesita redefinir si es que se mantiene el invariante de que ambos conjuntos no tienen elementos repetidos. Ejemplos: Bolsa<int> bolsa_a; Bolsa<int> bolsa_b; Bolsa<int> bolsa_c; bolsa_a = Conjunto<int>(5); bolsa_b = Conjunto<int>(10); bolsa_c = bolsa_a + bolsa_b; En tiempo de compilación la última operación llama al operador de suma de Bolsa. En tiempo de ejecución se llama al operador de suma de Conjuntos. /* * Complex.cpp * * Created on: * Author: diego */ #include "Complex.h" #include <iostream> using namespace std; 4

5 Complex::Complex(double r, double i) re=r; im=i; Complex::Complex(double r) re=r; im=0; /* -OPERADORES DEFINIDOS FUERA DE LA CLASE * CON ESTO PODEMOS HACER a + b * SIENDO a,b INSTANCIAS DE LA CLASE COMPLEX * - LAS OPERACIONES SERAN METODOS ESTATICOS * - COMO ESTAN FUERA DE LA CLASE DEBEN SER FRIEND, * PARA QUE TENGAN ACCESO A LAS VARIABLES * PROTEGIDAS * */ friend Complex operator+(complex a, Complex b) return Complex(a.re + b.re, a.im + b.im); friend Complex operator-(complex a, Complex b) return Complex(a.re - b.re, a.im - b.im ); friend Complex operator-(complex a) return Complex(a.re, -a.im); friend Complex operator*(complex a, Complex b) return Complex(a.re*b.re - a.im*b.im, a.im*b.re + a.re*b.im); 5

6 friend Complex operator/(complex a, Complex b) return Complex((a.re*b.re + a.im*b.im)/(b.re*b.re + b.im*b.im), (a.im*b.re - a.re*b.im)/(b.re*b.re + b.im*b.im) ); void Complex::show() std::cout << re << " + " << im << "i" << "\n"; ; 6