Las cuestiones se responderán en el espacio reservado para ello

APELLIDOS
Nº Mat.
NOMBRE
UNIVERSIDAD POLITÉCNICA DE MADRID
Calificación
ESCUELA UNIVERSITARIA DE INGENIERÍA TÉCNICA INDUSTRIAL
Departamento El.A.I.
ASIGNATURA
INFORMÁTICA INDUSTRIAL
CURSO 2º
GRUPO
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;
}
Impresión por pantalla
Junio 2013
APELLIDOS
Nº Mat.
NOMBRE
UNIVERSIDAD POLITÉCNICA DE MADRID
Calificación
ESCUELA UNIVERSITARIA DE INGENIERÍA TÉCNICA INDUSTRIAL
Departamento El.A.I.
ASIGNATURA
INFORMÁTICA INDUSTRIAL
CURSO 2º
GRUPO
Junio 2013
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
e
suma de términos, cada uno de los cuales tiene la forma Cx , 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
#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);
};
Termino.h
#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
2
polinomio (2.5x + 6) se creará mediante esta secuencia de instrucciones:
Polinomio p;
p.add(Termino(2.5,2));
p.add(Termino(6,0));
n
n-1
El método mostrar imprime el polinomio, comenzando por el término de mayor exponente: Anx + An-1x
+ A1x + A0
El operador paréntesis evalua el polinomio para un valor dado de la incógnita.
Se pide:
(a)
(b)
(c)
(d)
Proponga el código correspondiente al constructor de la clase Termino.
Defina los métodos get de la clase Termino.
Sobrecargue el operador suma para que devuelva la suma de dos términos (si tienen exponente distinto devuelve cero).
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;
for (i=MAX_TERMINOS-1;i>=0;i--)
APELLIDOS
Nº Mat.
NOMBRE
UNIVERSIDAD POLITÉCNICA DE MADRID
Calificación
ESCUELA UNIVERSITARIA DE INGENIERÍA TÉCNICA INDUSTRIAL
Departamento El.A.I.
ASIGNATURA
INFORMÁTICA INDUSTRIAL
CURSO 2º
GRUPO
Junio 2013
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;
}
APELLIDOS
Nº Mat.
NOMBRE
UNIVERSIDAD POLITÉCNICA DE MADRID
Calificación
ESCUELA UNIVERSITARIA DE INGENIERÍA TÉCNICA INDUSTRIAL
Departamento El.A.I.
ASIGNATURA
INFORMÁTICA INDUSTRIAL
CURSO 2º
GRUPO
Junio 2013
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.
3.
4.
5.
6.
APELLIDOS
Nº Mat.
NOMBRE
UNIVERSIDAD POLITÉCNICA DE MADRID
Calificación
ESCUELA UNIVERSITARIA DE INGENIERÍA TÉCNICA INDUSTRIAL
Departamento El.A.I.
ASIGNATURA
INFORMÁTICA INDUSTRIAL
CURSO 2º
GRUPO
#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
/////////////////////////////////////////
Junio 2013
#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
APELLIDOS
Nº Mat.
NOMBRE
UNIVERSIDAD POLITÉCNICA DE MADRID
Calificación
ESCUELA UNIVERSITARIA DE INGENIERÍA TÉCNICA INDUSTRIAL
Departamento El.A.I.
ASIGNATURA
INFORMÁTICA INDUSTRIAL
CURSO 2º
GRUPO
Junio 2013
///////////////////////////////////////////////////
#ifndef _CAJA_
#define _CAJA_
#include "Pared.h"
class Caja
{
friend class Interaccion;
public:
float Ancho();
float Alto();
Caja();
virtual ~Caja();
void Dibuja();
private:
Pared
Pared
Pared
Pared
suelo;
techo;
pared_izq;
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