, , , Indicar la salida por pantalla (2 puntos-20 minutos) Indicar la impresión por pantalla del siguiente programa:

Transcripción

1 3. Indicar la salida por pantalla (2 puntos-20 minutos) Indicar la impresión por pantalla del siguiente programa: #include <iostream.h> class ClaseA int a; ClaseA(int n):a(n) void mostrar()cout<<a<<endl; ; class ClaseB:public ClaseA int b; ClaseB(int n, int m):b(n),clasea(m) void mostrar()cout<<a<<','<<b<<endl;; ; ClaseA ca(2); ClaseB cb(8,4); ca.mostrar(); cb.mostrar(); ca=cb; ca.mostrar(); cb.mostrar(); ClaseA *c1=new ClaseA(1); ClaseB *c2=new ClaseB(2,3); ClaseA *c3=c1,*c4=c2; c3->mostrar(); c4->mostrar(); ClaseB *c5; c5 = static_cast<claseb *>(c4); c5->mostrar(); delete c1; delete c2; , , ,2 8

2 4. Ejercicio de programación (2,5 puntos-50 minutos) Uno de los clases más clásicas y evidentes en las que se guarda especialmente el encapsulamiento son las clases contenedoras, cuya misión es la de almacenar referencias a objetos u objetos. Hay varios tipos clásicos de contenedores, entre los que cabe destacar las pilas de datos, los árboles, las listas enlazadas, etc. El siguiente ejercicio consiste en completar y trabajar con una pequeña estructura de clases que implementa una pila de datos. Para ello se dispone de una clase base denominada EUITIapilable, que servirá de sustento para los objetos que posteriormente se quieran introducir en una pila. El código de esta clase está COMPLETO, y es utilizado por la clase EUITIpila que es quien implementa la función de pila, o dicho de otra forma, de contenedor LIFO (Last In First Out). Esta funcionalidad se logra mediante la inclusión de una lista encadenada de objetos EUITIapilable, tal y como representa el esquema de la figura: PILA 0 Raiz anterior siguiente Objeto anterior siguiente Objeto anterior siguiente 0 De forma que cada vez que se añade un nuevo elemento a la pila, lo que se hace es que el nodo Raiz, apunte con su puntero siguiente a este nuevo elemento, y al antiguo elemento que estaba al principio de la pila se le dice que su puntero anterior apunte al nuevo. De forma coherente se procede a modificar los punteros anterior y siguiente del nuevo objeto para mantener la lista organizada. Las funciones que hacen esto se denominan push() para insertar, y pop() para extraer. Además se incluye una función main, que demuestra un primer uso de EUITIpila. SE PIDE, por orden: 1.- Escribir la definición del destructor de EUITIpila, el cual eliminará todo lo almacenado. (1 punto) 2.- Escribir la definición del método getnumero() de EUITIpila. (2 puntos) 3.- Sobrecargar el operador += de EUITIpila de forma que se comporte igual que el método push(). (2 puntos) 4.- Escribir completamente la clase Numero de forma que sea coherente con el uso que se da de la misma en la función main. (2 puntos) 5.- Crear una clase Vector que pueda ser introducida en la pila, y que permita almacenar ternas de tres números decimales. (2 puntos) 6.- Escribir una función main nueva que permita incluir en la pila tanto Números como Vectores a elección del usuario, y que después muestre lo almacenado por pantalla. Se recomienda crear para ello una clase abstracta que de una interfaz de impresión y petición de datos, y de la cual se puede hacer heredar tanto número como vector. (2 puntos) NOTA : Aunque la suma de puntuaciones es 11, la máxima nota posible en el ejercicio será de 10.

3 class EUITIapilable friend class EUITIpila; EUITIapilable *siguiente; EUITIapilable *anterior; EUITIapilable():siguiente(0),anterior(0); virtual ~EUITIapilable() if(anterior==0)return; //no esta en la pila if(siguiente) anterior->siguiente=siguiente; siguiente->anterior=anterior; else anterior->siguiente=0; ; class EUITIpila EUITIapilable raiz; void push(euitiapilable *obj); EUITIapilable *pop(); int getnumero(); //numero de elementos en la pila void vacia(); ~EUITIpila(); //elimina los elementos de la pila ; //introduce el objeto al principio de la pila void EUITIpila::push(EUITIapilable *obj) if(obj==0)return; if(raiz.siguiente)( raiz.siguiente)->anterior=obj; obj->siguiente=raiz.siguiente; obj->anterior=&raiz; raiz.siguiente=obj; //saca el primer objeto de la pila EUITIapilable *EUITIpila::pop() if(raiz.siguiente==0)return 0; EUITIapilable *aux=raiz.siguiente; raiz.siguiente=aux->siguiente; if(raiz.siguiente)( raiz.siguiente)->anterior=&primero; aux->anterior=aux->siguiente=0; return aux; //elimina los elementos almacenados y deja la pila //preparada para ser utilizada de nuevo void EUITIpila::vacia() EUITIapilable *aux; while(aux=pop())delete aux; #include <iostream.h> EUITIpila pila; Numero *aux;; int num; cin>>num; while(num) pila.push(new Numero(num)); cin>>num; cout<<"se han almacenado "<<pila.getnumero()<<"numeros:\n"; while(aux=(numero *)(pila.pop())) cout<<aux->num<<endl; delete aux;

4 1.- Escribir la definición del destructor de EUITIpila, el cual eliminará todo lo almacenado. (1 punto) EUITIpila::~EUITIpila() vacia(); 2.- Escribir la definición del método getnumero() de EUITIpila. (2 puntos) int EUITIpila::getNumero() int num=0; EUITIapilable *aux=&raiz; while(aux->siguiente) aux=aux->siguiente; num++; return num; 3.- Sobrecargar el operador += de EUITIpila de forma que se comporte igual que el método push(). (2 puntos) void EUITIpila::operator += (EUITIapilable *obj) push(obj); 4.- Escribir completamente la clase Numero de forma que sea coherente con el uso que se da de la misma en la función main. (2 puntos) class Numero:public EUITIapilable int num; Numero(int n):num(n); ; 5.- Crear una clase Vector que pueda ser introducida en la pila, y que permita almacenar ternas de tres números decimales. (2 puntos) class Vector:public EUITIapilable float data[3]; Vector(float a,float b, float c) data[0]=a; data[1]=b; data[2]=c; ; 6.- Escribir una función main nueva que permita incluir en la pila tanto Números como Vectores a elección del usuario, y que después muestre lo almacenado por pantalla. Se recomienda crear para ello una clase abstracta que de una interfaz de impresión y petición de datos, y de la cual se puede hacer heredar tanto número como vector. (2 puntos)

5 #include <iostream.h> class Interfaz: public EUITIapilable virtual void pedir()=0; virtual void imprimir()=0; ; class Numero:public Interfaz int num; Numero(int n=0):num(n); void pedir() cin>>num; void imprimir() cout<<num; ; class Vector:public Interfaz float data[3]; Vector(float a=0,float b=0, float c=0) data[0]=a; data[1]=b; data[2]=c; void pedir() cin>>data[0]>>data[1]>>data[2]; void imprimir() cout<<data[0]<<data[1]<<data[2]; ; EUITIpila pila; Interfaz *aux; char sel='1'; while(sel!='3') cout<<"1.- Numero"<<endl; cout<<"2.- Vector"<<endl; cout<<"3.- Salir"<<endl; cin>>sel; if(sel=='1') aux=new Numero(); else if(sel=='2') aux=new Vector(); else aux=0; if(aux) aux->pedir(); pila.push(aux); cout<<"se han almacenado "<<pila.getnumero()<<"cosas:\n"; while(aux=(interfaz *)(pila.pop())) aux->imprimir(); cout<<endl; delete aux;

6 5. Problema de Análisis y Diseño Orientado a Objetos (2.5 puntos - 50 minutos) Se pretende desarrollar un programa de simulación de un vapor de agua, para el que se ha desarrollado ya la siguiente clase, que funciona correctamente y no es necesario modificar: class Atomo Atomo(int num); virtual ~Atomo(); void Enlaza(Atomo* a); void CalculaPosicion(); void Dibuja(); float x; float y; float z; int numero_atomico; ; Atomo* enlace; Ejemplo del resultado final Supóngase que el método CalculaPosicion() es capaz de calcular la posición del átomo en el espacio teniendo en cuenta todas las interacciones físicas, incluyendo la posibilidad que dicho átomo haya establecido un enlace con otro átomo. El código para dibujar una molécula de agua utilizando la clase Atomo sería el siguiente: Atomo hidrogeno1(1); Atomo hidrogeno2(1); Atomo oxigeno(16); hidrogeno1.enlaza(&oxigeno); hidrogeno2.enlaza(&oxigeno); oxigeno.calculaposicion(); hidrogeno1.calculaposicion(); hidrogeno2.calculaposicion(); hidrogeno1.dibuja(); hidrogeno2.dibuja(); oxigeno.dibuja(); Donde es importante el orden de cálculo de las posiciones, es decir, primero se calcula la posición del oxigeno, y después la de los átomos de hidrogeno, que dependen del átomo de oxigeno. Cuando el programa este completado, el código del main() debe quedar como: VaporAgua vapor(30); //30 moleculas de agua vapor.calculaposicion(); vapor.dibuja(); Se pide: 1. Diagrama de Clases de Diseño (DCD de la solución), que incluya orientación a objetos para cada molécula de agua. (3,5 puntos) 2. Implementación de la solución en C++ (3,5 puntos) 3. Un diagrama de secuencias del cálculo de la posición y el dibujo del vapor, a partir de la función main().(3 puntos) SOLUCION: 1:

7 2: 3:CODIGO #include "Atomo.h" //MoleculaAgua.h class MoleculaAgua MoleculaAgua(); void Dibuja(); void CalculaPosicion(); Atomo hidrogeno1; Atomo hidrogeno2; Atomo oxigeno; ; //MoleculaAgua.cpp MoleculaAgua::MoleculaAgua():oxigeno(16),hidrogeno1(1),hidrogeno2(1) hidrogeno1.enlaza(&oxigeno); hidrogeno2.enlaza(&oxigeno); void MoleculaAgua::CalculaPosicion()

8 oxigeno.calculaposicion(); hidrogeno1.calculaposicion(); hidrogeno2.calculaposicion(); void MoleculaAgua::Dibuja() hidrogeno1.dibuja(); hidrogeno2.dibuja(); oxigeno.dibuja(); //VaporAgua.h #include "MoleculaAgua.h" class VaporAgua VaporAgua(int num); virtual ~VaporAgua(); void CalculaPosicion(); void Dibuja(); Molecula* moleculas[100]; int num_moleculas; ; //VaporAgua.cpp #include "VaporAgua.h" VaporAgua::VaporAgua(int num) for(int i=0;i<num;i++) Molecula* m=new MoleculaAgua; moleculas[num_moleculas++]=m; VaporAgua::~VaporAgua() for(int i=0;i<num_moleculas;i++) delete moleculas[i]; num_moleculas=0; void VaporAgua::Dibuja() for(int i=0;i<num_moleculas;i++) moleculas[i]->dibuja(); void VaporAgua::CalculaPosicion() for(int i=0;i<num_moleculas;i++) moleculas[i]->calculaposicion();