Programación II Curso: 2016-2017

Tema I: Relaciones entre clases.

CP # 6: Polimorfismo. Continuación.

Objetivos:
Lograr que los estudiantes:
1. Apliquen el concepto del polimorfismo en la solución de problemas.
2. Desarrollen habilidades en la definición e implementación de clases donde se
haga uso del contenido relacionado con la herencia y el polimorfismo.

Sumario:
 Resolución de ejercicios.
o Identificación de la relación es-un entre clases.
o Implementación del polimorfismo en C++.

Introducción

En la clase de hoy continuaremos profundizando en los aspectos relacionados con el

polimorfismo, trabajando en la identificación de clases que intervienen en la jerarquía de
herencia y en la necesidad del uso del polimorfismo para una mejor solución.

Desarrollo

Ejercicio # 1

En el Museo Nacional de Bellas Artes se realiza un control estricto de todas las obras allí
expuestas. De toda obra se conoce el año de terminada, autor, fecha de ingreso al museo y
un valor base de la misma. Las obras pueden estar especializadas en: Pintura o Escultura. Si
la obra es una pintura, se conoce además sus dimensiones (largo x ancho), tipo de pintura
utilizada, material sobre el que se pintó y la técnica utilizada; en el caso de las esculturas, se
conoce además el material en que se modeló, su peso y su volumen aproximados. Para
lograr este control estricto el museo tiene archivado una ficha con la información de cada
obra.

a) Implemente los constructores de las clases que satisfacen el problema.

b) Implemente el método FichaTecnica en cada una de las clases de la jerarquía de
herencia.

Nota: Elabore un programa manipulador que pruebe la jerarquía de clases implementada.

Variante de solución:

Dado que este ejercicio fue previamente solucionado en la CP # 5 y posteriormente vuelto a

analizar en la CPM # 3, nos limitaremos a analizar las diferencias que resultarían de
considerar la aplicación del polimorfismo a la solución de este problema.

1
 Declaración de las funciones virtuales

Antes Después

class Obra { class Obra {

private: private:
int annoTerminacion; int annoTerminacion;
char * autor; char * autor;
Fecha ingreso; Fecha ingreso;
float valorBase; float valorBase;

protected: protected:
char * tipo; char * tipo;
char ficha[200]; char ficha[200];
char * conv(int); char * conv(int);
char * conv(float); char * conv(float);

public: public:
Obra(int, char *, Obra(int, char *,
const Fecha &, float); const Fecha &, float);
char * getTipo(); char * getTipo();
char * Autor(); char * Autor();
void setAutor(char *); void setAutor(char *);
float ValorBase(); float ValorBase();
void setValorBase(float); void setValorBase(float);
int AnnoTerminacion(); int AnnoTerminacion();
void setAnnoTerminacion(int); void setAnnoTerminacion(int);
char * FichaTecnica(); virtual char * FichaTecnica();
~Obra(); virtual ~Obra();
}; };

class Pintura : public Obra { class Pintura : public Obra {

private: private:
float largo, ancho; float largo, ancho;
char* tipoPintura; char* tipoPintura;
char* material; char* material;
char* tecnica; char* tecnica;

public:
Pintura(int, char*, const Fecha&,
float, float, float, char*,
char*, char*);
float Largo();
void setLargo(float);
float Ancho();
void setAncho(float);
char * TipoPintura();
void setTipoPintura(char *);
char * Material();
void setMaterial(char *);
char * Tecnica();
void setTecnica(char *);
char * FichaTecnica();
~Pintura();
};
public:
Pintura(int, char*, const Fecha&,
float, float, float, char*,
char*, char*);
float Largo();
void setLargo(float);
float Ancho();
void setAncho(float);
char * TipoPintura();
void setTipoPintura(char *);
char * Material();
void setMaterial(char *);
char * Tecnica();
void setTecnica(char *);
virtual char * FichaTecnica();
virtual ~Pintura();
};

2
 class Escultura : public Obra { class Escultura : public Obra {
private: private:
char* materialM; char* materialM;
float peso, volumen; float peso, volumen;
public: public:
Escultura(int, char*, const Fecha&, Escultura(int, char*, const Fecha&,
float, char*, float, float); float, char*, float, float);
char* MaterialMoldeado(); char* MaterialMoldeado();
void setMaterialMoldeado(char*); void setMaterialMoldeado(char*);
float Peso(); float Peso();
void setPeso(float); void setPeso(float);
float Volumen(); float Volumen();
void setVolumen(float); void setVolumen(float);
char* FichaTecnica(); virtual char* FichaTecnica();
~Escultura(); virtual ~Escultura();
}; };

 Implementación de las llamadas polimórficas

void Museo::MostrarCatalogo() void Museo::MostrarCatalogo()

{ {
for (int i = 0; i < cantReal; i++) for (int i = 0; i < cantReal; i++)
{ cout<<obras[i]->FichaTecnica();
char* tipoObra = }
obras[i]->getTipo();

if (strcmp(tipoObra, "pintura")==0)
cout<<((Pintura*)obras[i])
->FichaTecnica();
else if (strcmp(tipoObra,
"escultura")==0)
cout<<((Escultura*)obras[i])
->FichaTecnica();
else
cout<<obras[i]->FichaTecnica();
}
}

Museo::~Museo() Museo::~Museo()
{ {
for (int i = 0; i < cantReal; i++) for (int i = 0; i < cantReal; i++)
{ delete obras[i];
char* tipoObra = delete [] obras;
obras[i]->getTipo(); }

if (strcmp(tipoObra, "pintura")==0)
delete (Pintura*)obras[i];
else if (strcmp(tipoObra,
"escultura")==0)
delete (Escultura*)obras[i];
else
delete obras[i];
}
delete [] obras;
}

3
Ejercicio # 2

Se quiere conformar un equipo de fútbol a partir de cierto presupuesto para el pago de los
jugadores. Los jugadores pueden ser juveniles o mayores, representados mediante la
siguiente jerarquía de clases.

Juvenil

juegos
Juvenil
Pago

Mayor

goles
Mayor
Pago

Implemente la jerarquía en C++ teniendo en cuenta lo siguiente:

1) Los atributos son privados.

2) Los atributos juegos y goles almacenan la cantidad de juegos y goles de por vida de
un futbolista.
3) El pago a un futbolista Juvenil es de 5 pesos por cada juego que tenga de por vida.
4) El pago a un futbolista Mayor es de 500 pesos por su promedio de goles por juego,
excepto cuando esta cantidad es menor que 400 pesos, en cuyo caso se le pagarían
400 pesos.

La siguiente clase es la encargada de almacenar los futbolistas para un equipo. Complete la

clase Equipo agregándole un método Contratar, cuya función es agregar un futbolista al
listado del equipo. Contratar devolverá true o false en dependencia de si el jugador se
puede o no contratar. Un jugador se puede contratar si queda suficiente presupuesto para su
pago, y si la cantidad de jugadores ya contratados es menor que 20.

class Equipo
{
Juvenil* jugadores[20];
int cantidad;
double presupuesto, prUsado;
public:
Equipo(double presup);
// Crear método Contratar
…
}

Realice lo siguiente en el programa principal:

4
  Cree un equipo vacío.
 Cree jugadores con datos entrados por consola, estos puede ser de tipo Juvenil o
Mayor a opción del usuario.
 Después de crear el equipo, imprima el total de dinero que se les paga a los jugadores
mayores.

Variante de solución:

 Archivo juvenil.h

#ifndef juvenilH
#define juvenilH
class Juvenil
{
int juegos;
public:
Juvenil(int);
virtual ~Juvenil(){}
virtual double Pago();
int Juegos();
};
#endif

 Archivo juvenil.cpp

#include "juvenil.h"

Juvenil::Juvenil(int j)
{
if(j > 0)
juegos = j;
}

double Juvenil::Pago()
{
return juegos * 5;
}

int Juvenil::Juegos()
{
return juegos;
}

 Archivo mayor.h

#ifndef mayorH
#define mayorH
#include "juvenil.h"
class Mayor : public Juvenil
{
int goles;
public:
Mayor(int, int);
virtual ~Mayor(){}
virtual double Pago();

5
};
#endif

 Archivo mayor.cpp

#include "mayor.h"

Mayor::Mayor(int j, int g):Juvenil(j)

{
if(g > 0)
goles = g;
}

double Mayor::Pago()
{
double p = 500 * (double)(goles / Juegos());

if (p < 400)
p = 400;

return p;
}

 Archivo equipo.h

#ifndef equipoH
#define equipoH
#include "mayor.h"
class Equipo
{
Juvenil* jugadores[20];
int cantidad;
double presupuesto, prUsado;
public:
Equipo(double presup);
~Equipo();
bool Contratar(Juvenil*);
double PagoTotalMayores();
};
#endif

 Archivo equipo.cpp

#include "equipo.h"
#include <typeinfo>

Equipo::Equipo(double presup)
{
for (int i = 0; i < 20; i++)
jugadores[i] = 0;

cantidad = 0;
prUsado = 0;

if(presup > 0)
presupuesto = presup;
}

6
Equipo::~Equipo()
{
for (int i = 0; i < cantidad; i++)
delete jugadores[i];
}

bool Equipo::Contratar(Juvenil* jug)

{
double usar = prUsado + jug->Pago();

if (cantidad < 20 && usar <= presupuesto && jug != 0)

{
jugadores[cantidad++] = jug;
prUsado = usar;
return true;
}

return false;
}

double Equipo::PagoTotalMayores()
{
double suma = 0;

for (int i = 0; i < cantidad; i++)

{
if (typeid(*jugadores[i]) == typeid(Mayor))
suma += jugadores[i]->Pago();
}

return suma;
}

 Archivo main.h

#include <iostream.h>
#include "equipo.h"

int main()
{
int presupuesto;
cout << "Introduzca el presupuesto del cual dispone el equipo: ";
cin >> presupuesto;

Equipo E(presupuesto);
Juvenil* J;
char opcion, tipo;

cout << "\nPara introducir un jugador presione cualquier tecla, para terminar (t): ";
cin >> opcion;
opcion = tolower(opcion);

while (opcion != 't') {

do {
cout << "(J)uvenil o (M)ayor? ";
cin >> tipo;
tipo = toupper(tipo);

7
 } while (tipo != 'J' && tipo != 'M');

int juegos, goles;

do {
cout << "Entre la cantidad de juegos de por vida: ";
cin >> juegos;
} while (juegos <= 0);

if (tipo == 'J')
J = new Juvenil(juegos);
else {
do {
cout << "Entre la cantidad de goles: ";
cin >> goles;
} while (goles < 0);

J = new Mayor(juegos, goles);

}

if (E.Contratar(J))
cout << "El jugador fue contratado.\n";
else
cout << "El jugador no fue contratado.\n";

cout << "\nPara introducir un jugador presione cualquier tecla, para terminar (t): ";
cin >> opcion;
}

cout << "Total de dinero que se les paga a los jugadores mayores: " << E.PagoTotalMayores() << endl;
system("pause");
return 0;
}

 Ejemplo de salida en consola:

Introduzca el presupuesto del cual dispone el equipo: 1000

Para introducir un jugador presione cualquier tecla, para terminar (t): a

(J)uvenil o (M)ayor? j
Entre la cantidad de juegos de por vida: 5
El jugador fue contratado.

Para introducir un jugador presione cualquier tecla, para terminar (t): a

(J)uvenil o (M)ayor? m
Entre la cantidad de juegos de por vida: 10
Entre la cantidad de goles: 5
El jugador fue contratado.

Para introducir un jugador presione cualquier tecla, para terminar (t): t

Total de dinero que se les paga a los jugadores mayores: 400
Presione una tecla para continuar . . .

Conclusiones

8
En esta clase continuamos la ejercitación de los contenidos vistos en la conferencia,
identificando clases y dentro de estas las funciones virtuales; dándosele solución a diferentes
problemas donde se manifestaba la herencia y el polimorfismo.

Ejercicio propuesto

En una base de transporte se registran dos tipos de vehículos, los terrestres y los aéreos,
representados mediante la siguiente jerarquía de clases:

Vehiculo

marca
Vehiculo
NecesitaMantenimiento

VTerrestre VAereo

kilometraje horasVuelo
VTerrestre VAereo
NecesitaMantenimiento NecesitaMantenimiento

Impleméntelas en C++ teniendo en cuenta lo siguiente:

1. Los atributos son privados.
2. Un vehículo terrestre necesita mantenimiento si ha recorrido más de 1000 km.
3. Un vehículo aéreo necesita mantenimiento si tiene más de 15 horas de vuelo.

Complete la clase BaseTransporte adicionándole un método Agregar, cuya función es

agregar un vehículo a la lista de la base. Agregar devuelve true o false en dependencia si el
vehículo se puede o no agregar a la base. Un vehículo se puede agregar si no necesita
mantenimiento y si la base tiene capacidad para almacenarlo.

class BaseTransporte
{
Vehiculo* lista[100];
int cantidad;
// Crear el constructor y el destructor.
};
En el programa principal realice lo siguiente:
 Cree una base de transporte vacía.
 Cree un vehículo con datos entrados por consola, el transporte puede ser de tipo
VTerrestre o VAereo a opción del usuario.
 Agregue el vehículo a la base de transporte.