3. Indicar la salida por pantalla (2 puntos-10 minutos)

Texto completo

(1)

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; }

(2)
(3)

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.

(4)

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;

(5)

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;

}

(6)
(7)

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.

(8)

4.

5.

(9)

#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

(10)

#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

(11)
(12)

/////////////////////////////////////////////////// #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

Figure

Actualización...

Referencias

Actualización...

Related subjects :