3. Indicar la salida por pantalla (2 puntos-10 minutos)
#include <iostream.h> class ClaseA { protected: int a; public: ClaseA(int n):a(n){} void mostrar(){cout<<a<<endl;} };class ClaseB:public ClaseA {
int b; public:
ClaseB(int n, int m):b(n),ClaseA(m){} void mostrar(){cout<<a<<’,’<<b<<endl;}; } ; void main() { 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; }
4. Ejercicio de programación (2,5 puntos-50 minutos)
Se desea realizar un programa que permita trabajar con polinomios de una variable. Un polinomio de una variable se define como una suma de términos, cada uno de los cuales tiene la forma Cx e, donde C es un coeficiente real, x es la incógnita y e un exponente entero. Tras el análisis del problema se ha determinado que el modelo de clases estará formado por una clase Término y una clase Polinomio cuya declaración es la siguiente:
Polinomio.h Termino.h
#pragma
once
#define
MAX_TERMINOS 10
#include
"Termino.h"
#include
<iostream>
#include
<math.h>
using
namespace
std;
class
Polinomio
{
private
:
Termino terminos[MAX_TERMINOS];
public
:
Polinomio(
void
);
virtual
~Polinomio(
void
);
void
add (Termino &t);
void
mostrar (
void
);
Termino &
operator
[](
int
);
Polinomio
operator
+(Polinomio &p);
float
operator
() (
float
x);
};
#pragma
once
class
Termino
{
private
:
float
coeficiente;
int
exponente;
public
:
Termino(
float
c=0.0,
int
e=0);
virtual
~Termino(
void
);
int
getExponente(
void
);
float
getCoeficiente (
void
);
float
operator
+(Termino t);
};
Teniendo en cuenta que un polinomio se crea inicialmente sin términos y luego se van añadiendo con el método add. Por ejemplo, el polinomio (2.5x2 + 6) se creará mediante esta secuencia de instrucciones:
Polinomio p;
p.add(Termino(2.5,2)); p.add(Termino(6,0));
El método mostrar imprime el polinomio, comenzando por el término de mayor exponente: Anxn + An-1xn-1 + A1x + A0 El operador paréntesis evalua el polinomio para un valor dado de la incógnita.
Se pide:
(a) Proponga el código correspondiente al constructor de la clase Termino. (b) Defina los métodos get de la clase Termino.
(c) Sobrecargue el operador suma para que devuelva la suma de dos términos (si tienen exponente distinto devuelve cero). (d) Implemento el método add para establecer los términos del polinomio. Para simplificar ubique cada término en la
posición que indique su exponente.
(e) Sobrecargue el operador [] para que devuelva el término que ocupa la posición del índice. (f) Sobrecargue el operador + para implementar la suma de polinomios.
(g) Sobrecargue el operador () para que evalue el polinomio para un valor (h) Implemente el método mostrar de la clase Polinomio
La puntuación del ejercicio irá no sólo en funcion del resultado, sino de la correcta programación usando las
herramientas propias de la POO.
a)
Termino::Termino(
float
c,
int
e)
{
coeficiente = c;
exponente = e;
}
b)
int
Termino::getExponente (
void
)
{
return
exponente;
}
float
Termino::getCoeficiente(
void
)
{
return
coeficiente;
}
c)
float
Termino::
operator
+(Termino t)
{
if
(exponente==t.exponente)
return
coeficiente+t.coeficiente;
else
return
0.0;
}
d)
void
Polinomio::add(Termino &t)
{
terminos[t.getExponente()]=t;
}
e)
Termino & Polinomio::
operator
[] (
int
n)
{
return
terminos [n];
}
f)
Polinomio Polinomio::
operator
+(Polinomio &q)
{
Polinomio s;
for
(
int
i=MAX_TERMINOS-1;i>=0;i--)
s[i]=terminos[i]+q[i];
return
s;
}
g)
float
Polinomio::
operator
() (
float
x)
{
float
resultado=0.0;
for
(
int
i=MAX_TERMINOS-1;i>=0;i--)
if
(terminos[i].getCoeficiente()!=0.0)
resultado+=(terminos[i].getCoeficiente()*pow(x,i));
return
resultado;
}
h)
void
Polinomio::mostrar(
void
)
{
int
i;
cout <<endl;
if
(terminos[i].getCoeficiente()!=0.0)
{
cout <<terminos[i].getCoeficiente();
if
(i!=0) cout <<
"X"
<< i<<
"+"
;
}
cout<<endl;
}
Programa principal de ejemplo (no se pide en el examen)
#include
"stdafx.h"
#include
"Polinomio.h"
#include
<iostream>
using
namespace
std;
int
_tmain(
int
argc, _TCHAR* argv[])
{
int
i;
Polinomio p,q,s;
p.add(Termino(2.5,2));
p.add(Termino(6,0));
p.mostrar();
q.add(Termino(1.5,2));
q.add(Termino(5,1));
q.add(Termino(3,0));
q.mostrar();
s=p+q;
s.mostrar();
cout<<
"s(2)="
<<s(2)<<endl;
cin>>i;
return
0;
}
5. Problema de Análisis y Diseño Orientado a Objetos (2.5 puntos - 50 minutos)
Se desea hacer una aplicación que simule la interacción entre un número indefinido de esferas dentro
de una caja cerrada y que tiene barreras. Para su implementación se hace uso de las GLUT y de la
filosofía empleada en las prácticas de la asignatura. Se pide:
1.
Principales características: jerarquía a dos
niveles.
2.
Lista
de
conceptos
y
asociaciones.
Represente el modelo del dominio.
3.
Diagrama de Clases de Diseño indicando los
patrones empleados.
4.
Diagrama de secuencia del servicio Mueve(t:
float) : void.
5.
Vista de gestión
6.
Implementación de los ficheros de cabecera,
en C++, de la solución.
SOLUCION:
1. El sistema debe de simular la interacción entre una lista de esferas contra las
paredes y las barreras.
1.1. Las esferas tienen velocidades y aceleraciones aleatorias.
1.1 El sistema debe determinar la colisión entre cualquier esfera y las
paredes o barreras, cambiando la velocidad de las esferas que chocan.
1.2 El sistema debe determinar el choque entre las esferas.
2.
4.
5.
#ifndef _VECTOR2D_ #define _VECTOR2D_ class Vector2D { float x; float y; public:
Vector2D(float xv=0.0f,float yv=0.0f);
virtual ~Vector2D();
float modulo();
float argumento();
Vector2D Unitario();
Vector2D operator - (Vector2D &);
Vector2D operator + (Vector2D &);
float operator *(Vector2D &)
Vector2D operator *(float);
}; #endif ///////////////////////////////////////////// // #ifndef _OBJETOMOVIL_ #define _OBJETOMOVIL_ #include "comun/Vector2D.h" class ObjetoMovil { public: ObjetoMovil(); virtual ~ObjetoMovil();
virtual void Mueve(float t);
Vector2D GetPos();
void SetVel(float vx, float vy);
void SetVel(Vector2D vel);
virtual void SetPos(float x,float y);
void SetPos(Vector2D pos);
protected: Vector2D posicion; Vector2D velocidad; Vector2D aceleracion; }; #endif ///////////////////////////////////////////// #ifndef _ESFERA_ #define _ESFERA_ #include "ObjetoMovil.h"
class Esfera :public ObjetoMovil
{
friend class Interaccion;
public:
Esfera();
Esfera(float rad, float x=0.0f, float
y=0.0f,
float vx=0.0f, float vy=0.0f);
virtual ~Esfera();
void Dibuja();
void SetColor( unsigned char
r,unsigned char v, unsigned char a);
void SetRadio(float r);
protected:
unsigned char rojo;
unsigned char verde;
unsigned char azul;
float radio;
};
#endif
#ifndef _LISTAESFERA_ #define _LISTAESFERA_ #define MAX_ESFERAS 100 #include "Esfera.h" class ListaEsferas { public: ListaEsferas(); virtual ~ListaEsferas();
void Mueve(float t);
void Dibuja();
bool Agregar(Esfera* e);
void Eliminar(Esfera* e);
private: Esfera * lista[MAX_ESFERAS]; int numero; }; #endif //////////////////////////////////////////////// #ifndef _PARED_ #define _PARED_ #include "comun/Vector2D.h" class Pared {
friend class Interaccion;
public:
Pared();
virtual ~Pared();
void Dibuja();
void SetColor( unsigned char r,unsigned
char v, unsigned char a);
void SetPos(float x1,float y1,float x2,
float y2);
float Distancia(Vector2D punto, Vector2D
*direccion=0);
private:
Vector2D limite1; Vector2D limite2;
unsigned char rojo;
unsigned char verde;
unsigned char azul;
}; #endif //////////////////////////////////////////// #ifndef _BARRERA_ #define _BARRERA_ #include "Pared.h"
class Barrera: public Pared
{ }; #endif //////////////////////////////////////////// #ifndef _LISTABARRERA_ #define _LISTABARRERA_ #include "Barrera.h" #include <vector> using namespace std; class ListaBarreras {
friend class Interaccion;
vector<Barrera *> listaBarreras; public: void Dibuja(); void anyadirBarrera(Barrera *); virtual ~ListaBarreras(); void ListaBarreras(); }; #endif
/////////////////////////////////////////////////// #ifndef _CAJA_ #define _CAJA_ #include "Pared.h" class Caja {
friend class Interaccion;
public: float Ancho(); float Alto(); Caja(); virtual ~Caja(); void Dibuja(); private: Pared suelo; Pared techo; Pared pared_izq; Pared pared_dcha; }; #endif /////////////////////////////////////////////////// #ifndef _INTERACCION_ #define _INTERACCION_ #include "Caja.h" #include "Esfera.h" class Interaccion { public: Interaccion(); virtual ~Interaccion();
static bool Rebote(Esfera& , ListaBarreras
&);
static void Rebote(Esfera& , Caja &);
static bool Rebote(Esfera& , Esfera& ); }; #endif /////////////////////////////////////////////////// #ifndef _COORDINADOR_ #define _COORDINADOR_ #include "dominio/Caja.h" #include "dominio/ListaEsferas.h" #include "dominio/ListaBarreras.h" class CoordinadorDominio { ListaBarrera barreras; ListaEsferas barreras; Caja caja; public: CoordinadorDominio(); virtual ~CoordinadorDominio(); void Mueve(); void Dibuja(); }; #endif