Solución Métodos virtuales. Concepto y características

Solución
2. Pregunta Teórica (1 punto-15 minutos)
Métodos virtuales. Concepto y características, mencionando y explicando al menos el
tipo de enlace que lleva asociado (estático o dinámico), el comportamiento en relación
con la herencia, su relación con los niveles de acceso, la eficiencia respecto a las funciones
no virtuales, y la virtualidad en constructores y destructores.
Un método virtual es un método de una clase base que puede ser redefinido en cada una de las
clases derivadas de esta, y que una vez redefinido puede ser accedido por medio de un puntero
o una referencia a la clase base, resolviéndose mediante enlace dinámico (tiempo de
ejecución).
La virtualidad se hereda.
El nivel de acceso no afecta a la virtualidad de las funciones. Si es público en la clase base y
privado en las derivadas se puede acceder desde fuera con un puntero a la clase base.
Las funciones virtuales son menos eficientes que las normales precisamente por resolverse
mediante enlace dinámico.
Es conveniente que el destructor de la clase base sea virtual para que las llamadas a los
destructores respeten la jerarquía señalada por la herencia. Con los constructores no sucede
este problema porque siempre se invoca primero al constructor de la clase base.
3. Indicar la salida por pantalla (2 puntos-15 minutos)
#include "stdafx.h"
#include <iostream.h>
class Onda
{
public:
Onda () {cout <<"Creación de la onda"<<endl;}
~Onda () {cout <<"Destrucción de la onda"<<endl;}
};
class nota : public Onda
{
protected:
int nombre;
public:
nota (int valor){nombre=valor; cout <<"Nota "<<(char)nombre<<"
creada"<<endl;}
~nota (){cout <<"Nota "<<(char)nombre<<" destruida"<<endl;}
};
class ruido : public Onda
{
public:
ruido (){cout <<"Ruido creado"<<endl;}
~ruido (){cout <<"Ruido destruido"<<endl;}
};
int main(void)
{
nota c1('C');
ruido c2;
printf("¡Reproduciendo ondas!\n");
return 0;
}
Impresión por pantalla
Creación de la onda
Nota C creada
Creación de la onda
Ruido creado
¡Reproduciendo ondas!
Ruido destruido
Destrucción de la onda
Nota C destruida
Destrucción de la onda
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.
#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
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