Practica 42012

Facultad de Ciencias Exactas, Ingeniería y Agrimensura
Departamento de Sistemas e Informática

Escuela 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.h
using 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);
Pág. 2
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));
}

Pág. 3
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á bien
string message = "Este punto esta: ";
if (equals(0, 0, 0)) // origen

message = "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(){
inta1 = 10, b1 = -5, c1 = 4; // para constructor
inta2 = 9, b2 = 8, c2 = -6; // para actualizar coordenadas
intshift1X = 3,
shift1Y = -3,
shift1Z = 7,
shift2X = 6,
shift2Y = 11,
shift2Z = -13;
// para mover
int low = 5, high = 15; // para constructor
int xBox = -12, yBox = 20, zBox = 8;
// borde superior izquierdo y delante de una caja
int width = 24, height = 40, depth = 35; // de la caja
int xCenterSphere = 1, yCenterSphere = 2, zCenterSphere = 5;
// centro de esfera

Pág. 4
int radius = 50; // radio de esfera
// declara referencia a puntos 3D

Point3D pt1, pt2(a1, b1, c1), pt3(low, high);
// imprime
cout << "Punto 1 es: (" << pt1.getX() << ", " << pt1.getY() << ", " << pt1.getZ() <<
")" << endl;
")" << endl;
")" << endl;
// imprime coordenadas de punto 3

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

pt2.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 pt2

pt1.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 pt2

pt1.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 origen

cout << "Distancia de pt3 al origen es: " << pt3.distanceOrigin() << endl;
// distancia pt1 - pt3
cout << "Distancia entre pt1 y pt3 es: " << pt1.distanceToPoint(pt3) << endl;
// producto escalar de vectores pt1 , pt2
cout << "Producto escalar de pt1, pt2 es: " << pt1.scalarProduct(pt2) << endl;
// en qué espacios están pt1, pt2, pt3?
cout << "Para pt1 --> " << pt1.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;

Pág. 5
// Imprimir todos los puntos
cout << endl << "Punto 1 es ( " << pt1.getX() << ", " << pt1.getY() << ", " <<
pt1.getZ() << ")" << endl;
pt2.getZ() << ")" << endl;
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 capacidad
void 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 once
class 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;
Pág. 6
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";
else
contenido=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

Pág. 7
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 array
char* 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;

Pág. 8
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){
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;

Pág. 9
cout<<"Se invoca al destructor de atleta\n";}
//archivo Carrera.h
#pragma once
class 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);
};

Pág. 10
//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
Carrera2::Carrera2(int d, int cantidad)

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

Pág. 11
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 <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";

Pág. 12
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;
}
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 inicializadores
Train(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;
}

Pág. 14
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
Pág. 15
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
Pág. 16
• 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 m 2 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 once
class Sala
{
private:
char* nombre;
int ancho;
int largo;
bool equipado;
Pág. 17
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)

{
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();
else
return 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";
}}

Pág. 18
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.
Pág. 19
Solución:
//Candado.h
#pragma once
class 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
{
if(programado[i]!=actual[i])
return false;
return true;
}
bool Candado::mismaCombinacionActual(const Candado &c)const
{
if(actual[i]!=c.actual[i])
return false;
return true;
}
Candado::~Candado(void)
{
}
//pruebaCandado.cpp
#include <iostream>
#include "Candado.h"
using std::cout;

Pág. 20
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

Pág. 21
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 once
class 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;
}

Pág. 22
//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 4
11 7 6 9
8 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.

Pág. 23
• 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 once
class EsONoMagica
{
public:
EsONoMagica(int **m, int f, int c);
bool esCuadrada()const;//true es cuadrada, false no es cuadrada
int 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 filas
matriz=new int*[f];

Pág. 24
//reservo memoria para las columnas de cada fila
for(int i=0;i<c;i++)
matriz[i]=new int[c];
//llena con datos
for(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;
suma+=matriz[i][i];
return suma;
}
int EsONoMagica::sumadiagsec()const
{
int suma=0;
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 matriz

Pág. 25
delete[]matriz[i];//libera columnas
delete[]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];
p[i]=new int[4];
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 once
class 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;};
Pág. 26
#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;
}

Pág. 27
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 "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);
}

Pág. 28
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>
using std::cout;
using std::endl;

Pág. 29
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 stack

void CStack::push(int i)
{
if (next < 99)
list[next++] = i;
}
// Pop a value off the stack

int CStack::pop()
{
return list[--next];
}
// Output the contents of the stack

void 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

Pág. 30
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>
using std::cout;
using std::endl;
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();
};
// Constructor
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);
}
}
}
// Copy constructor
CSimpleString::CSimpleString(const CSimpleString& s)
{
len = s.len;
strcpy_s(buff, len+1, s.buff);
}
// Destructor
CSimpleString::~CSimpleString()
{
delete buff;
}
// Assignment operator - does not deal with str = str

CSimpleString& CSimpleString::operator=(const CSimpleString& rhs)
{
len = rhs.len;
delete buff;

Pág. 31
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;
cout << "s2 = \"";

s2.print();
cout << "\"" << endl;
return 0;
}
Solución 14 b)
#include <iostream>
#include <cstring>
using std::cout;
using std::endl;
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();
};
Pág. 32
// Contructor - repeated given character
CSimpleString::CSimpleString(char c, int count) : len(0), buff(0)
{
len = count;
if (len > 0)
{
memset(buff, c, len);
buff[len] = '\0';
}
}
// Constructor - from an integer

CSimpleString::CSimpleString(int i) : len(0), buff(0)
{
char sTmp[20];
_itoa_s(i, sTmp, 20, 10);
len = strlen(sTmp);
if (len > 0)
{
strcpy_s(buff, len+1, sTmp);
}
}
// Constructor
{
if (p != 0)
{
len = strlen(p);
if (len > 0)
{
}
}
}
// Copy constructor
{
len = s.len;
}
// Destructor
{
delete buff;
}
// Assignment operator - does not deal with str = str

{
len = rhs.len;
delete buff;

Pág. 33
return *this;
}
{
cout << buff;
}
int main()
{
CSimpleString s2;
s2 = s1;
CSimpleString marker = CSimpleString('*', 30);
marker.print();
cout << endl;
cout << "s1 = \"";

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

s2.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>
using std::cout;
using std::endl;
class CSimpleString{
private:
size_t len;
char* buff;
Pág. 34
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)
{
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)
{
strcpy_s(buff, len+1, sTmp);
}
}

{
if (p != 0)
{
len = strlen(p);
if (len > 0)
{
}
}
}
{
len = s.len;
}

Pág. 35
{
delete buff;
}
// Assignment operator - does deal with str = str

{
if (&rhs != this)
{
len = rhs.len;
delete buff;
}
return *this;
}
// Addition operator: add two CSimpleString objects

CSimpleString 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 constant

CSimpleString CSimpleString::operator+(const char* s)
{
return *this + CSimpleString(s);
}
// += operator
CSimpleString& CSimpleString::operator+=(const CSimpleString& rhs)
{
*this = *this + rhs;
return *this;
}
{
cout << buff;
}
int main()
{
CSimpleString s2;
s2 = s1;
CSimpleString marker = CSimpleString('*', 30);
marker.print();
cout << endl;
cout << "s1 = \"";

s1.print();

Pág. 36
cout << "\"" << endl;
cout << "s2 = \"";

s2.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;
};
Pág. 37
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:

Pág. 38
#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 once
class 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);
}

Pág. 39
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();
~AvionHidrante(void);
private:
int litrosAgua;
int capacidad;
};
//AvionHidrante.cpp
#include <iostream>
using std::cout;
AvionHidrante::AvionHidrante(char* nv, char* d, int c):Avion(nv, d)

{
capacidad=c;
litrosAgua=c;
}

Pág. 40
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);
~AvionPasajeros(void);
private:
int duracionVuelo; //en minutos
double pesoEquipaje;
};
//AvionPasajeros.cpp
#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ódigo
cout<<"La duracion del mismo: "<<duracionVuelo<<" minutos, con capacidad maxima
para equipaje: "<<
pesoEquipaje<<"\n";
}
AvionPasajeros::~AvionPasajeros(void)
{
}
//pruebaAvion.cpp
#include <iostream>
using std::cout;

Pág. 41
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 once
class Figura
{
public:
virtual double area(void)=0;//funcion virtual pura
virtual void mostrar(void)=0;//muestra datos de las figuras
bool 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 once
class 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();}

Pág. 42
//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 <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);
~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;}

Pág. 43
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);
~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"
using std::cout;
int main(void)
{
Figura* p1=new Triangulo(1,2);
Figura* p2=new Rectangulo(2,1);

Pág. 44
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 once
class OperacionBinaria
{
public:
OperacionBinaria(double op1, double op2);
virtual double opera()=0;//retorna resultado operación binaria
double getOpera1(void);//retorna operando 1
double getOpera2(void);//retorna operando 2
void 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};
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.
Pág. 45
Solución:
//OperaciónBinaria.h
#pragma once
class 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)

{
}

Pág. 46
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 :

Pág. 47
public Producto{
public:
Division(double op1, double op2);
~Division(void);
};
//Division.cpp
Division::Division(double op1, double op2):Producto(op1, (1/op2))

{
}
Division::~Division(void)
{
}
//Matematicas.cpp
#include <iostream>
#include "Resta.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};
v[i]->mostrar();
return 0;
}
Problema 20
Dado el archivo de cabecera de la clase abstracta Compuerta:

#pragma once
class Compuerta
{
public:
Compuerta(int nro);
int getNroentradas(void);//retorna nro.entradas
int getEntradaNro(int nro);//retorna la entrada nro.
void setEntradaNro(int nro, int val);//cambia la entrada nro con val
virtual int eval(void)=0;//evalua la salida de la compuerta
static 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 compuerta
int* entradas;//vector con los valores presentes en todas las entradas de la compuerta
};
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 once
class 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
Pág. 49
#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 once
class Volumen
{
public:
Volumen(char* t="", char* i="", int n=1);
Volumen (const Volumen& v);
char* getTitulo(void);
Pág. 50
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 once
class Volumen
{
public:
Volumen(char* t="", char* i="", int n=1);
Volumen (const Volumen& v);
char* getTitulo(void);
char* getIsbn(void);
int getNroEjemplares(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;
Pág. 51
}
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);
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;
Pág. 52
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
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();
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);
Pág. 53
}
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
class Biblioteca
{
public:
Biblioteca(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;
}
Pág. 54
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 siguiente
agregado=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.

Pág. 55
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 once
class 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;
Pág. 56
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 <iostream>
VagonTanque::VagonTanque(double l, double r):Vagon(l)

{
radio=r;
}
double VagonTanque::volumen(void)
{
return PI*radio*radio*getLongitud();
}
VagonTanque::~VagonTanque(void)
{
}
Pág. 57
//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"
using 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";
Pág. 58
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 once
class 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
fija
3) 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 once
class 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();
Pág. 59
~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 clase
Y 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
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;
Pág. 60
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);
personas[i]->mostrardatos();
return 0;
}
Solución:
//Persona.h
#pragma once
class Persona
{
public:
Persona(char* n, double e, double p);
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)
{
Pág. 61
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
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)
Pág. 62
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
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";
Pág. 63
else
return "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);
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.

Pág. 64
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 once
class Vehiculo
{
public:
Vehiculo(char* n, double p);
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"

Pág. 65
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;
Pág. 66
}
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 once
class 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)
Pág. 67
{
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 uso
Para 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 once
class 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;

Pág. 68
};
//Conexión.cpp
#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
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;
}
Pág. 69
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 //standard
return 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 once
class 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);
Pág. 70
private:
double frigorias;
double precio;
char* color;
protected:
bool tienecontrolremoto; //false=NO, true=SI
double 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.

Pág. 71

Practica 42012

Cargado por

Copyright:

Formatos disponibles

Practica 42012

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Practica 42012

Cargado por

Copyright:

Formatos disponibles

Facultad de Ciencias Exactas, Ingeniería y Agrimensura

Departamento de Sistemas e Informática

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

Acceso y actualización: (6 en total)

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

int getX() const;

void setX (int tx);

//string toString() const;

Point3D::Point3D (int low, int high) {

int Point3D::getX() const { return x; }

void Point3D::setX (int tx) { x = tx; }

bool Point3D::equals(Point3D q) const {

bool Point3D::equals(int x1, int y1, int z1) const {

void Point3D::shiftX(int tx) { x += tx; }

double Point3D::distanceOrigin() const {

double Point3D::distanceToPoint(Point3D q) const {

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

string Point3D::whichSpace() const { // 8 'espacios': left/right, up/low, far/back

if (equals(0, 0, 0)) // origen

bool Point3D::inBox (int xbox, int ybox, int zbox,

bool Point3D::inSphere(Point3D center, int radius) const {

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

// declara referencia a puntos 3D

// imprime coordenadas de punto 3

// cambia coordenadas de pt2

// mueve pt1 y chequea si es igual a pt2

// mueve pt1 de nuevo y chequea si es igual a pt2

// distancia de pt3 al origen

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

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

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

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

d) Ahora deseamos registrar la información de todos los participantes en la carrera,

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

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

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

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

Atleta * Carrera1::getGanador(void) const

Carrera2::Carrera2(int d, int cantidad)

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

int Carrera2::getCantAtletas(void) const

Atleta* Carrera2::getGanador(void) const

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

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

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

Desarrolle la clase Persona para que la siguiente funcióm main funcione

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

Use los principios de programación orientada a objetos (en especial el encapsulamiento)

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

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

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

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

Un polinomio es una expresión matemática en forma de suma de potencias de una o más

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

3x3 – 1.5x2 + 3.3x1 – 20x0

si se invoca el método calcular pasándole como argumento el entero 2, deberá retornar un

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

303 – 1.502 + 3.30 – 200 +0= -2.0

313 – 1.512 + 3.31 – 210 +0= 2.8

323 – 1.522 + 3.32 – 220+0 = 22.6