Descargar 73,5 kb - U

Pauta Lectura 1 CC51H: Programación
Orientada a Objetos
Profesora: Nancy Hitschfeld Kahler. Ayudante: Diego Dı́az Espinoza
May 2, 2010
1. 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
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
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>
Bolsa<T>
Bolsa<T>
Bolsa<T>
& operator =(const Bolsa<T>& bolsa); //ASIGNACION Y COPIA
operator +(const Bolsa<T>& bolsa1, const Bolsa<T>& bolsa1) //UNION
operator -(const Bolsa<T>& bolsa1, const Bolsa<T>& bolsa1) //DIFERENCIA
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
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: 12-04-2010
*
Author: diego
*/
#include "Complex.h"
#include <iostream>
using namespace std;
4
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
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