Prácticas de C++

Prácticas de C++
Practica Nº 4
Informática II
Fundamentos de Programación
Prof. Dr. Paul Bustamante
Practica Nº 4 Programación en C++
Pág. 1
ÍNDICE
ÍNDICE ........................................................................................................................................ 1
1. Introducción...................................................................................................................... 1
1.1
Ejercicio 1: Mi Primera clase complejo ..................................................................... 1
1.2
Ejercicio 2: Modificar la clase complejo.................................................................... 3
1.3
Ejercicio 3: La clase Fracción .................................................................................... 3
1.4
Ejercicio 4: La clase cuenta_corriente ....................................................................... 4
1. Introducción.
En esta práctica empezará a utilizar las clases, a crear nuevos objetos, a entender la
encapsulación y abstracción de datos, es decir, todo lo relacionado con la Programación
Orientada a Objetos.
Recuerde que siempre hay más ejercicios que los que puede hacer en dos horas de
práctica. Hay que evitar copiar los ejercicios de otra persona, principalmente porque así no se
aprende a programar: a programar sólo se aprende programando.
1.1 Ejercicio 1: Mi Primera clase complejo
En la clase de esta semana y en la anterior, se ha explicado la clase complejo, que permite
trabajar con números complejos como si fuesen un tipo de variables más de C++, de modo
análogo a int, long, double, etc..
Este proyecto se llamará Ejer1. Debe crear tres ficheros complejo.h, complejo.cpp y
main.cpp. Estos ficheros se listan a continuación:
// fichero complejo.h
#include <iostream.h>
class complejo
{
private:
double real;
double imag;
public:
// Constructores
complejo();
//defecto
complejo(double, double im=0.0);
// SetThings
void SetData(void);
void SetReal(double);
void SetImag(double);
// GetThings
double GetReal(void){return real;}
double GetImag(void){return imag;}
//Operaciones
complejo Suma(complejo c);
complejo Resta(complejo c);
complejo Multiplica(complejo c);
complejo Cociente(complejo c);
//Salida
void Prt(){ cout << "("<< real <<","<< imag<<"i)"<<endl; }
};
// fichero complejo.cpp
// funciones y operadores de la clase complejo
#include "complejo.h"
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Practica Nº 4 Programación en C++
complejo::complejo() // constructor por defecto
{
real = 0.0;
imag = 0.0;
}
// constructor general
complejo::complejo(double re,double im)
{
real = re;
imag = im;
}
// función miembro SetData()
void complejo::SetData(void)
{
cout << "Parte real: ";
cin >> real;
cout << "Parte imaginaria: ";
cin >> imag;
}
void complejo::SetReal(double re)
{
real = re;
}
void complejo::SetImag(double im)
{
imag = im;
}
complejo complejo::Suma(complejo c)
{
complejo cs;
cs.real = real + c.real;
cs.imag = imag + c.imag;
return cs;
}
complejo complejo::Resta(complejo c)
{
complejo cr;
//escribir el código para restar
return cr;
}
complejo complejo::Multiplica(complejo c)
{
complejo cm;
//escribir el código (a,b) * (c,d) = (ac-bd, ad+bc)
return cm;
}
complejo complejo::Cociente(complejo c)
{
complejo cc;
//escribir (a,b)/(c,d) = ((ac+bd)/(c^2+d^2) , (bc-ad)/(c^2 + d^2 ))
return cc;
}
//fichero main.cpp
#include "complejo.h"
void main(void)
{
// declaración de números complejos
complejo c1(1.0, 1.0);
complejo c2(2.0, 2.0);
complejo c3;
c3.SetData();
//pide datos para c3
complejo c4(4.0);
// operadores aritméticos
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Pág. 2
Practica Nº 4 Programación en C++
complejo
complejo
complejo
complejo
cout
cout
cout
cout
cout
cout
cout
}
<<
<<
<<
<<
<<
<<
<<
suma = c1.Suma(c2);
resta = c1.Resta(c3);
producto = c2.Multiplica(c4);
cociente = c1.Cociente(c3);
Pág. 3
//c1+c2
//c1-c3
//c2*c4
//c1/c3
"Primer complejo: "; c1.Prt();
"Segundo complejo: ";c2.Prt();
"Tercer complejo: "; c3.Prt();
"Suma: " ;
suma.Prt();
"Resta: " ;
resta.Prt();
"Producto: " ; producto.Prt();
"Cociente: " ; cociente.Prt();
cout << "Ya he terminado." << endl;
Compile el proyecto y ejecútelo, observando el resultado. Cree algunos números
complejos más en el programa principal, opere con ellos y escriba el resultado.
1.2 Ejercicio 2: Modificar la clase complejo.
Cree un nuevo proyecto llamado Ejer2 en su directorio de trabajo. Copie en este directorio los
ficheros fuente del Ejercicio 1, complejo.h, complejo.cpp y main.cpp. Cambie el nombre a
estos ficheros llamándolos complejo2.h, complejo2.cpp y main2.cpp.
Ahora deberá modificar esos ficheros para que cumplan los siguientes objetivos:
1. Crear una función miembro llamada modulo() que permita calcular el módulo del
objeto complejo que sea su argumento implícito. Se utilizará por ejemplo en la
forma:
complejo a(3.0, 2.0);
cout << "El modulo de ";
a.Prt();
cout<<" es "<<a.modulo()<< endl;
2. Crear una función friend (ver transparencia No.15 de clase) llamada también
modulo() que permita calcular el módulo del objeto complejo que sea su argumento
explícito. Se utilizará por ejemplo en la forma:
complejo b(2.5, -1.0);
cout << "El modulo de ";
b.Prt();
cout<<" es "<<modulo(b)<< endl;
Modifique el programa main2.cpp de modo que utilice las dos funciones modulo(). Este
es un buen ejemplo de las posibilidades de C++ de cara a definir nuevos tipos de datos.
Recuerde que ahora debe incluir el fichero “complejo2.h” en main2.cpp.
1.3 Ejercicio 3: La clase Fracción
En este ejercicio va a crear la clase Fraccion, que permite trabajar con fracciones como si
fuesen un tipo de variables más de C++, de modo análogo a int, long, double, etc.
La clase Fraccion debe tener dos variables miembro tipo private: long num, den; las cuales
nos servirán para almacenar el numerador y el denominador de la fracción. Debe crear los
constructores y escribir las funciones miembro adecuadas para que le permitan escribir el
siguiente programa:
//fichero main.cpp
#include "fraccion.h"
void main(void)
{
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Practica Nº 4 Programación en C++
// declaración de fracciones
Fraccion f1(1, 4);
// Representa
Fraccion f2(1, 2);
// Representa
Fraccion f3;
// Representa
Fraccion f4(4);
// Representa
Pág. 4
1/4
1/2
0/1
4/1
// oporaciones aritméticos
Fraccion suma = f1.Suma(f2);
Fraccion resta = f1.Resta(f3);
Fraccion producto = f1.Multiplica(f4);
Fraccion cociente = f1.Divide(f2);
cout
cout
cout
cout
cout
cout
}
<<
<<
<<
<<
<<
<<
"Primera fracción: " ; f1.Prt();
"Segunda fracción: " ; f2.Prt();
"Suma: "
<< suma.Prt();
"Resta: "
<< resta.Prt();
"Producto: "
<< producto.Prt();
"Cociente: "
<< cociente.Prt();
cout << "Ya he terminado." << endl;
Debe crear un nuevo proyecto Ejer3 y los ficheros Fraccion.h, Fraccion.cpp y
main.cpp. Recuerde que los dos primeros son para la clase Fraccion y main.cpp es para el
programa principal.
1.4 Ejercicio 4: La clase cuenta_corriente
Con este ejercicio se pretende que el alumno se familiarice con las clases de C++. Cree un
nuevo proyecto llamado Ejer4 dentro de su directorio de trabajo. Los ficheros de partida de
este ejercicio son: cuenta.h, cuenta.cpp y bancoT.cpp (donde estará main).
// Fichero cuenta.h
class cuenta_corriente {
private:
// declaración de variables miembro -privadas, por defectodouble saldo;
// saldo actual de la cuenta
double interes;
// interes en tanto por 1
public:
// declaración de funciones miembro
// constructor de la clase
cuenta_corriente(double inicio, double int100);
void
deposito(double cantidad);
// hacer un deposito
double pago(double cantidad);
// hacer pago (si se puede)
void
abono_interes();
// abonar intereses
double obtener_saldo();
// preguntar el saldo
// transferencia de objeto implícito a objeto “destino”
double transfer(cuenta_corriente& destino, double cantidad);
};
// Fichero cuenta.cpp
// Definición de las funciones de la clase cuenta_corriente
#include <iostream.h>
// se incluye la declaración de cuenta_corriente
#include "cuenta.h"
// funcion round() para redondear céntimos.
//
No es función miembro
double round(double cantidad);
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Practica Nº 4 Programación en C++
// Constructor de la clase:
// Abrir cuenta con saldo e interés en %
cuenta_corriente::cuenta_corriente(double inicio, double int100)
{
saldo
= inicio;
interes = int100/100.0;
}
// Depositar cantidad en cuenta.
// No se chequea si el valor es positivo
void cuenta_corriente::deposito(double cantidad)
{
saldo += cantidad;
}
// Función para retirar cantidad.
// Se devuelve cantidad o cero (si no hay saldo)
double cuenta_corriente::pago(double cantidad)
{
// Si hay saldo suficiente
if(cantidad <= saldo) {
saldo -= cantidad;
return cantidad;
}
// No hay saldo suficiente
else
return 0.0;
}
// Función para calcular interés y sumarlo
void cuenta_corriente::abono_interes()
{
// cálculo del interés
double intereses = round(saldo * interes);
// se incrementa el saldo
saldo += intereses;
}
// Preguntar el saldo
double cuenta_corriente::obtener_saldo()
{
// de devuelve el valor del saldo
return saldo;
}
// Función para hacer una trasferencia.
//
El objeto origen es el argumento implícito.
//
El objeto destino es el argumento explícito
double cuenta_corriente::transfer(cuenta_corriente& destino, double
cantidad)
{
// Se accede directamente a la variable saldo
//
del objeto origen. Para acceder a saldo de
//
destino se utiliza el operador punto.
if (saldo < cantidad)
return 0.0;
saldo -= cantidad;
destino.saldo += cantidad;
return cantidad;
}
// Función para redondear los céntimos
// No es función miembro
double round(double cantidad)
{
long centimos = long(100.0 * cantidad + 0.5);
return double(centimos)/100.0;
}
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Pág. 5
Practica Nº 4 Programación en C++
// Fichero bancoT.cpp
// Calcular el saldo en una cuenta bancaria
#include <iostream.h>
#include "cuenta.h"
void main(void)
{
// Obtener los datos del usuario
double saldo;
// Se leen las variables del programa
// Datos para el objeto mi_cuenta
cout << "Teclee los datos de mi_cuenta: " << endl;
cout << "Saldo inicial: ";
cin >> saldo;
// llamada al constructor.
// Se crea un objeto de la clase cuenta_corriente
//
con nombre mi_cuenta
// Se le pasa un interés mensual cualquiera
cuenta_corriente mi_cuenta(saldo, 1.0);
// Datos para el objeto su_cuenta
cout << "\nTeclee los datos de su_cuenta: " << endl;
cout << "Saldo inicial: ";
cin >> saldo;
// llamada al constructor.
// Se crea un objeto de la clase cuenta_corriente
//
con nombre su_cuenta
// Se le pasa un interés mensual cualquiera
cuenta_corriente su_cuenta(saldo, 1.0);
// Transferencia
int tr = 1;
double cantidad = 0.0;
while (tr==1) {
cout << "\nTeclee los datos de la transferencia"
<< "\n1. de mi_cuenta a su_cuenta"
<< "\n2. de su_cuenta a mi_cuenta" << endl;
cin >> tr;
cout << "\nTeclee la cantidad: " << flush;
cin >> cantidad;
cout << "\nLos saldos antes de la transferencia son:"
<< "\n En mi_cuenta: " << mi_cuenta.obtener_saldo()
<< "\n En su_cuenta: " << su_cuenta.obtener_saldo()
<< endl;
if (tr==1) {
// mi_cuenta se pasa como argumento implícito
// su_cuenta se pasa como argumento explícito
if (mi_cuenta.transfer(su_cuenta, cantidad)==0.0)
cout << "\nSaldo insuficiente en mi_cuenta"
<< endl;
}
else if (tr==2) {
if (su_cuenta.transfer(mi_cuenta, cantidad)==0.0)
cout << "\nSaldo insuficiente en su_cuenta"
<< endl;
}
else
cout << "\nTransferencia mal definida: "
<< "Teclee de nuevo." << endl;
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Pág. 6
Practica Nº 4 Programación en C++
Pág. 7
cout << "\nLos saldos tras la transferencia son:"
<< "\n En mi_cuenta: " << mi_cuenta.obtener_saldo()
<< "\n En su_cuenta: " << su_cuenta.obtener_saldo()
<< endl;
cout << "\nDesea hacer una nueva transferencia? "
<< " Teclee 1 (SI) o 2 (NO)" << endl;
cin >> tr;
} // fin del while
}
cout << "Ya he terminado. " << endl;
Cree el ejecutable de este proyecto y ejecútelo practicando con las trasferencias entre las
dos cuentas corrientes, observando los resultados.
Adicional: Como habrá podido notar, no hemos usado las funciones miembro deposito
ni abono_intereses. Trate de usarlas desde main.
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra