Práctica Nº 4 – Programación orientada a objetos en C++ · Informática II Práctica Nº 4 – Programación orientada a objetos en C++ Problema 1: Diseñe e implemente una clase

Facultad de Ciencias Exactas, Ingeniería y AgrimensuraDepartamento de Sistemas e InformáticaEscuela de Electrónica Informática II

Práctica Nº 4 – Programación orientada a objetos en C++

Problema 1:

Diseñe e implemente una clase Point3D para representar puntos del espacio y pruébela en una función main.

Point3D: Campos:

Tres campos privados representando sus coordenadas: x, y, y z. Constructores:

• Point3D(): Asigna los valores (0, 0, 0) al punto.• Point3D(int x1, int y1, int z1).• Point3D(int low, int high): Genera aleatoriamente las coordenadas en el

rango dado por los argumentos.

Acceso y actualización: (6 en total)Métodos de utilidad (públicos):

• boolean equals(Point3D q).• boolean equals(int x1, int y1, int z1).• void shiftX(int tx): desplaza coordenada x en tx.• void shiftY(int ty): desplaza la coordenada y en ty.• void shiftZ(int tz): ídem para la z.• Point3D translate(int tx, int ty, int tz): desplaza el punto.• double distanceOrigin(): retorna la distancia al origen.• double distanceToPoint(Point3D q): retorna la distancia al punto q.• int scalarProduct(Point3D q): retorna el producto escalar del vector del

origen al punto q con el vector formado por el punto actual: (x1*x2 + y1*y2 + z1*z2).

• string whichSpace(): Retorna un string que indica si el punto está en el semiplano derecho o izquierdo, arriba o abajo y adelante o atrás o si es el origen. Si una coordenada es 0 puede pertenecer a cualquiera de los dos semiespacios.

• boolean inBox (int xbox, int ybox, int zbox, int width, int height, int depth): retorna verdadero si el punto está contenido en una caja definida por el por el vértice superior, izquierdo al frente (xbox, ybox, zbox) y de un ancho, altura y profundidad.

• boolean inSphere (Point3D center, int radius): retorna true si el punto actual se encuentra contenido en la esfera determinada por su centro y radio.

Informática II Programación orientada a objetos en C++ Pág. 1

Debe definir cualquier constante, variable o método que necesite para hacer lo siguiente en main():

• Declare referencias Point3D (pt1, pt2, pt3). • Instancie cada punto así: pt1 inicializado con el primer constructor, pt2 con el segundo y parámetros (10, -5, 4), pt3 inicializado con el tercero y parámetros (5, 15). • Muestre los 3 puntos con un breve mensaje. • Cambie las coordenadas del punto pt2 a (9, 8, -6) y muestre por pantalla. • Desplace pt1 en 3, -3, 7 usando los shifts separados para cada coordenada, muestre por pantalla y vea si el punto actualizado es igual a pt2, usando el primer método de igualdad. • Desplace el pt1 en 6, 11, -13 usando translate(…) y generando un nuevo punto pt4 , muestre el nuevo pt4, chequee si pt4 es igual a pt2, usando el segundo método de igualdad. • Calcule y muestre la distancia de pt3 al origen. • Calcule y muestre la distancia entre pt1 y pt3. • Calcule y muestre el producto escalar de pt1 y pt2. • Muestre en qué parte del espacio están pt1, pt2 y pt3. • Chequee e imprima si pt2 está contenido en una caja de vértice (-12, 20, 8) y ancho, alto y profundidad de 24, 40 y 35 respectivamente. • Chequee e imprima si pt1 está en una esfera con centro (1, 2, 5) y radio 50. • Imprima todos los campos de los tres puntos.

Solución:// archivo Point3D.husing std::string;

class Point3D {int x;int y;int z;

public:Point3D (int x1, int y1, int z1): x(x1), y(y1), z(z1) {}Point3D (): x(0), y(0), z(0) {}Point3D (int low, int high);

int getX() const;int getY() const;int getZ() const;

void setX (int tx);void setY (int ty);void setZ (int tz);

//string toString() const;bool equals(Point3D q) const;bool equals(int x1, int y1, int z1) const;void shiftX(int tx);void shiftY(int ty);


void shiftZ(int tz);void translate (int tx, int ty, int tz);double distanceOrigin() const;double distanceToPoint(Point3D q) const;int scalarProduct(Point3D q) const;string Point3D::whichSpace() const;bool Point3D::inBox (int xbox, int ybox, int zbox,

int width, int height, int depth) const;bool inSphere(Point3D center, int radius) const;

};

// archivo Point3D.cpp#include <iostream>#include <sstream>#include "Point3D.h"

using std::cout;using std::endl;using std::stringstream;

Point3D::Point3D (int low, int high) {x = low + int((rand() / RAND_MAX)) * (high - low);y = low + int((rand() / RAND_MAX)) * (high - low);z = low + int((rand() / RAND_MAX)) * (high - low);

}

int Point3D::getX() const { return x; }int Point3D::getY() const { return y; }int Point3D::getZ() const { return z; }

void Point3D::setX (int tx) { x = tx; }void Point3D::setY (int ty) { y = ty; }void Point3D::setZ (int tz) { z = tz; }

bool Point3D::equals(Point3D q) const {return (x == q.x && y == q.y && z == q.z);

}

bool Point3D::equals(int x1, int y1, int z1) const {return (x == x1 && y == y1 && z == z1);

}

void Point3D::shiftX(int tx) { x += tx; }void Point3D::shiftY(int ty) { y += ty; }void Point3D::shiftZ(int tz) { z += tz; }void Point3D::translate (int tx, int ty, int tz) {

x += tx;y += ty;z += tz;

}

double Point3D::distanceOrigin() const {return sqrt(pow((double)x, 2) + pow((double)y, 2) + pow((double)z, 2));

}

double Point3D::distanceToPoint(Point3D q) const {return sqrt(pow(double(x - q.x), 2) + pow(double(y - q.y), 2) + pow(double(z - q.z),

2));}


int Point3D::scalarProduct(Point3D q) const {return x * q.x + y * q.y + z * q.z;

}

string Point3D::whichSpace() const { // 8 'espacios': left/right, up/low, far/back// si está en el borde cualquier lado está bienstring message = "Este punto esta: ";

if (equals(0, 0, 0)) // origenmessage = "El punto es el origen!";

else {message += "en el ";if (x >= 0) // derecha

message += "semiplano derecho, ";else

message += "semiplano izquierdo, ";if (y >= 0) // arriba

message += "superior, ";else

message += "inferior, ";if (z >= 0) // delante

message += "y delante.";else

message += "y detrás.";}return message;

}

bool Point3D::inBox (int xbox, int ybox, int zbox, int width, int height, int depth) const {

// xbox,ybox,zbox: borde superior izquierdo de la caja return (x >= xbox) && (x <= xbox + width) // rango de x

&& (y <= ybox) && (y >= ybox - height) // rango de y && (z <= zbox) && (z >= zbox - depth); // rango de z

}

bool Point3D::inSphere(Point3D center, int radius) const {// chequea si este punto está dentro de una esfera de // centro (cx,cy,cz)y radio=radius

return distanceToPoint(center) <= radius;}

int main() {int a1 = 10, b1 = -5, c1 = 4; // para constructorint a2 = 9, b2 = 8, c2 = -6; // para actualizar coordenadasint shift1X = 3,

shift1Y = -3,shift1Z = 7,shift2X = 6,shift2Y = 11,shift2Z = -13;// para mover

int low = 5, high = 15; // para constructorint xBox = -12, yBox = 20, zBox = 8;// borde superior izquierdo y delante de una cajaint width = 24, height = 40, depth = 35; // de la cajaint xCenterSphere = 1, yCenterSphere = 2, zCenterSphere = 5;// centro de esfera


int radius = 50; // radio de esfera

// declara referencia a puntos 3D Point3D pt1, pt2(a1, b1, c1), pt3(low, high);

// imprimecout << "Punto 1 es: (" << pt1.getX() << ", " << pt1.getY() << ", " << pt1.getZ() <<

")" << endl;cout << "Punto 2 es: (" << pt2.getX() << ", " << pt2.getY() << ", " << pt2.getZ() <<

")" << endl;cout << "Punto 3 es: (" << pt3.getX() << ", " << pt3.getY() << ", " << pt3.getZ() <<

")" << endl;

// imprime coordenadas de punto 3printf("\n\nLas coordenadas del punto 3 son: %d, %d, %d", pt3.getX(), pt3.getY(),

pt3.getZ());

// cambia coordenadas de pt2pt2.setX(a2);pt2.setY(b2);pt2.setZ(c2);

cout << endl << "Punto 2 ahora es: ( " << pt2.getX() << ", " << pt2.getY() << ", " << pt2.getZ() << ")" << endl;

// mueve pt1 y chequea si es igual a pt2pt1.shiftX(shift1X);pt1.shiftY(shift1Y);pt1.shiftZ(shift1Z);

cout << "Punto 1 ahora es: ( "<< pt1.getX() << ", " << pt1.getY() << ", " << pt1.getZ() << ")" << endl;

cout << "Es pt1 igual a pt2? --> "<< pt1.equals(pt2) << endl;

// mueve pt1 de nuevo y chequea si es igual a pt2pt1.translate(shift2X, shift2Y, shift2Z);Point3D pt4(pt1);cout << endl << "Punto 1 trasladado, ahora pt4 es: ( " << pt1.getX() << ", " <<

pt1.getY() << ", " << pt1.getZ() << ")" << endl;cout << "Es este nuevo punto transladado pt4 igual a pt2? --> " <<

pt4.equals(pt2.getX(), pt2.getY(), pt2.getZ()) << endl;

// distancia de pt3 al origencout << "Distancia de pt3 al origen es: " << pt3.distanceOrigin() << endl;// distancia pt1 - pt3cout << "Distancia entre pt1 y pt3 es: " << pt1.distanceToPoint(pt3) << endl;// producto escalar de vectores pt1 , pt2cout << "Producto escalar de pt1, pt2 es: " << pt1.scalarProduct(pt2) << endl;// en qué espacios están pt1, pt2, pt3?

cout << "Para pt1 --> " << pt1.whichSpace() << endl;cout << "Para pt2 --> " << pt2.whichSpace() << endl;cout << "Para pt3 --> " << pt3.whichSpace() << endl;// está pt2 en una caja?cout << "Está pt2 en la caja dada? --> " << pt2.inBox(xBox, yBox, zBox, width, height,

depth) << endl;// está pt1 en la esfera?Point3D center(xCenterSphere, yCenterSphere, zCenterSphere);cout << "Está pt1 dentro de la esfera? ---> " << pt1.inSphere(center, radius) << endl;


// Imprimir todos los puntoscout << endl << "Punto 1 es ( " << pt1.getX() << ", " << pt1.getY() << ", " <<

pt1.getZ() << ")" << endl;cout << endl << "Punto 2 es ( " << pt2.getX() << ", " << pt2.getY() << ", " <<

pt2.getZ() << ")" << endl;cout << endl << "Punto 3 es ( " << pt3.getX() << ", " << pt3.getY() << ", " <<

pt3.getZ() << ")" << endl;}

Problema 2:

Se tiene la siguiente definición de la clase Tanque:

class Tanque {double contenido;

public:static const int capacidad = 5000.0;Tanque();double getContenido() const;void agregar(double cantidad); // no superar la capacidadvoid sacar(double cantidad); // no sacar más de lo que hay

};

a) Complete escribiendo el código de métodos y constructor.

b) Añada un método sacaMitad() que elimina la mitad del contenido del tanque. Si el tanque está vacío no hace nada.

c) Escriba una función main que instancie y utilice un objeto t de la clase Tanque. Agregue 100 unidades al tanque. Añada código que contenga un bucle de tipo while, con sentencias que utilicen repetidamente el método sacaMitad() para reducir el contenido del tanque. La iteración deberá detenerse cuando el contenido del tanque sea menor a 1.0.

Solución://archivo Tanque.h#pragma onceclass Tanque{private:

double contenido;public:

static const int capacidad=5000.0;Tanque(void);double getContenido(void) const;void agregar(double cantidad);void sacar(double cantidad);void sacaMitad(void);~Tanque(void);

};//Archivo Tanque.cpp#include "Tanque.h"#include <iostream>using std::cout;


Tanque::Tanque(void){

contenido=0; //inicializo tanque vacío}double Tanque::getContenido(void)const{

return contenido;}void Tanque::agregar(double cantidad){

double aux=cantidad+contenido;if(aux<=capacidad)

contenido=aux;else

cout<<"Si agrega "<<cantidad<<" supera la capacidad\n";}void Tanque::sacar(double cantidad){

double aux=contenido-cantidad;if(aux>=0)

contenido=aux;else

cout<<"Si saca "<<cantidad<<" extrae mas del contenido y queda un nivel negativo\n";}void Tanque::sacaMitad(void){

if(contenido==0)cout<<"No puede sacar la mitad pues el tanque esta vacio";

elsecontenido=contenido/2;

}Tanque::~Tanque(void){}//archivo TestTanque#include <iostream>#include "Tanque.h"using std::cout;

int main(void){

Tanque t;t.agregar(100.0);while(t.getContenido()>=1.0)

t.sacaMitad();cout<<"El contenido final es: "<<t.getContenido()<<"\n";return 0;

}

Problema 3:

a) En una carrera de velocidad participan un cierto número de atletas, cada uno de ellos tiene un nombre, número, nacionalidad y el tiempo que le tomó correr la carrera. Cree


una clase Atleta que represente a un atleta. Para ensayar esta clase, una función main(), que haga lo siguiente: provea información acerca de dos atletas, cree dos objetos Atleta e imprima el nombre del más rápido.

b) Una carrera cubre una cierta distancia y cada carrera tiene un ganador. Cree una clase Carrera que maneje esta información. Ajuste la función main para crear un objeto de tipo Carrera y registre el nombre del atleta más rápido de la carrera.

c) Suponga que desea tener acceso a más información acerca del ganador de la carrera (por ejemplo, el tiempo que tardó o su nacionalidad). No podemos hacer esto desde el objeto carrera directamente. Necesitamos cambiar la definición de la clase tal que en lugar de almacenar el nombre del ganador, almacene un objeto Atleta. Haga este cambio muestre todos los detalles del ganador de una carrera.

d) Ahora deseamos registrar la información de todos los participantes en la carrera, podemos podemos hacer esto añadiendo un atributo competidores a la clase Carrera, que será un array de atletas. Edite la función que determina el ganador de tal forma que ahora lo haga mirando los tiempos de cada competidor. Pruebe estos cambios.

Solución://archivo Atleta.h#pragma once#include <iostream>

class Atleta{private:

char* nombre;int numero;char* nacionalidad;double tiempo;

public:Atleta(char* n=NULL, int nro=0, char* p=NULL, double t=0.0);//para arraychar* getNombre(void) const;int getNumero(void) const;char* getNacionalidad(void) const;double getTiempo(void) const;void setNombre(char* n);void setNumero(int n);void setNacionalidad(char* n);void setTiempo(double t);void mostrarDatos(void) const;~Atleta(void);

};//Atleta.cpp#include "Atleta.h"#include <string.h>#include <iostream>

using std::cout;


Atleta::Atleta(char* n, int nro, char* p, double t){

nombre=new char[strlen(n) + 1];strcpy(nombre, n);numero=nro;nacionalidad=new char[strlen(p)+1];strcpy(nacionalidad, p);tiempo=t;

}char* Atleta::getNombre(void) const{

return nombre;}int Atleta::getNumero(void) const{

return numero;}char* Atleta::getNacionalidad(void) const{

return nacionalidad;}double Atleta::getTiempo(void)const{

return tiempo;}void Atleta::mostrarDatos(void) const{

cout<<"Nombre atleta: "<<nombre<<"\nNumero: "<<numero<<"\nNacionalidad: "<<nacionalidad<<"\nTiempo: "<<tiempo<<"\n";}void Atleta::setNombre(char *n){

if(nombre==NULL){nombre=new char[strlen(n) + 1];strcpy(nombre, n);}

}void Atleta::setNumero(int n){

numero=n;}void Atleta::setTiempo(double t){

tiempo=t;}void Atleta::setNacionalidad(char *p){

if(nacionalidad==NULL){nacionalidad=new char[strlen(p)+1];strcpy(nacionalidad, p);}

}Atleta::~Atleta(void){

delete[] nombre;delete[] nacionalidad;


cout<<"Se invoca al destructor de atleta\n";}//archivo Carrera.h#pragma onceclass Carrera{private:

int distancia;char* ganador;

public:Carrera(int d, char* g);int getDistancia(void)const;char* getGanador(void) const;~Carrera(void);

};//archivo Carrera.cpp#include "Carrera.h"#include <string.h>

Carrera::Carrera(int d, char* g){

distancia=d;ganador=new char[strlen(g) + 1];strcpy(ganador, g);

}int Carrera::getDistancia(void) const{

return distancia;}char* Carrera::getGanador(void) const{

return ganador;}

Carrera::~Carrera(void){

delete[] ganador;}//Carrera1.h#pragma once#include "Atleta.h"

class Carrera1{private:

int distancia;Atleta *ganador;

public:Carrera1(int d, Atleta *g);int getDistancia(void)const;Atleta * getGanador(void) const;~Carrera1(void);

};


//Carrera1.cpp#include "Carrera1.h"#include <iostream>

Carrera1::Carrera1(int d, Atleta *g){

distancia=d;ganador=g;

}int Carrera1::getDistancia(void) const{

return distancia;}

Atleta * Carrera1::getGanador(void) const{

return ganador;}Carrera1::~Carrera1(void){

ganador=NULL;}//Carrera2.h#pragma once#include "Atleta.h"

class Carrera2{private:

int distancia;Atleta** competidores;int cantAtletas;int indice;

public:Carrera2(int d, int cantidad);int getDistancia(void) const;Atleta *getGanador(void) const;int getCantAtletas(void) const;void agregarAtleta(Atleta* p);~Carrera2(void);

};//Carrera2.cpp#include "Carrera2.h"

Carrera2::Carrera2(int d, int cantidad){

distancia=d;cantAtletas=cantidad;competidores=new Atleta* [cantidad];indice=0;

}


int Carrera2::getDistancia(void) const{

return distancia;}

int Carrera2::getCantAtletas(void) const{

return cantAtletas;}

Atleta* Carrera2::getGanador(void) const{

double t=competidores[0]->getTiempo();//Uso de ->double taux;int iaux;for(int i=1;i<cantAtletas;i++){

taux=competidores[i]->getTiempo();if(taux<t){

t=taux;iaux=i;

}}return competidores[iaux];

}

void Carrera2::agregarAtleta(Atleta* p){

if(indice<cantAtletas){competidores[indice]=p;

indice++;}

}Carrera2::~Carrera2(void){

delete[] competidores;}//pruebaAtleta.cpp#include "Atleta.h"#include "Carrera.h"#include "Carrera1.h"#include "Carrera2.h"#include <iostream>

using std::cout;

int main(void){

Atleta a1("Juan Perez",1, "Argentina", 10.1);Atleta a2("John Ford",2,"USA", 9.1);if(a1.getTiempo()<a2.getTiempo())

cout<<"El atleta "<<a1.getNombre()<<" es el mas rapido\n";else

cout<<"El atleta "<<a2.getNombre()<<" es el mas rapido\n";Carrera c1(100, "John Ford");cout<<"El ganador de la carrera es: "<<c1.getGanador()<<"\n";


Atleta *p=new Atleta("Juan Castro", 3, "Mexico", 7.3);Carrera1 c2(200,p);Atleta *q=c2.getGanador();q->mostrarDatos();Carrera2 c3(300,3);c3.agregarAtleta(&a1);c3.agregarAtleta(&a2);c3.agregarAtleta(p);Atleta *r=c3.getGanador();r->mostrarDatos();delete p;return 0;

}

Problema 4:

a) Un vagón de un tren tiene 40 asientos, cada uno de ellos puede estar ocupado o vacante. El vagón puede ser de primera o segunda clase. Cree una clase Carriage para representar esta información. En el constructor se supondrá que todos los asientos inicialmente están vacantes. Escriba los métodos apropiados de acceso y actualización y un método que vaya ocupando los asientos de la siguiente forma: si el vagón es de primera hay un 10% de probabilidad que los asientos sean ocupados; si es de segunda clase hay un 40% de probabilidad que los asientos sean ocupados. Escriba una función main() que contenga un objeto Carriage, llénelo aleatoriamente e imprima el estado de cada asiento.

b) Un tren consta de un cierto número de vagones, tiene una estación de partida y una de llegada, un cierto precio para los tickets de primera y otro para los de segunda. Cree una clase Train que contenga esta información. Añada una función que llene los asientos de los vagones aleatoriamiente. Cree un método que calcule el total de ventas de tickets. Ajuste su función main para probar lo hecho.

Solución:

#include <iostream>

using std::cout;using std::endl;

class Carriage {bool asientos [40]; bool primera;

public:Carriage() {};Carriage(bool prim);bool getAsiento(int ind) { return asientos[ind]; }bool getPrimera() { return primera; }void setPrimera(bool p) { primera = p; }void ocupar();

};

Carriage::Carriage(bool prim) {primera = prim;for(int i = 0; i < 40; i++) asientos[i] = 0;

}Informática II Programación orientada a objetos en C++

Pág. 13

void Carriage::ocupar() {double probabilidad = primera ? 0.1 : 0.4;for(int i = 0; i < 40; i++) asientos[i] = double(rand())/RAND_MAX < probabilidad;

}

class Train {Carriage * carriages;int numPri;int numSeg;char * salida;char * destino;int precioPrimera;int precioSegunda;

public: //lista inicializadoresTrain(int nP, int nS, char * sal, char * dest, int pP, int pS):numPri(nP), numSeg(nS), salida(sal), destino(dest), precioPrimera(pP),

precioSegunda(pS) {carriages = new Carriage[nP + nS];for(int i = 0; i < nP + nS; i++) carriages[i].setPrimera(i < nP);

};~Train() { delete [] carriages; } Carriage getCarriage(int i) { return carriages[i]; }void llenar();int totalVentas();

};

int Train::totalVentas() {int acum = 0;for(int i = 0; i < numPri + numSeg; i++)

if (carriages[i].getPrimera()) for(int j = 0; j < 40; j++)

acum += carriages[i].getAsiento(j) * precioPrimera;else for(int j = 0; j < 40; j++)

acum += carriages[i].getAsiento(j) * precioSegunda;return acum;

}

void Train::llenar() {for(int i = 0; i < numPri + numSeg; i++)

carriages[i].ocupar();}

int main() {Train t(4, 7, "Rosario", "Tucuman", 20, 10);t.llenar();cout << endl << endl << t.totalVentas() << endl;

}


Problema 5:

Suponga que se desea simular el uso de un sube-baja como el mostrado en la figura.

La idea es que cada una de las personas al empujar a la otra hacia arriba está quemando calorías. Suponga que la simulación comienza con la posición del sube y baja en la posición de abajo del lado derecho (como se ve en la figura). Un ciclo completo (tabla arriba y nuevamente abajo) se supone hace que cada persona queme 10 calorías. Las personas realizarán 25 ciclos a menos que una de las dos que están jugando se aburra antes de finalizar los 25 ciclos completos, lo cual ocurre el 5% (probabilidad: 0,05) de las veces que se simula el juego.

Objetivo: Determinar e informar cuántas calorías han quemado las personas en una sesión de simulación.

Desarrolle la clase Persona para que la siguiente funcióm main funcione correctamente. Verifique la posibilidad de finalización de la simulación debido al aburrimiento de cualquiera de las 2 personas, al comienzo de cada ciclo incluyendo el comienzo de la sesión de simulación.

int main() {const int MAX_CICLOS = 25;Persona p1, p2;int ciclos = 0;

while (!p1.decideParar() && !p2.decideParar() && ciclos < MAX_CICLOS) {p1.agregarCalorias();p2.agregarCalorias();ciclos++;

}

cout << endl << "Calorias persona 1: " << p1.getCalorias() << endl;cout << endl << "Calorias persona 2: " << p2.getCalorias() << endl;

}

Problema 6:

Complete dos clases: Triangle y Point. Se suministra un main para probar el código de ambas, en la cual comparará la posición de objetos Triangle, definidos por sus vértices: p1, p2 y p3 expresados en términos de coordenadas (x, y). En la figura, puede apreciarse que el objeto Triangle A está a la izquierda del objeto Triangle B. Suponga que las


bases de los triángulos están siempre alineadas con el eje x y que los vértices son especificados siempre en el mismo orden: p1 (coordenada superior), p2 (coordenada inferior izquierda), p3 (coordenada inferior derecha). Debe suponer también que p2 estará siempre a la izquierda de p1.

Use los principios de programación orientada a objetos (en especial el encapsulamiento) cuando utilice y/o complete las siguientes clases:

• Función main() que crea dos objetos Triangle, muestra por pantalla el área del objeto Triangle creado en primer lugar y determina cuál es el objeto Triangle que está más a la izquierda.

• Point: Esta clase representa un vértice expresado en forma de coordenadas (x, y)• Triangle: Esta clase representa un triángulo cuyos tres vértices (p1, p2, p3) son

objetos de la clase Point.• El método leftmost compara el Triangle con el cual se invoca este método

con otro objeto Triangle chequeando la coordenada x del vértice que está más a la izquierda de cada triángulo. Retorna una referencia al objeto de tipo Triangle que está más a la izquierda.

• El método area calcula el área del objeto Triangle con el cual se invoca, usando esta fórmula: área = (base x altura) / 2.

• Otros métodos: necesita completar el constructor.

int main() {Triangle t1("A", Point(1, 2), Point(0, 0), Point(2, 0));Triangle t2("B", Point(2, 3), Point(1, 0), Point(4, 0));cout << endl << "Area: " << t1.area() << endl;cout << endl << t2.leftmost(t1).getName() << endl;

}

Problema 7:

Escriba una clase que represente un paquete de información enviado a través de una red. Los paquetes tienen las siguientes características que han sido simplificadas para esta aplicación:

• La dirección IP del emisor• La dirección IP del receptor.• Las direcciones IP son números de 12 dígitos • Un número identificador (ID) del paquete que puede estar entre 0 y 2.000.000.000


• El dato enviado representado por un array de bytes. Para este problema se supone que cada paquete tiene una longitud fija de 1000 bytes. Si la información a enviar ocupa menos espacio se rellena con bytes que van alternando ente valores iguales a -1 y 0.

Escriba la clase que represente a uno de estos paquetes. Dicha clase deberá proveer la siguiente funcionalidad:

• Defina un constructor con parámetros para las direcciones de IP del emisor y receptor, el ID del paquete, y un array de tipo byte.

• Implemente el método de acceso para la dirección IP del receptor.• Escriba un método de modificación para especificar un elemento en el array de

datos.• Sobrecargue el operador '=='. Dos paquetes se consideran iguales si las direcciones

IP del destinatario y receptor coinciden al igual que los ID de los paquetes comparados.

Problema 8:

Se desea modelar información acerca de salas para eventos. La capacidad de los salones depende de la superficie y el costo del alquiler depende de la superficie y si están equipados o no.

a. Defina la clase Sala con campos miembro nombre, ancho, largo y equipado. Incluir constructores.

b. Desarrolle una función que permita obtener la capacidad de la sala. Se considera necesario 1.5 m2 para cada asistente.

c. Desarrolle un método que calcule el valor del alquiler: $45 el m2 si la sala está equipada y $32 el m2 si no lo está.

d. Instancie tres objetos de la clase Sala, con las siguientes características:1. Sala1: 12 m de largo por 8 m de ancho, equipada.2. Sala2: 20 m de largo por 18 m de ancho, sin equipar.3. Sala3: 15 m de largo por 12 m de ancho, equipada.

e. Imprima en pantalla los datos de la primera sala (campos miembro, superficie, capacidad y costo).

f. Para los próximos 4 eventos se esperan 200, 50, 100 y 150 asistentes respectivamente. Para ello instancie un arreglo y recórralo con un bucle for imprimiendo en cada iteración el nombre de las posibles salas para realizar el evento según su capacidad, independientemente de que si están equipadas o no.

Solución://Sala.h

#pragma onceclass Sala{

private:char* nombre;int ancho;int largo;bool equipado;


public:Sala(char* n, int a, int l, bool e);char * getNombre(void) const{return nombre;}int getAncho(void)const {return ancho;}int getLargo(void)const{return largo;}bool getEquipado(void)const{return equipado;} int calculaArea(void)const{return ancho*largo;}int calculaCapacidad()const;int calculaAlquiler(void)const;void mostrarDatos(void)const;~Sala(void);};

//Sala.cpp#include "Sala.h"#include <string.h>#include <iostream>#include <math.h>using std::cout;

Sala::Sala(char* n, int a, int l, bool e){

nombre=new char[strlen(n) + 1];strcpy(nombre, n);ancho=a;largo=l;equipado=e;

}int Sala::calculaCapacidad()const{

int superficie=calculaArea();double cap=superficie/1.5;//cout<<"Capacidad: "<<cap<<"\n";return floor(cap);

}int Sala::calculaAlquiler(void) const{

if(equipado)return 45*calculaArea();

elsereturn 32*calculaArea();

}void Sala::mostrarDatos(void) const{ if(equipado){

cout<<"La sala se llama: "<<nombre<<" y mide: "<<ancho<<" de ancho y "<<largo<<" de largo; esta equipada\n"; cout<<"La superficie es de: "<<calculaArea()<<" metros cuadrados, tiene una capacidad para "<<calculaCapacidad()<<" personas y el costo de su alquiler es de: "

<<calculaAlquiler()<<" $\n";}else{

cout<<"La sala se llama: "<<nombre<<" y mide: "<<ancho<<" de ancho y "<<largo<<" de largo; no esta equipada\n"; cout<<"La superficie es de: "<<calculaArea()<<" metros cuadrados, tiene una capacidad para "<<calculaCapacidad()<<" personas y el costo de su alquiler es de: "

<<calculaAlquiler()<<" $\n";}}


Sala::~Sala(void){

}//pruebaSala.cpp#include "Sala.h"#include <iostream>

using std::cout;

int main(void){

Sala s1("Sala 1", 8,12,true);Sala s2("Sala 2", 18,20,false);Sala s3("Sala 3", 12,15,true);Sala s[]={s1,s2,s3};s1.mostrarDatos();int eventos[4]={200,50,100,150};for(int i=0;i<4;i++)

for(int j=0;j<3;j++)if(s[j].calculaCapacidad()>=eventos[i])

cout<<"La sala "<<s[j].getNombre()<<" tiene capacidad para "<<eventos[i]<<" personas\n\n";

return 0;}

Problema 9:

Escriba el código de una clase Candado que modele un candado con combinación numérica (como los usados para equipaje de viaje). Al utilizar por primera vez dicho candado, puede programársele un número de 3 dígitos del 0 al 9 (deberá almacenarlos en un array) que, será la combinación de seguridad. La clase Candado deberá almacenar también información (en forma de array) del estado actual de los tres dígitos de la combinación (que en un dado instante podrá o no coincidir con los 3 dígitos programados). Agregar un constructor que inicialice ambos arrays. Deberá añadir además los siguientes métodos:

• Un método que permita alterar alguno de los 3 dígitos (indicar posición) de la combinación actual.

• Un método, puedeAbrir, que retornará una variable booleana de valor true en caso que la cerradura pueda abrirse y, false en caso contrario.

• Un método mismaCombinacionActual que retornará una variable booleana de valor true en el caso que la combinación actual del objeto con el cual se invoca este método coincida con la combinación actual de otro Candado (deberá pasarlo como argumento al invocarlo).

Deberá escribir una función main donde creará dos objetos de tipo Candado, c1 y c2. Deberá cambiar uno de los tres dígitos de la combinación actual de c1, mostrar por pantalla: un mensaje que indique si con la combinación actual de c2 que programó se puede abrir o no y otro indicando si c1 y c2 tienen (o no) programados las mismas combinaciones actuales.


Solución://Candado.h#pragma onceclass Candado{public:

Candado(int []);void alterardigito(int i, int nro);bool puedeAbrir()const;bool mismaCombinacionActual(const Candado &c)const;~Candado(void);

private:int programado[3];int actual[3];

};//Candado.cpp#include "Candado.h"

Candado::Candado(int c[]){

for(int i=0;i<3;i++){programado[i]=c[i];actual[i]=0;

}}

void Candado::alterardigito(int i, int nro){

actual[i]=nro;}

bool Candado::puedeAbrir()const{

for(int i=0;i<3;i++)if(programado[i]!=actual[i])

return false;return true;

}bool Candado::mismaCombinacionActual(const Candado &c)const{

for(int i=0;i<3;i++)if(actual[i]!=c.actual[i])

return false;return true;

}Candado::~Candado(void){}//pruebaCandado.cpp#include <iostream>#include "Candado.h"using std::cout;


int main(void){int p1[]={3,2,1};int p2[]={1,2,3};Candado c1=Candado(p1);Candado c2=Candado(p2);c1.alterardigito(0,1);if(c1.puedeAbrir())

cout<<"El candado se puede abrir\n";else

cout<<"El candado no se puede abrir\n";if(c1.mismaCombinacionActual(c2))

cout<<"Los dos candados tienen la misma combinacion actual\n";else

cout<<"Los dos candados no tienen la misma combinacion actual\n";return 0;

}

Problema 10:

Un polinomio es una expresión matemática en forma de suma de potencias de una o más variables multiplicadas por coeficientes. Un polinomio en una variable con coeficientes constantes está dado por:

anxn + an-1xn-1 + .. + a2x2+ a1x + a0

El grado u orden del polinomio está dado por la potencia más elevada del mismo. Escribir el código de una clase Polinomio que modele un polinomio monovariable. Dicha clase deberá almacenar información sobre el orden del polinomio (mayor o igual a 0) y sobre los coeficientes (usar array de flotantes de doble precisión con de n+1 elementos para el caso de polinomio de orden n) de cada potencia. Añadir a la clase un constructor donde se le pase como información un array con los coeficientes del polinomio(de 0 a n). Deberá escribir 2 métodos de acceso que permitan: uno de ellos, leer el orden del polinomio y el otro, leer el coeficiente que corresponda a una determinada potencia, información que deberá pasar como argumento al invocar el método; un método, calcular, que retorne un array de flotantes de doble precisión donde almacenará el cálculo del polinomio para los valores enteros desde 0 hasta un límite (mayor o igual a cero) que deberá pasar como argumento al invocarlo. Por ejemplo: en el caso de un polinomio de orden 3 (4 elementos) y coeficientes: [-2, 3.3, -1.5, 3] o sea,

3x3 – 1.5x2 + 3.3x1 – 20x0

si se invoca el método calcular pasándole como argumento el entero 2, deberá retornar un array de 3 flotantes de doble precisión que contendrá [-2, 2.8, 22.6] que resulta de calcular Polinomio para los valores: 0, 1, 2, o sea:

3*03 – 1.5*02 + 3.3*0 – 2*00 +0= -2.0

3*13 – 1.5*12 + 3.3*1 – 2*10 +0= 2.8

3*23 – 1.5*22 + 3.3*2 – 2*20+0 = 22.6


Crear además una función main() donde deberá crear un polinomio, mostrar por pantalla información de alguno de sus coeficientes e invocar el método calcular para un valor límite 2.

Solución://Polinomio.h#pragma onceclass Polinomio{public:

Polinomio(int n, double []);int getOrden()const;double getCoef(int p)const;double* calcular(int limite);~Polinomio(void);

private:int orden;double *coef;

};//Polinomio.cpp#include "Polinomio.h"#include <math.h>

Polinomio::Polinomio(int n, double v[]){

orden=n;coef=new double[n+1];for(int i=0;i<(n+1);i++)

coef[i]=v[i];}int Polinomio::getOrden()const{

return orden;}double Polinomio::getCoef(int n) const{

return coef[n];}double* Polinomio::calcular(int limite)//no puedo retornar array{

double *p=new double[limite+1];double suma;for(int i=0;i<=limite;i++){

suma=0;for(int j=0;j<=orden;j++)

suma+=pow((double)i,j)*coef[j];p[i]=suma;

}return p;

}Polinomio::~Polinomio(void){

delete[] coef;}


//pruebaPolinomio.cpp#include <iostream>#include "Polinomio.h"using std::cout;

int main(void){

double v[]={-2, 3.3, -1.5, 3};Polinomio p(3,v);cout<<"\El coeficiente 0 del polinomio es: "<<p.getCoef(0)<<"\n";double *v1=p.calcular(2);for(int i=0;i<=2;i++)

cout<<"El polinomio calculado en "<<i<<" es: "<<v1[i]<<"\n";return 0;

}

Problema 11:

Se llama “cuadrado mágico” a una matriz cuadrada cuyos elementos tienen la propiedad de estar dispuestos de forma tal que, al sumar cada una de sus filas, cada una de sus columnas y cada una de las dos diagonales se obtiene el mismo resultado. Un ejemplo de cuadrado mágico es la matriz que se encuentra en cada una de las fachadas de la Sagrada Familia en Barcelona:

1 14 14 411 7 6 98 10 10 5

13 2 3 15

En este caso la suma de todas sus filas, columnas y dos diagonales es 33, la edad a la que murió Jesucristo.

a.- Escriba el código de una clase EsoNoMagica que representen matrices de cualquier cantidad de filas y columnas y se verifique si son o no cuadradas y si son o no mágicas. Deberá usar campos privados. Dicha clase debe tener un constructor que reciba como argumentos: una matriz de enteros y dos argumentos que indiquen número de filas y número de columnas de la matriz que se pasa como primer argumento. Suponer que las matrices pasadas como primer argumento tienen todas sus filas con la misma cantidad de columnas.

Deberá añadir además los siguientes métodos:

• Un método que retorne una variable cuyo valor indique si la matriz representada por esta clase, es cuadrada o no (es decir, si el número de filas es igual al de columnas, o no).

• Un método que retorne una variable cuyo valor indique la suma de una fila i de la matriz representada por esta clase. Suponga que se pasa como argumento un valor correcto.


• Un método que retorne una variable cuyo valor indique la suma de columna fila i de la matriz representada por esta clase. Suponga que se pasa como argumento un valor correcto.

• Un método que retorne una variable cuyo valor indique la suma de la diagonal principal (es decir, los elementos aii) de la matriz representada por esta clase. Suponer que este método se va a invocar para una matriz cuadrada.

• Un método que retorne una variable cuyo valor indique la suma de la diagonal secundaria de la matriz representada por esta clase (es decir, los elementos ai(n-1-i), con i=0 hasta (n-1), siendo n el número de filas o columnas de la matriz) . Suponer que este método se va a invocar para una matriz cuadrada.

• Un método que retorne una variable cuyo valor indique si la matriz representada por esta clase es un cuadrado mágico o no. Suponer que este método se va a invocar para una matriz cuadrada. Nota: Se recomienda sumar cualquiera de sus filas, columnas o diagonales y luego comparar este valor con las sumas del resto de las filas, columnas y diagonales. Si se encuentra cualquier fila/columna o diagonal cuya suma tenga un valor distinto al de comparación, se puede decir que la matriz no es cuadrado mágico.

b.- Escribir el código de una función main donde creará un objeto de tipo EsoNoMagica. Deberá invocar el método que determine si la matriz representada por dicha clase es cuadrada o no y, en caso de serlo, deberá invocar al método que determina si es un cuadrado mágico o no. En caso de serlo deberá mostrar por pantalla un mensaje indicando el valor de la suma de sus filas/columnas/diagonales. En caso contrario deberá mostrar un mensaje por pantalla indicando que no es cuadrado mágico.

Solución://EsONoMagica.h#pragma onceclass EsONoMagica{public:

EsONoMagica(int **m, int f, int c);bool esCuadrada()const;//true es cuadrada, false no es cuadradaint sumafilai(int i)const;int sumacolumnai(int i)const;int sumadiagpcipal()const;int sumadiagsec()const;bool esMagica()const;~EsONoMagica(void);

private:int** matriz;int filas;int columnas;

};//EsONoMagica.cpp#include "EsONoMagica.h"

EsONoMagica::EsONoMagica(int **m, int f, int c){

filas=f;columnas=c;//reservo espacio para el vector que apunta a las filasmatriz=new int*[f];


//reservo memoria para las columnas de cada filafor(int i=0;i<c;i++)

matriz[i]=new int[c];//llena con datosfor(int i=0;i<filas;i++)

for(int j=0;j<columnas;j++)matriz[i][j]=m[i][j];

}bool EsONoMagica::esCuadrada()const{ if(filas==columnas)return true; else return false;}int EsONoMagica::sumafilai(int i)const{ int suma=0;

for(int j=0;j<columnas;j++)suma+=matriz[i][j];

return suma;}int EsONoMagica::sumacolumnai(int i)const{

int suma=0;for(int j=0;j<filas;j++)

suma+=matriz[j][i];return suma;

}int EsONoMagica::sumadiagpcipal()const{

int suma=0;for(int i=0;i<filas;i++)

suma+=matriz[i][i]; return suma;}

int EsONoMagica::sumadiagsec()const{

int suma=0;for(int i=0;i<filas;i++)

suma+=matriz[0][filas-1-i];return suma;

}bool EsONoMagica::esMagica()const{

int suma=0;for(int i=0;i<columnas;i++)

suma+=matriz[0][i]; int i;

for(i=1;i<filas;i++)if(suma!=sumafilai(i))return false;

for(i=0;i<columnas;i++)if(suma!=sumacolumnai(i))return false;

if(suma!=sumadiagpcipal())return false;if(suma!=sumadiagsec())return false;return true;

}EsONoMagica::~EsONoMagica(void){

//libera la memoria de la matrizfor(int i=0;i<filas;i++)


delete[]matriz[i];//libera columnasdelete[]matriz;//libera filas

}//pruebaMagica.cpp#include <iostream>#include "EsONoMagica.h"using std::cout;

int main(void){

int matriz[4][4]={{1,14,14,4},{11,7,6,9},{8,10,10,5},{13,2,3,15}};int **p;p=new int*[4];for(int i=0;i<4;i++)

p[i]=new int[4];for(int i=0;i<4;i++)

for(int j=0;j<4;j++)p[i][j]=matriz[i][j];

EsONoMagica c(p, 4,4);if(c.esCuadrada())cout<<"La matriz es cuadrada\n";else cout<<"La matriz no es cuadrada\n";if(c.esCuadrada()){

if(c.esMagica())cout<<"La suma de cualquier fila, columna o diagonal es:

"<<c.sumadiagpcipal()<<"\n";else

cout<<"La matriz no es magica\n";}return 0;

}

Problema 12

Un anillo (representado por la clase Anillo) es un par de círculos (representados por la clase Circulo) concéntricos especificado por un centro (existe una clase Punto para representar cualquier punto del plano) el radio del círculo interior y el ancho del anillo (diferencia entre el radio del círculo exterior y el radio del círculo interior). Dado el código del archivo de cabecera de la clase Anillo (y de las clases Punto y Circulo) deberá completar el archivo cpp asociado. El área del anillo es la diferencia entre el área del círculo externo y el área del círculo interno. Para mover un anillo, se deben mover los dos círculos.

#pragma onceclass Punto{public:

Punto(double cx=0.0, double cy=0.0);~Punto(void);double getX(void);double getY(void);void setX(double cx);void setY(double cy);void mover(double dx, double dy);void mostrarPunto(void);

private:double x;double y;};


#pragma once#include "Punto.h"class Circulo{public:

Circulo(double r=1.0, double x=0.0, double y=0.0);double getRadio(void);void setRadio(double r);double area(void);void mostrarCirculo(void);void mover (double dx, double dy);~Circulo(void);

private:double radio;Punto centro;

};

#pragma once#include "Circulo.h"class Anillo{public:

Anillo(double x=0.0, double y=0.0, double radio=1.0, double a=1.0);double getAncho(void);void setAncho(double a);double area(void);void mover(double dx, double dy);void mostrarAnillo(void);~Anillo(void);

private:Circulo interior;Circulo exterior;double ancho;

};

Solución://Punto.cpp#include "Punto.h"#include <iostream>using std::cout;

Punto::Punto(double cx, double cy){

x=cx;y=cy;

}double Punto::getX(void){

return x;}double Punto::getY(void){

return y;}


void Punto::setX(double cx){

x=cx;}void Punto::setY(double cy){

y=cy;}void Punto::mover(double dx, double dy){

x=dx;y=dy;

}void Punto::mostrarPunto(void){cout<<"["<<x<<", "<<y<<"]\n";}Punto::~Punto(void){}//Circulo.cpp#include "Circulo.h"#include "Punto.h"#include <iostream>using std::cout;

const double PI = std::atan(1.0)*4;Circulo::Circulo(double r, double x, double y):centro(x,y){

radio=r;}

double Circulo::getRadio(void){

return radio;}void Circulo::setRadio(double r){

radio=r;}double Circulo::area(void){

return PI*radio*radio;}void Circulo::mostrarCirculo(void){

cout<<"Centro: ";centro.mostrarPunto();cout<<"Radio: "<<radio<<"\n";

}void Circulo::mover(double dx, double dy){

centro.mover(dx, dy);}


Circulo::~Circulo(void){}//Anillo.cpp#include "Anillo.h"

Anillo::Anillo(double x=0.0, double y=0.0, double radio=1.0, double a=1.0):interior(x,y,radio), exterior(x,y,radio+ancho){

ancho=a;}double Anillo::getAncho(void){

return ancho;}void Anillo::setAncho(double a){

ancho=a;}double Anillo::area(void){

return (exterior.area()-interior.area());}void Anillo::mover(double dx, double dy){

interior.mover(dx, dy);exterior.mover(dx,dy);

}//ver funciones que retornan objetos o referencias hacer una qretorne centro//otra que retorne cada una de los circulos

Anillo::~Anillo(void){}

Problema 13

Definir una clase para representar una pila de enteros. Una pila es una lista de items que permite agregar (push) o sacar (pop) sólo de un extremo, operando con el principio LIFO (last-in, first out). Por ejemplo, si la pila contiene [10 4 16 20], pop() debe retornar 10, y luego la pila queda [4 16 20]. Un subsecuente push(13) debe dejar la pila en [13 4 16 20]. No se puede obtener un item que no esté en el top, salvo que se quiten todos los items que están sobre él. La clase debe implementar las funciones push(), pop() y una función print() para mostrar el estado de la pila. Guardar la lista internamente como un arreglo. Escribir un programa de test para verificar el correcto funcionamiento de la clase.

Solución:#include <iostream>



class CStack{public: CStack() : next(0) {} void push(int i); int pop(); void print();private: int list[100]; int next;};

// Push a value on to the stackvoid CStack::push(int i){ if (next < 99) list[next++] = i;}

// Pop a value off the stackint CStack::pop(){ return list[--next];}

// Output the contents of the stackvoid CStack::print(){ cout << '['; for(int i=next-1 ; i>=0 ; i--) cout << ' '<< list[i]; cout << " ]\n";}

int main(){ CStack s;

s.print();

s.push(5); s.push(10); s.push(8);

s.print();

cout << "top of stack=" << s.pop() << endl;

s.print();

return 0;}

Problema 14

a- Implementar una clase CSimpleString que contenga un char* y un entero (longitud) como campos miembro privados. Proveer un constructor que tome un argumento de tipo const char*. Implementar además las funciones constructor de copia, destructor y


sobrecarga del operador de asignación. Verificar que la clase funciona. Ayuda: Utilizar funciones del archivo de cabecera <cstring>. b- ¿Qué otros constructores se pueden definir para la clase CSimpleString? Codificarlos.

Solución 14 a)#include <iostream> // For stream input/output#include <cstring>


class CSimpleString{private: size_t len; char* buff;public: CSimpleString(const char* p = 0); CSimpleString(const CSimpleString& s);//uso de referencias, constructor copia ~CSimpleString();

CSimpleString& operator=(const CSimpleString& rhs);//sobrecarga operadores void print();};

// ConstructorCSimpleString::CSimpleString(const char* p) : len(0), buff(0){ if (p != 0) { len = strlen(p); if (len > 0) { buff = new char[len+1]; strcpy_s(buff, len+1, p); } }}

// Copy constructorCSimpleString::CSimpleString(const CSimpleString& s){ len = s.len; buff = new char[len+1]; strcpy_s(buff, len+1, s.buff);}

// DestructorCSimpleString::~CSimpleString(){ delete buff;}

// Assignment operator - does not deal with str = strCSimpleString& CSimpleString::operator=(const CSimpleString& rhs){ len = rhs.len; delete buff; buff = new char[len+1];


strcpy_s(buff, len+1, rhs.buff);

return *this;}

void CSimpleString::print(){ cout << buff;}

int main(){ CSimpleString s1 = "hello"; CSimpleString s2 = "goodbye"; cout << "s1: \""; s1.print(); cout << "\"" << endl;

cout << "s2: \""; s2.print(); cout << "\"" << endl;

cout << " After executing s2 = s1:" << endl; s2 = s1;

cout << "s1 = \""; s1.print(); cout << "\"" << endl;


return 0;}

Solución 14 b)#include <iostream> #include <cstring>


class CSimpleString{private: size_t len; char* buff;public: CSimpleString(const char* p = 0);//argumento por defecto CSimpleString(const CSimpleString& s);

CSimpleString(char c, int count=1); CSimpleString(int i);

~CSimpleString();

CSimpleString& operator=(const CSimpleString& rhs); void print();};


// Contructor - repeated given characterCSimpleString::CSimpleString(char c, int count) : len(0), buff(0){ len = count; if (len > 0) { buff = new char[len+1]; memset(buff, c, len); buff[len] = '\0'; }}

// Constructor - from an integerCSimpleString::CSimpleString(int i) : len(0), buff(0){ char sTmp[20]; _itoa_s(i, sTmp, 20, 10);

len = strlen(sTmp); if (len > 0) { buff = new char[len+1]; strcpy_s(buff, len+1, sTmp); }}

// ConstructorCSimpleString::CSimpleString(const char* p) : len(0), buff(0){ if (p != 0) { len = strlen(p); if (len > 0) { buff = new char[len+1]; strcpy_s(buff, len+1, p); } }}

// Copy constructorCSimpleString::CSimpleString(const CSimpleString& s){ len = s.len; buff = new char[len+1]; strcpy_s(buff, len+1, s.buff);}

// DestructorCSimpleString::~CSimpleString(){ delete buff;}

// Assignment operator - does not deal with str = strCSimpleString& CSimpleString::operator=(const CSimpleString& rhs){ len = rhs.len; delete buff;


buff = new char[len+1]; strcpy_s(buff, len+1, rhs.buff);

return *this;}


int main(){ CSimpleString s1 = "hello"; CSimpleString s2;

s2 = s1; CSimpleString marker = CSimpleString('*', 30); marker.print(); cout << endl;

cout << "s1 = \""; s1.print();

cout << "\"" << endl;


int n = 7890;

CSimpleString nStr = CSimpleString(n);

cout << n << " as a string is \""; nStr.print(); cout << "\"" << endl;

marker.print(); cout << endl; return 0;}

Problema 15

Sobrecargar los operadores + y += para la clase del ejercicio anterior para concatenar strings.

Solución:#include <iostream> // For stream input/output#include <cstring>


class CSimpleString{private: size_t len; char* buff;


public: CSimpleString(const char* p = 0); CSimpleString(const CSimpleString& s); CSimpleString(char c, int count=1); CSimpleString(int i); ~CSimpleString();

CSimpleString& operator=(const CSimpleString& rhs); CSimpleString& operator+=(const CSimpleString& rhs); CSimpleString operator+(const CSimpleString& s); CSimpleString operator+(const char* s); void print();};

CSimpleString::CSimpleString(char c, int count) : len(0), buff(0){ len = count; if (len > 0) { buff = new char[len+1]; memset(buff, c, len); buff[len] = '\0'; }}

CSimpleString::CSimpleString(int i) : len(0), buff(0){ char sTmp[20]; _itoa_s(i, sTmp, 20, 10);

len = strlen(sTmp); if (len > 0) { buff = new char[len+1]; strcpy_s(buff, len+1, sTmp); }}

CSimpleString::CSimpleString(const char* p) : len(0), buff(0){ if (p != 0) { len = strlen(p); if (len > 0) { buff = new char[len+1]; strcpy_s(buff, len+1, p); } }}

CSimpleString::CSimpleString(const CSimpleString& s){ len = s.len; buff = new char[len+1]; strcpy_s(buff, len+1, s.buff);}


CSimpleString::~CSimpleString(){ delete buff;}

// Assignment operator - does deal with str = strCSimpleString& CSimpleString::operator=(const CSimpleString& rhs){ if (&rhs != this) { len = rhs.len; delete buff; buff = new char[len+1]; strcpy_s(buff, len+1, rhs.buff); }

return *this;}

// Addition operator: add two CSimpleString objectsCSimpleString CSimpleString::operator+(const CSimpleString& s){ size_t length = len + s.len + 1; char* tmp = new char[length]; strcpy_s(tmp, length, buff); strcat_s(tmp, length, s.buff);

return CSimpleString(tmp);}

// Addition operator: CSimpleString object + string constantCSimpleString CSimpleString::operator+(const char* s){ return *this + CSimpleString(s);}

// += operatorCSimpleString& CSimpleString::operator+=(const CSimpleString& rhs){ *this = *this + rhs; return *this;}


int main(){ CSimpleString s1 = "hello"; CSimpleString s2;

s2 = s1; CSimpleString marker = CSimpleString('*', 30); marker.print(); cout << endl;

cout << "s1 = \""; s1.print();


cout << "\"" << endl;


int n = 7890;

CSimpleString nStr = CSimpleString(n);

cout << n << " as a string is \""; nStr.print(); cout << "\"" << endl;

CSimpleString* pStr = &s2;

s2 = *pStr; // s2 = s2 cout << "s2 = \""; s2.print(); cout << "\"" << endl;

s1 += " world!";

cout << "s1 = \""; s1.print();

cout << "\"" << endl;

marker.print(); cout << endl; return 0;}

Problema 16

Modificar la clase pila del ejercicio 13 de forma que el tamaño de la misma sea especificado mediante un constructor con reserva de memoria. Agregar lo que sea necesario. Probar el funcionamiento.

Solución:#include <iostream> using std::cout;using std::endl;

class CStack{public: CStack(int n = 10); ~CStack(); void push(int i); int pop(); void print();

private: int* pList; int size; int next;};


CStack::CStack(int n) : next(0), size(n){ pList = new int[size];}

CStack::~CStack(){ delete [] pList;}

void CStack::push(int i){ if (next < 99) pList[next++] = i;}

int CStack::pop(){ return pList[--next];}

void CStack::print(){ cout << '['; for(int i=next-1 ; i>=0 ; i--) cout << ' '<< pList[i]; cout << " ]\n";}

int main(){ CStack s(20);

s.print();

s.push(5); s.push(10); s.push(8);

s.print();

cout << "top of stack=" << s.pop() << endl;

s.print();

return 0;}

Problema 17

Cree una clase Avión que almacene el nombre del vuelo que realiza y el destino (añadir métodos de acceso y modificación de dichos datos miembros) y permita mostrar por pantalla los datos asociados al mismo. Luego cree dos clases derivadas: AvionPasajeros y AvionHidrante, con los miembros necesarios para que el siguiente programa funcione correctamente:


#include "AvionHidrante.h"#include "AvionPasajeros.h"#include <iostream>using std::cout;

int main(void){

AvionPasajeros ap("AZ19B2", "Londres", 2400, 270.5);AvionHidrante ah("BT3533P8", "Bariloche", 500);ap.mostrarDatos();ah.mostrarDatos();ah.descargarAgua(300);ah.mostrarDatos();ah.descargarAgua();ah.mostrarDatos();return 0;

}

De los aviones de pasajeros (además de los datos miembros del avión) debe almacenar información sobre la cantidad de kilos de equipaje que transporta y la duración prevista del vuelo (en minutos). De los aviones hidrantes interesa almacenar la cantidad de agua que transportan (en litros) y la cantidad de litros de agua actuales. La función descargarAgua () debe permitir disminuir la cantidad de agua que se le pase como argumento, sino se le pasa argumento deberá soltar todo el agua restante.

Solución://Avion.h#pragma onceclass Avion{public:

Avion(char* nv, char* d);void mostrarDatos(void);char* getNombreVuelo(void);char* getDestino(void);void setDestino(char* d);void setNombreVuelo(char* nv);~Avion(void);

private:char* nombrevuelo;char* destino;

};//Avion.cpp#include "Avion.h"#include <string.h>#include <iostream>using std::cout;

Avion::Avion(char* nv, char* d){nombrevuelo=new char[strlen(nv)+1];strcpy_s(nombrevuelo, strlen(nv)+1,nv);destino=new char[strlen(d)+1];strcpy_s(destino, strlen(d)+1,d);}


char* Avion::getDestino(void){return destino;

}

char* Avion::getNombreVuelo(void){

return nombrevuelo;}void Avion::setDestino(char* d){

delete [] destino; destino=new char[strlen(d)+1];

strcpy_s(destino, strlen(d)+1,d);}void Avion::setNombreVuelo(char* nv){

delete [] nombrevuelo;nombrevuelo=new char[strlen(nv)+1];

strcpy_s(nombrevuelo, strlen(nv)+1,nv);}void Avion::mostrarDatos(void){cout<<"El vuelo se llama: "<<nombrevuelo<<" y tiene destino: "<<destino<<"\n";}Avion::~Avion(void){

}//AvionHidrante.h#pragma once#include "avion.h"class AvionHidrante :

public Avion{public:

AvionHidrante(char* nv, char* d, int l);void descargarAgua(int l);void descargarAgua();void mostrarDatos(void);~AvionHidrante(void);

private:int litrosAgua;int capacidad;

};//AvionHidrante.cpp#include "AvionHidrante.h"#include <iostream>using std::cout;

AvionHidrante::AvionHidrante(char* nv, char* d, int c):Avion(nv, d){

capacidad=c;litrosAgua=c;

}


void AvionHidrante::descargarAgua(int l){litrosAgua -=l;

}void AvionHidrante::descargarAgua(){

litrosAgua=0;}void AvionHidrante::mostrarDatos(){

Avion::mostrarDatos();cout<<"La capacidad en litros de agua es: "<<capacidad

<<". Actualmente le quedan: "<<litrosAgua<<"litros de agua\n";}AvionHidrante::~AvionHidrante(void){}//AvionPasajeros#pragma once#include "avion.h"class AvionPasajeros :

public Avion{public:

AvionPasajeros(char* nv, char* d, int du, double p);void mostrarDatos(void);~AvionPasajeros(void);

private:int duracionVuelo; //en minutosdouble pesoEquipaje;

};//AvionPasajeros.cpp#include "AvionPasajeros.h"#include <iostream>using std::cout;

AvionPasajeros::AvionPasajeros(char* nv, char* d, int du, double p):Avion(nv,d){

duracionVuelo=du;pesoEquipaje=p;

}

void AvionPasajeros::mostrarDatos(void){

Avion::mostrarDatos();//reutilizo códigocout<<"La duracion del mismo: "<<duracionVuelo<<" minutos, con capacidad maxima

para equipaje: "<<pesoEquipaje<<"\n";

}

AvionPasajeros::~AvionPasajeros(void){}//pruebaAvion.cpp#include "AvionHidrante.h"#include "AvionPasajeros.h"#include <iostream>using std::cout;


int main(void){

AvionPasajeros ap("AZ19B2", "Londres", 2400, 270.5);AvionHidrante ah("BT3533P8", "Bariloche", 500);ap.mostrarDatos();ah.mostrarDatos();ah.descargarAgua(300);ah.mostrarDatos();ah.descargarAgua();ah.mostrarDatos();return 0;

}

Problema 18

Dado el archivo de cabecera de la clase abstracta Figura:

#pragma onceclass Figura{public:

virtual double area(void)=0;//funcion virtual puravirtual void mostrar(void)=0;//muestra datos de las figurasbool mayorArea(Figura* f);

//si this tiene mayor area que f retorna true};

defina las clases Rectangulo, Circulo y Triangulo derivadas de Figura. Implemente en las clases todas las funciones y datos miembros necesarios para ello.Arme una aplicación Test que tenga una función main que instancie objetos Rectangulo, Circulo y Triangulo (usando punteros de tipo Figura), y muestre un mensaje por pantalla indicando cuál es la de mayor tamaño, mostrando también sus características (ancho, alto, etc.).

Solución://Figura.h#pragma onceclass Figura{public:

virtual double area(void)=0;virtual void mostrar(void)=0;bool mayorArea(Figura* f);bool mayorArea1(Figura& f);

};//Figura.cpp#include "Figura.h"

bool Figura::mayorArea(Figura* f){

return this->area()>f->area();}bool Figura::mayorArea1(Figura& f){

return this->area()>f.area();}


//Circulo.h#pragma once#include "figura.h"

class Circulo :public Figura

{public:

Circulo(double r);virtual double area(void);virtual void mostrar(void);~Circulo(void);

private:double radio;

};//Circulo.cpp#include "Circulo.h"#include <iostream>using std::cout;const double PI = std::atan(1.0)*4;

Circulo::Circulo(double r){radio=r;}

double Circulo::area(void){

return PI*radio*radio;}void Circulo::mostrar(void){

cout<<"El Circulo tiene radio: "<<radio<<"\n";}Circulo::~Circulo(void){}//Rectangulo.h#pragma once#include "Figura.h"class Rectangulo: public Figura{public:

Rectangulo(double l, double a);virtual double area(void);virtual void mostrar(void);~Rectangulo(void);

private: double largo;double ancho;

};//Rectangulo.cpp#include "Rectangulo.h"#include <iostream>using std::cout;

Rectangulo::Rectangulo(double l, double a){

largo=l;ancho=a;}


double Rectangulo::area(void){

return largo*ancho;}void Rectangulo::mostrar(void){cout<<"El Rectangulo tiene largo: "<<largo<<" y ancho: "<<ancho<<"\n";}Rectangulo::~Rectangulo(void){}//Triangulo.h#pragma once#include "Figura.h"class Triangulo: public Figura{public:

Triangulo(double b, double a);virtual double area(void);virtual void mostrar(void);~Triangulo(void);

private:double base;double altura;

};//Triangulo.cpp#include "Triangulo.h"#include <iostream>using std::cout;

Triangulo::Triangulo(double b, double a){

base=b;altura=a;

}double Triangulo::area(void){

return base*altura/2;}void Triangulo::mostrar(void){ cout<<"El triangulo tiene base: "<<base<<" y altura: "<<altura<<"\n";}

Triangulo::~Triangulo(void){}//PruebaFiguras.cpp#include <iostream>#include "Triangulo.h"#include "Rectangulo.h"#include "Circulo.h"

using std::cout;

int main(void){

Figura* p1=new Triangulo(1,2);Figura* p2=new Rectangulo(2,1);


Figura* p3=new Circulo(1);Figura* f;bool b=p3->mayorArea1(*p2);if(b)

cout<<"El circulo es el mas grande"<<"\n";if(p1->mayorArea(p2))

f=p1;else f=p2;if(p3->mayorArea(f))

f=p3;f->mostrar();cout<<"Y tiene un area: "<<f->area()<<"\n";return 0;

}

Problema 19

Se desea desarrollar una aplicación para realizar operaciones aritméticas binarias simples con números reales (Suma, Resta, Producto, Division). Se proporciona el archivo de cabecera de OperacionBinaria:

#pragma onceclass OperacionBinaria{public:

OperacionBinaria(double op1, double op2);virtual double opera()=0;//retorna resultado operación binariadouble getOpera1(void);//retorna operando 1double getOpera2(void);//retorna operando 2void mostrar(void);//muestra resultado operación~OperacionBinaria(void);

private:double operando1;double operando2;

};

#include <iostream>#include "Resta.h"#include "Division.h"using std::cout;

int main(void){

OperacionBinaria* p1=new Suma(4,3);OperacionBinaria* p2=new Resta(4,3);OperacionBinaria* p3=new Producto(4,3);OperacionBinaria* p4=new Division(4,3);Suma* p5=new Resta(3,4);Producto* p6=new Division(3,4);OperacionBinaria* v[]={p1, p2, p3,p4, p5,p6};for(int i=0;i<6;i++)

v[i]->mostrar();return 0;

}

Completar con el código de las clases que considere necesarias de forma tal que Matematicas pueda ser compilada y ejecutada sin errores.


Solución://OperaciónBinaria.h#pragma onceclass OperacionBinaria{public:

OperacionBinaria(double op1, double op2);virtual double opera()=0;double getOpera1(void);double getOpera2(void);void mostrar(void);~OperacionBinaria(void);

private:double operando1;double operando2;

};//OperacionBinaria.cpp#include "OperacionBinaria.h"#include <iostream>using std::cout;

OperacionBinaria::OperacionBinaria(double op1,double op2){

operando1=op1;operando2=op2;

}double OperacionBinaria::getOpera1(void){

return operando1;}double OperacionBinaria::getOpera2(void){

return operando2;}void OperacionBinaria::mostrar(void){

cout<<"El resultado de la operacion binaria es: "<<opera()<<"\n";}OperacionBinaria::~OperacionBinaria(void){}//Suma.h#pragma once#include "operacionbinaria.h"class Suma :

public OperacionBinaria{public:

Suma(double op1, double op2);virtual double opera(void);~Suma(void);

};//Suma.cpp#include "Suma.h"

Suma::Suma(double op1, double op2):OperacionBinaria(op1, op2){}


double Suma::opera(void){return (getOpera1()+getOpera2());

}

Suma::~Suma(void){}//Resta.h#pragma once#include "suma.h"class Resta :

public Suma{public:

Resta(double op1, double op2);~Resta(void);

};

#include "Resta.h"

Resta::Resta(double op1, double op2):Suma(op1, -op2){}

Resta::~Resta(void){}//Producto.h#pragma once#include "operacionbinaria.h"class Producto :

public OperacionBinaria{public:

Producto(double op1, double op2);virtual double opera(void);~Producto(void);

};//Producto.cpp#include "Producto.h"

Producto::Producto(double op1, double op2):OperacionBinaria(op1, op2){}

double Producto::opera(void){

return (getOpera1()*getOpera2());}Producto::~Producto(void){}//Division.h#pragma once#include "producto.h"class Division :


public Producto{

public:Division(double op1, double op2);~Division(void);

};//Division.cpp#include "Division.h"

Division::Division(double op1, double op2):Producto(op1, (1/op2)){}

Division::~Division(void){}//Matematicas.cpp#include <iostream>#include "Resta.h"#include "Division.h"using std::cout;

int main(void){

OperacionBinaria* p1=new Suma(4,3);OperacionBinaria* p2=new Resta(4,3);OperacionBinaria* p3=new Producto(4,3);OperacionBinaria* p4=new Division(4,3);Suma* p5=new Resta(3,4);Producto* p6=new Division(3,4);OperacionBinaria* v[]={p1, p2, p3,p4, p5,p6};for(int i=0;i<6;i++)

v[i]->mostrar();return 0;

}

Problema 20

Dado el archivo de cabecera de la clase abstracta Compuerta:#pragma onceclass Compuerta{public:

Compuerta(int nro);int getNroentradas(void);//retorna nro.entradasint getEntradaNro(int nro);//retorna la entrada nro.void setEntradaNro(int nro, int val);//cambia la entrada nro con valvirtual int eval(void)=0;//evalua la salida de la compuertastatic const int FALSE=0;static const int TRUE=1;static const int UNKNOWN=2;~Compuerta(void);

private:int nroentradas;//número de entradas de la compuertaint* entradas;//vector con los valores presentes en todas las entradas de la compuerta

};Informática II Programación orientada a objetos en C++

Pág. 48

complete el archivo cpp de dicha clase. Escriba el código de la clase concreta CompuertaAND que represente al tipo de compuertas que realizan la función lógica AND de todas sus entradas. Implemente la aplicación Prueba con una función main donde se cree una instancia de CompuertaAND (usando un puntero de tipo Compuerta) para evaluar el resultado.Nota: si cualquier entrada de esta compuerta tiene un valor UNKNOWN, el producto lógico que realiza la compuerta tendrá este valor.

Solución://Compuerta.h#pragma onceclass Compuerta{public:

Compuerta(int nro);int getNroentradas(void);int getEntradaNro(int nro);void setEntradaNro(int nro, int val);virtual int eval(void)=0;static const int FALSE=0;static const int TRUE=1;static const int UNKNOWN=2;~Compuerta(void);

private:int nroentradas;int* entradas;

};//Compuerta.cpp#include "Compuerta.h"

Compuerta::Compuerta(int nro){

nroentradas=nro;entradas=new int[nro];for(int i=0;i<nroentradas;i++)

entradas[i]=UNKNOWN;}int Compuerta::getNroentradas(void){

return nroentradas;}int Compuerta::getEntradaNro(int nro){

return entradas[nro];}void Compuerta::setEntradaNro(int nro, int val){

entradas[nro]=val;}Compuerta::~Compuerta(void){}//CompuertaAND.h#pragma once


#include "compuerta.h"class CompuertaAND :

public Compuerta{public:

CompuertaAND(int nro);virtual int eval(void);~CompuertaAND(void);

};//CompuertaAND.cpp#include "CompuertaAND.h"

CompuertaAND::CompuertaAND(int nro):Compuerta(nro){}

int CompuertaAND::eval(void){

for(int i=0;i<getNroentradas();i++)if(getEntradaNro(i)==UNKNOWN)return UNKNOWN;

for(int i=0;i<getNroentradas();i++)if(getEntradaNro(i)==FALSE)return FALSE;

return TRUE;}CompuertaAND::~CompuertaAND(void){}//pruebaCompuerta.cpp#include "CompuertaAND.h"#include <iostream>using std::cout;

int main(void){

Compuerta* p=new CompuertaAND(4);p->setEntradaNro(0,Compuerta::TRUE);p->setEntradaNro(1,Compuerta::TRUE);p->setEntradaNro(2,Compuerta::FALSE);p->setEntradaNro(3,Compuerta::UNKNOWN);if((p->eval())==Compuerta::TRUE)

cout<<"La salida de la compuerta está en nivel: TRUE\n";else if((p->eval())==Compuerta::FALSE)

cout<<"La salida de la compuerta está en nivel: FALSE\n";else

cout<<"La salida de la compuerta está en nivel: UNKNOWN\n";return 0;

}

Problema 21

Dado el archivo de cabecera de la clase Volumen:#pragma onceclass Volumen{public:

Volumen(char* t="", char* i="", int n=1);Volumen (const Volumen& v);char* getTitulo(void);


char* getIsbn(void);int getNroEjemplares(void);virtual void mostrarDatos(void);void setDatos(char* t, char*i, int n);//seteo de los datos del libro~Volumen(void);

private:char* titulo;char* isbn;int nroejemplares;//cant.de ejemplares de cada volumen

};

Crear dos clases que deriven de Volumen: Libro y Revista. De la clase Libro (además de título e ISBN) interesa almacenar el autor y editorial del mismo. De la clase Revista interesa (además de título e ISBN) almacenar el año de publicación y número de la misma. Además deberá crear una clase Biblioteca como un array de punteros a Volumen de un máximo a determinar por el alumno (capacidad de almacenamiento de la biblioteca) añadir una función miembro para mostrar todos los volúmenes (libros y revistas) que tenga la biblioteca y otra bool añadirVolumen(Volumen* v); que añada el volumen a que apunta v (Libro o Revista) y retorne true si pudo añadir el volumen (aún no se alcanzó la capacidad máxima de la biblioteca) y false en caso contrario.Cree una aplicación Prueba con una función main() que cree algunos libros y revistas (como punteros a Volumen) y los añada en una Biblioteca previamente creada. Mostrar los datos de los volúmenes disponibles en dicha Biblioteca.

Solución://Volumen.h#pragma onceclass Volumen{public:

Volumen(char* t="", char* i="", int n=1);Volumen (const Volumen& v);char* getTitulo(void);char* getIsbn(void);int getNroEjemplares(void);virtual void mostrarDatos(void);void setDatos(char* t, char*i, int n);~Volumen(void);

private:char* titulo;char* isbn;int nroejemplares;

};//Volumen.cpp#include "Volumen.h"#include <iostream>using std::cout;Volumen::Volumen(char* t, char* i, int n)//ojo ocurre efecto division en porciones (12.2.3){

titulo=new char[strlen(t)+1];strcpy_s(titulo, strlen(t)+1,t);isbn=new char[strlen(i)+1];strcpy_s(isbn, strlen(i)+1,i);nroejemplares=n;


}Volumen::Volumen(const Volumen& v){

titulo=new char[strlen(v.titulo)+1];strcpy_s(titulo, strlen(v.titulo)+1,v.titulo);isbn=new char[strlen(v.isbn)+1];strcpy_s(isbn, strlen(v.isbn)+1,v.isbn);nroejemplares=v.nroejemplares;cout<<"Se llama al constructor por copia de Volumen";

}char* Volumen::getTitulo(void){

return titulo;}char* Volumen::getIsbn(void){

return isbn;}void Volumen::mostrarDatos(void){

cout<<"El título del volumen es: "<<titulo<< " y el ISBN: "<<isbn<<"\n";

}int Volumen::getNroEjemplares(void){

return nroejemplares;}void Volumen::setDatos(char* t, char* i, int n){

titulo=new char[strlen(t)+1];strcpy_s(titulo, strlen(t)+1,t);isbn=new char[strlen(i)+1];strcpy_s(isbn, strlen(i)+1,i);nroejemplares=n;

}Volumen::~Volumen(void){}//Revista.h

#pragma once#include "volumen.h"class Revista :

public Volumen{public:

Revista(char* t="", char* i="", int a=0, int nror=0, int n=1);int getaño(void);int getnrorevista(void);virtual void mostrarDatos(void);void setDatos(char* t, char* i, int a, int nror, int n);~Revista(void);

private:int año;int nrorevista;};

//Revista.cpp#include "Revista.h"#include <iostream>using std::cout;


Revista::Revista(char* t, char* i, int a, int nror, int n):Volumen(t,i,n){

año=a;nrorevista=nror;

}int Revista::getaño(void){

return año;}int Revista::getnrorevista(void){

return nrorevista;}void Revista::mostrarDatos(void){

Volumen::mostrarDatos();cout<<"El año de la revista es: "<<año<< ", el numero es: "<<nrorevista

<<" y la cantidad de ejemplares que hay es: "<<getNroEjemplares()<<"\n";

}void Revista::setDatos(char* t, char* i, int a, int nror, int n){

Volumen::setDatos(t,i,n);año=a;nrorevista=nror;

}Revista::~Revista(void){}//Libro.h#pragma once#include "volumen.h"class Libro :

public Volumen{public:

Libro(char* t="", char* i="", char* a="", char* e="",int n=1);Libro(const Libro& otro);char* getautor();char* geteditorial();virtual void mostrarDatos(void);void setDatos(char* t, char* i, char* a, char* e,int n);~Libro(void);

private:char* autor;char* editorial;

};//Libro.cpp#include "Libro.h"#include <iostream>using std::cout;

Libro::Libro(char* t, char* i, char* a, char* e,int n):Volumen(t,i,n){

autor=new char[strlen(a)+1];strcpy_s(autor, strlen(a)+1,a);editorial=new char[strlen(e)+1];strcpy_s(editorial, strlen(e)+1,e);


}Libro::Libro(const Libro& l):Volumen(l){

autor=new char[strlen(l.autor)+1];strcpy_s(autor, strlen(l.autor)+1,l.autor);editorial=new char[strlen(l.editorial)+1];strcpy_s(editorial, strlen(l.editorial)+1,l.editorial);cout<<"Se llama al constructor por copia de Libro";

}char* Libro::getautor(void){

return autor;}char* Libro::geteditorial(void){

return editorial;}void Libro::mostrarDatos(void){

Volumen::mostrarDatos();cout<<"El autor del libro es: "<<autor<< ", la editorial: "<<editorial<<" y la

cantidad de volúmenes: "<<getNroEjemplares()<<"\n";

}void Libro::setDatos(char* t, char* i, char* a, char* e,int n){

Volumen::setDatos(t,i,n);autor=new char[strlen(a)+1];strcpy_s(autor, strlen(a)+1,a);editorial=new char[strlen(e)+1];strcpy_s(editorial, strlen(e)+1,e);

}

Libro::~Libro(void){}//Biblioteca.h#pragma once#include "volumen.h"class Biblioteca{public:

Biblioteca(void);void mostrarDatos(void);bool añadirVolumen(Volumen* v); ~Biblioteca(void);

private:static const int MAX=100;Volumen* volumenes[MAX];int i;

};//Biblioteca.cpp#include "Biblioteca.h"

Biblioteca::Biblioteca(void){

i=0;}


void Biblioteca::mostrarDatos(void){

for(int j=0;j<i;j++)volumenes[j]->mostrarDatos();

}bool Biblioteca::añadirVolumen(Volumen* v){

bool agregado=false;if(i<MAX){

volumenes[i]=v;i++;//queda apuntando al siguienteagregado=true;

}return agregado;

}

Biblioteca::~Biblioteca(void){}//Biblioteca.cpp#include <iostream>#include "Biblioteca.h"#include "Revista.h"#include "Libro.h"using std::cout;using std::endl;

int main(){

Libro l("Programacion en lenguajes estructurados", "970-15-1165-4","Ma.Asuncion Criado Clavero", "Alfaomega", 1);

Revista r("Lugares", "9788435061599", 2011,189,2);Biblioteca b;b.añadirVolumen(&l);b.añadirVolumen(&r);b.mostrarDatos();return 0;

}

Problema 22

Un tren de carga lleva dos clases de vagones: VagonCaja que tienen forma de prisma rectangular y VagonTanque que tienen forma cilíndrica. Deberá diseñar tres clases para representar vagones de tren, una clase base (Vagon) abstracta con un dato miembro que represente la longitud de los vagones y dos clases derivadas (VagonCaja y VagonTanque) para representar los dos tipos de vagones. Para el vagón de tipo VagonCaja deberá almacenar su alto, ancho (aparte de la longitud). Para el vagón de tipo VagonTanque deberá almacenar su radio (aparte de su longitud). Las tres clases deben poseer un método volumen() que retorna un valor de tipo double que representa la capacidad en metros cúbicos del vagón. Parte de su trabajo será decidir si el método volumen() en cada una de las clases es declarado abstracto o no. Recordar que el volumen de un prisma rectangular es: alto * ancho * longitud y el del cilindro es PI * r2 * longitud.


Cree una clase Tren que represente a un tren de carga con sus vagones. Utilice un array de punteros de tipo Vagon. La clase debe tener una función miembro bool añadirVagon(Vagon* v); que permita añadir un vagón de algún tipo al Tren (si es que no supera la cantidad de vagones límite del tren) y otra que retorne el volumen total del tren. Cree una aplicación de prueba que permita crear trenes y calcular la capacidad total de carga de cada tren.

Solución://Vagon.h#pragma onceclass Vagon{public:

Vagon(double l=1);virtual double volumen(void)=0;double getLongitud();~Vagon(void);

private:double longitud;

};//Vagon.cpp#include "Vagon.h"

Vagon::Vagon(double l){

longitud=l;}double Vagon::getLongitud(void){

return longitud;}Vagon::~Vagon(void){}//VagonCaja.h#pragma once#include "vagon.h"class VagonCaja :

public Vagon{public:

VagonCaja(double l=1, double an=1, double al=1);virtual double volumen(void);~VagonCaja(void);

private:double ancho;double alto;

};//VagonCaja.cpp#include "VagonCaja.h"

VagonCaja::VagonCaja(double l, double an, double al):Vagon(l){

ancho=an;


alto=al;}

double VagonCaja::volumen(void){

return alto*ancho*getLongitud();}

VagonCaja::~VagonCaja(void){}//VagonTanque.h#pragma once#include "Vagon.h"

class VagonTanque: public Vagon{public:

VagonTanque(double l=1, double r=1);virtual double volumen(void);~VagonTanque(void);

private:double radio;

};//VagonTanque.cpp#include "VagonTanque.h"#include <iostream>#define PI std::atan(1.0)*4

VagonTanque::VagonTanque(double l, double r):Vagon(l){

radio=r; }double VagonTanque::volumen(void){

return PI*radio*radio*getLongitud();}

VagonTanque::~VagonTanque(void){}#include "VagonTanque.h"#include <iostream>#define PI std::atan(1.0)*4

VagonTanque::VagonTanque(double l, double r):Vagon(l){

radio=r; }double VagonTanque::volumen(void){

return PI*radio*radio*getLongitud();}

VagonTanque::~VagonTanque(void){}


//Tren.h#pragma once#include "Vagon.h"class Tren{public:

Tren(int n);double volumenTotal(void);bool añadirVagon(Vagon* v);~Tren(void);

private:int nrovagones;int i;Vagon* vagones[100];

};//Tren.cpp#include "Tren.h"

Tren::Tren(int n){

nrovagones=n;i=0;

}bool Tren::añadirVagon(Vagon* v){

bool agregado=false;if(i<100){

vagones[i]=v;i++;agregado=true;

}return agregado;

}double Tren::volumenTotal(void){

double vt=0;for(int j=0;j<i;j++)

vt+=vagones[j]->volumen();return vt;

}Tren::~Tren(void){}//PruebaTren.cpp#include <iostream>#include "Tren.h"#include "VagonCaja.h"#include "VagonTanque.h"#define PI std::atan(1.0)*4using std::cout;

int main(){

Vagon *v1=new VagonCaja(1.0,1.0,PI);Vagon *v2=new VagonTanque();Tren t(2);t.añadirVagon(v1);t.añadirVagon(v2);cout<<"El volumen total transportado por el tren es: "<<t.volumenTotal()<<"\n";


return 0;}

Problema 23

Mi programa de actividades hogareñas diarias incluye una variedad de tareas tales como: tareas escolares, gimnasia y comidas. Se trata de modelar estas tareas usando clases en C++.Defina la clase base abstracta Tarea de acuerdo al siguiente archivo de cabecera:

#pragma onceclass Tarea{public:

Tarea(void);virtual double cuantoTiempo(void)=0;void setTiempo(double t);~Tarea(void);

private:double tiempo;

};

y defina las siguientes tres clases derivadas concretas:1) TareaEscolar que tiene un campo: el número de problemas a resolver.2) Gimnasia que tiene un campo: si estoy haciendo o no bicicleta fija.3) Comida que no tiene campos.

Debe definir además en cada clase un método cuantotiempo() , que retorne la cantidad de minutos que toma realizar una tarea:1) Una tarea escolar toma 10 minutos por problema.2) Gimnasia ocupa 60 minutos, más un extra de 20 minutos si estoy usando la bicicleta fija3) En comer ocupo siempre 30 minutos.Finalmente usando las definiciones de las 4 clases deberá crear un array de 5 punteros a Tareas en una funcion main() de una aplicación Prueba, donde calculará el tiempo necesario para realizar todas estas tareas y lo mostrará por pantalla

Problema 24

Dada la siguiente clase abstracta, cuyo archivo de cabecera es el siguiente:

#pragma onceclass Persona{public:

Persona(char* n, double e, double p);char* getNombre(void);double getEstatura(void);double getPeso(void);double IMC(void);virtual double pesoteorico(void)=0;virtual char* estadoOMS(void)=0;virtual void mostrardatos();


~Persona(void);private:

char* nombre;double estatura;double peso;

};

donde el Indice de Masa Corporal (IMC) se calcula dividiendo los kilogramos de peso por el cuadrado de la estatura en metros. Completar el archivo cpp de dicha claseY dados los siguientes archivos de cabecera (incompletos) de las clases derivadas: Hombre y Mujer (completarlo y lo mismo para los cpp correspondientes):

#pragma once#include "persona.h"class Hombre : public Persona{public:

Hombre(char* n, double e, double p, bool c);//completar

private:bool corpulento;

};#pragma once#include "persona.h"class Mujer : public Persona{public:

Mujer(char* n, double e, double p, int nh);//completar

private:int nrohijos;

};

Debe tenerse en cuenta que:a) El peso teórico se calcula como:• Mujeres: 50 kg para los primeros 1.5 m de altura más 2.5 kg por cada 2.5 cm adicionales, mas 0.65 Kg por un hijo ó 1.3 Kg por 2 hijos o mas. • Hombres: 53 kg para los primeros 1.5 m de altura más 3 kg para cada 2.5 cm adicionales, mas 10% si el hombre es corpulento.b) El Indice de Masa Corporal (IMC) da origen a la siguiente clasificación acorde a la OMS:• < 18,5: Peso Bajo (Indica delgadez, desnutrición o algún problema de salud) • hasta 24,9 (hombres) o 23,9 (mujeres). Peso normal (Está catalogado como saludable) • hasta 29.9 hombres ó 28.9 mujeres: Sobrepeso (u Obesidad leve) • hasta 40 hombres ó 37 mujeres: Obesidad grado 2.• > 40 hombres ó > 37 mujeres: Obesidad severa o grado 3.

El código a completar debe ser tal que haga compilar y ejecutar la siguiente aplicación:

#include "Hombre.h"#include "Mujer.h"#include <iostream>using std::cout;


int main(void){Persona* personas[4];personas[0]=new Hombre("Javier",1.75,83.0,false);personas[1]=new Mujer("Marisa",1.80,72.0,0);personas[2]=new Hombre("Juan",1.70,92.0,false);personas[3]=new Hombre("Pedro",1.95,110.0,true);for(int i=0;i<4;i++)

personas[i]->mostrardatos();return 0;

}

Solución://Persona.h#pragma onceclass Persona{public:

Persona(char* n, double e, double p);char* getNombre(void);double getEstatura(void);double getPeso(void);double IMC(void);virtual double pesoteorico(void)=0;virtual char* estadoOMS(void)=0;virtual void mostrardatos();~Persona(void);

private:char* nombre;double estatura;double peso;

};//Persona.cpp#include "Persona.h"#include <iostream>using std::cout;

Persona::Persona(char* n, double e, double p){

nombre=new char[strlen(n)+1];strcpy_s(nombre, strlen(n)+1,n);estatura=e;peso=p;

}char* Persona::getNombre(void){

return nombre;}double Persona::getEstatura(void){

return estatura;}double Persona::getPeso(void){

return peso;}double Persona::IMC(void){


return peso/(estatura*estatura);}

void Persona::mostrardatos(void){cout<<"Nombre: "<<nombre<<", Estatura: "<<estatura<<", Peso: "<<peso<<"\n"<<

"Peso teórico: "<<pesoteorico()<<", Indice de masa muscular: "<<IMC()<<", Estado según OMS: "

<<estadoOMS()<<"\n";}

Persona::~Persona(void){}//Mujer.h#pragma once#include "persona.h"class Mujer :

public Persona{public:

Mujer(char* n, double e, double p, int nh);virtual double pesoteorico(void);virtual char* estadoOMS(void);virtual void mostrardatos(void);~Mujer(void);

private:int nrohijos;

};

//Mujer.cpp#include "Mujer.h"#include <iostream>using std::cout;

Mujer::Mujer(char* n, double e, double p, int nh):Persona(n, e, p){

nrohijos=nh;}double Mujer::pesoteorico(void){

double pt=0;double pt1=(getEstatura()-1.5)/0.025;if(getEstatura()<=1.5)

pt=50;else

pt=50+pt1*2.5;if(nrohijos==1)

pt+=0.65;else if(nrohijos>1)

pt+=1.3;return pt;

}char* Mujer::estadoOMS(void){

double imc=IMC();if(imc<18.5)

return "Peso bajo";else if(imc<=23.9)

return "Peso normal";else if(imc<=28.9)


return "Sobrepeso";else if(imc<=37)

return "Obesidad grado 2";else

return "Obesidad severa o grado 3";}void Mujer::mostrardatos(void){

Persona::mostrardatos();cout<<"Nro. de hijos: "<<nrohijos<<"\n";

}

Mujer::~Mujer(void){}//Hombre.h#pragma once#include "persona.h"class Hombre : public Persona{public:

Hombre(char* n, double e, double p, bool c);virtual double pesoteorico(void);virtual char* estadoOMS(void);virtual void mostrardatos(void);~Hombre(void);

private:bool corpulento;

};

#include "Hombre.h"#include <iostream>using std::cout;

Hombre::Hombre(char* n, double e, double p, bool c):Persona(n,e,p){ corpulento=c;}double Hombre::pesoteorico(void){double pt=0;

double pt1=(getEstatura()-1.5)/0.025;if(getEstatura()<=1.5)

pt=53;else

pt=50+pt1*3;if(corpulento==true)

pt*=1.1;return pt;

}char* Hombre::estadoOMS(void){

double imc=IMC();if(imc<18.5)

return "Peso bajo";else if(imc<=24.9)

return "Peso normal";else if(imc<=29.9)

return "Sobrepeso";else if(imc<=40)

return "Obesidad grado 2";


elsereturn "Obesidad severa o grado 3";

}

void Hombre::mostrardatos(void){

Persona::mostrardatos();cout<<"Es corpulento?: "<<corpulento<<"\n";

}

Hombre::~Hombre(void){}//PruebaPersona.cpp#include "Hombre.h"#include "Mujer.h"#include <iostream>using std::cout;

int main(void){

Persona* personas[4];personas[0]=new Hombre("Javier",1.75,83.0,false);personas[1]=new Mujer("Marisa",1.80,72.0,0);personas[2]=new Hombre("Juan",1.70,92.0,false);personas[3]=new Hombre("Pedro",1.95,110.0,true);for(int i=0;i<4;i++)

personas[i]->mostrardatos();return 0;

}

Problema 25

Cree las siguientes clases:Vehiculo (una clase abstracta)• Vehículo tiene un constructor que se usa para determinar dos propiedades: nombre (cadena de caracteres) y precio (double).• Cree dos funciones miembros de acceso para retornar cada una de las propiedades mencionadas.• Cree una función miembro que permita modificar el nombre del vehículo.• Cree un método abstracto: calcularTasa() que retorne un valor que indique el monto de un impuesto anual sobre el vehículo.Camion (una clase concreta)• El constructor invoca al de la clase base para establecer el valor de las propiedades nombre y precio. El constructor de Camion acepta nombre y precio como parámetro.• Camion tiene una propiedad nroRuedas (entero). Cree funciones miembros de acceso y modificación de esta propiedad.• calcularTasa() calculará el impuesto multiplicando el número de ruedas del camión por 100.• Camion tiene una función miembro static: int numeroCamiones() que retorna un número que indica cuántas instancias de tipo Camion se han creado en un programa. Declare cualquier variable que necesite para ello y asegúrese que la clase actualice esta variable cuando sea necesario.


Aeroplano (una clase concreta)• El constructor llama al de la clase base para establecer el valor de las propiedades nombre y precio. El constructor de Aeroplano acepta nombre y precio como parámetros.• Aeroplano tiene una propiedad nroAsientos (entero). Cree funciones miembros de acceso y modificación para esta propiedad.• calcularTasa() calcula la tasa multiplicando el número de asientos por 200.• Aeroplano tiene un método static: int numeroAeroplanos() que retorna un número que indica cuántas instancias de tipo Aeroplano se han creado en un programa. Declare cualquier variable que necesite para ello y asegúrese que la clase actualice esta variable cuando sea necesario.Cree una aplicación con una función main donde instancie objetos de tipo Camion y Aeroplano y escriba una línea de código donde muestre cómo invoca el método static nroCamiones() y muestre por pantalla el resultado de esta invocación.

Solución;//Vehiculo.h#pragma onceclass Vehiculo{public:

Vehiculo(char* n, double p);char* getNombre(void);double getPrecio(void);virtual double calcularTasa(void)=0;~Vehiculo(void);

private:char* nombre;double precio;

};//Vehiculo.cpp#include "Vehiculo.h"#include <iostream>

Vehiculo::Vehiculo(char* n, double p){

nombre=new char[strlen(n)+1];strcpy_s(nombre, strlen(n)+1,n); precio=p;

}char* Vehiculo::getNombre(void){

return nombre;}double Vehiculo::getPrecio(void){

return precio;}

Vehiculo::~Vehiculo(void){}//Camion.h#pragma once#include "vehiculo.h"


class Camion :public Vehiculo{

public:Camion(char* n, double p, int nror);virtual double calcularTasa(void);static int nroCamiones(void);~Camion(void);

private:int nroruedas;static int nrocamiones;

};//Camion.cpp#include "Camion.h"

Camion::Camion(char* n, double p, int nror):Vehiculo(n,p){

nroruedas=nror;nrocamiones++;

}double Camion::calcularTasa(void){

return 100*nroruedas;}int Camion::nroCamiones(void){

return nrocamiones;}Camion::~Camion(void){}int Camion::nrocamiones=0;//Aeroplano.h#pragma once#include "vehiculo.h"class Aeroplano :

public Vehiculo{public:

Aeroplano(char* n, double p, int nroa);virtual double calcularTasa(void);static int nroAeroplanos(void);

~Aeroplano(void);private:

int nroasientos;static int nroaeroplanos;

};//Aeroplano.cpp#include "Aeroplano.h"

Aeroplano::Aeroplano(char* n, double p, int nroa):Vehiculo(n,p){

nroasientos=nroa;nroaeroplanos++;

}double Aeroplano::calcularTasa(void){

return 200*nroasientos;


}int Aeroplano::nroAeroplanos(void){

return nroaeroplanos;}Aeroplano::~Aeroplano(void){}int Aeroplano::nroaeroplanos=0;//PruebaAviones.cpp#include <iostream>#include "Camion.h"#include "Aeroplano.h"using std::cout;

int main(void){

Camion c("Mercedes Benz", 123000,6);Camion d("Scania", 125000, 8);cout<<"El nro. de camiones creados es: "<<Camion::nroCamiones()<<"\n";return 0;

}

Problema 26

Dada la siguiente clase que representa una conexión a Internet brindada por algún proveedor de dicho servicio:

//ARCHIVO CABECERA Conexion.h#pragma onceclass Conexion{public:

Conexion(char* n, long b, double t);char* getNombreusuario(void);long getBytesacumulados(void);double getTiempoacumulado(void);virtual double pago(void)=0;void mostrar(void);//invoca a pago()~Conexion(void);

private:char * nombreusuario;

protected:long bytesacumulados;double tiempoacumulado;

};

//archivo Conexión.cpp#include "Conexion.h"#include <iostream>using std::cout;Conexion::Conexion(char* n, long b, double t){

nombreusuario=new char[strlen(n)+1];strcpy_s(nombreusuario, strlen(n)+1,n);bytesacumulados=b;tiempoacumulado=t;

}char* Conexion::getNombreusuario(void)


{return nombreusuario;

}

long Conexion::getBytesacumulados(void){return bytesacumulados;

}double Conexion::getTiempoacumulado(void){

return tiempoacumulado;}void Conexion::mostrar(void){ //completar con nombreusuario, bytesacumulados, tiempoacumulado e importe pagado }Conexion::~Conexion(void){}

Crear las clases BandaAncha y DialUp, derivadas de conexión. Agregar a BandaAncha como atributo una cadena de caracteres para indicar el tipo de conexión, la cual puede ser PREMIUM o STANDARD. Para DialUp añadir como atributo un entero que represente el número de teléfono autorizado a través del cual se realizará la conexión. Para calcular el monto mensual pagado por el usuario, debe tenerse en cuenta:Para conexiones de tipo dialup (discadas) el pago se calcula: -si se transfirieron mas de 100Mb: $50.- (no importa cuanto se transfirió) -si se transfirieron entre 50Mb y <100 Mb: $0,6 x Mb transferido -si se transfirieron menos de 50 Mb: $0,01 x minuto de usoPara conexiones de banda ancha el pago se calcula: -conexión PREMIUM: $120.- -conexión STANDARD: $0,3 x Mb(nota: para calcular por Mb divida los bytesacumulados por 1000000).Cree una aplicación de prueba de las distintas conexiones con una función main( ) y cree allí un array de punteros a las distintas conexiones inicializados con 2 conexiones de cada tipo. Muestre por pantalla los datos correspondientes a cada una de ellas.

Solución://Conexión.h#pragma onceclass Conexion{public:

Conexion(char* n, long b, double t);char* getNombreusuario(void);long getBytesacumulados(void);double getTiempoacumulado(void);virtual double pago(void)=0;void mostrar(void);//invoca a pago()~Conexion(void);

private:char * nombreusuario;

protected:long bytesacumulados;double tiempoacumulado;


};//Conexión.cpp#include "Conexion.h"#include <iostream>using std::cout;Conexion::Conexion(char* n, long b, double t){

nombreusuario=new char[strlen(n)+1];strcpy_s(nombreusuario, strlen(n)+1,n);bytesacumulados=b;tiempoacumulado=t;

}char* Conexion::getNombreusuario(void){

return nombreusuario;}long Conexion::getBytesacumulados(void){

return bytesacumulados;}double Conexion::getTiempoacumulado(void){

return tiempoacumulado;}void Conexion::mostrar(void){ cout<<"Nombre usuario: "<<nombreusuario<<", Bytes acumulados: "<<bytesacumulados<<

", Tiempo acumulado: "<<tiempoacumulado<<", Pago total"<<pago(); }Conexion::~Conexion(void){}//DialUp.h#pragma once#include "Conexion.h"class Dialup:public Conexion{public:

Dialup(char* n, long b, double t, int te);virtual double pago(void);~Dialup(void);

private:int telefonoAutorizado;

};//DialUp.cpp#include "Dialup.h"

Dialup::Dialup(char* n, long b, double t, int te):Conexion(n,b,t){

telefonoAutorizado=te;}double Dialup::pago(void){

if(bytesacumulados<50000000)return 0.01*tiempoacumulado;

else if(bytesacumulados<100000000) return 0.6*(bytesacumulados/1000000);

else return 50;}


Dialup::~Dialup(void){}//BandaAncha.h#pragma once#include "conexion.h"class BandaAncha :

public Conexion{public:

BandaAncha(char* n, long b, double t, char*ti);double pago(void);~BandaAncha(void);

private:char* tipo;

};//BandaAncha.cpp#include "BandaAncha.h"#include <iostream>

BandaAncha::BandaAncha(char* n, long b, double t, char*ti):Conexion(n,b,t){

tipo=new char[strlen(ti)+1];strcpy_s(tipo, strlen(ti)+1,n);

}double BandaAncha::pago(void){

if(strcmp(tipo,"PREMIUM")==0)return 120;

else //standardreturn 0.3*(bytesacumulados/1000000);

}

BandaAncha::~BandaAncha(void){}//completar la aplicación

Problema 27

Dada el siguiente archivo de cabecera de una clase que representa un acondicionador de aire:

#pragma onceclass LineaFrio{public:

LineaFrio(double f, double p, bool t, char* c);const double costoBasicoInstalacion=50;double getFrigorias(void);virtual double getConsumo(void)=0;double getPrecio(void);virtual double getCostoInstalacion(void)=0;bool getTieneControlRemoto(void);virtual void mostrar(void);//muestra frigorias, precio, consumo, costoinstalacion,

tienecontrolremoto, color~LineaFrio(void);


private:double frigorias;double precio;char* color;

protected:bool tienecontrolremoto; //false=NO, true=SIdouble consumo;double costoinstalacion;

};

y los archivos de cabecera, a completar (al igual que los archivos cpp asociados), correspondientes a dos clases concretas de acondicionadores de aire:

#pragma once#include "lineafrio.h"class AcondicionadorSplit :

public LineaFrio{public:

//añadir constructor//añadir métodos para que la clase sea concreta//mostrar datos LineaFrio y propios~AcondicionadorSplit(void);

private:double diametroAgujero;double costoMaterialesInstalacion;

};

#pragma once#include "lineafrio.h"class AcondicionadorDePared :

public LineaFrio{public:

//añadir constructor//añadir métodos para que la clase sea concreta//mostrar datos LineaFrio y propios~AcondicionadorDePared(void);

private:double altoAgujero;double anchoAgujero;

};

Tener en cuenta que el consumo de un equipo de pared se calcula como: 0.41 vatios por frigoría y el de un splits como: 0.45 vatios por frigoría. El costo de instalación final se calcula como el costo básico de instalación más los materiales que, en el caso particular de un equipo de pared son siempre de $30.-Crear una clase de prueba con una función main() donde define un array de punteros de tipo LineaFrio que deberá llenar con objetos de diferentes tipos concretos de la jerarquía de acondicionadores de aire, usando los constructores con los datos adecuados. Mostrar por pantalla los datos de todos los elementos de dicho array.


Documents

Práctica Nº 4 – Programación orientada a objetos en C++ · Informática II Práctica Nº 4 – Programación orientada a objetos en C++ Problema 1: Diseñe e implemente una clase