Prácticas de C++

Prácticas de C++
Practica Nº 11
Informática II
Fundamentos de Programación
Prof. Dr. Paul Bustamante
Practica Nº11 Programación en C++
Pág. 1
ÍNDICE
ÍNDICE ........................................................................................................................................ 1
1. Introducción...................................................................................................................... 1
1.1
Ejercicio 1: Clase Fecha............................................................................................. 1
1.2
Ejercicio 2: Clase Fraccion, versión 1.1..................................................................... 3
1.3
Ejercicio 3: Clase Complejo, versión 1.1................................................................... 4
1.4
Ejercicio 4: Clase String, versión 1.1......................................................................... 5
1. Introducción.
En esta práctica trataremos de hacer un ejercicio de clases con algoritmos y nos
introduciremos en la sobrecarga de operadores, un nuevo concepto visto esta semana en las
clases de teoría.
1.1 Ejercicio 1: Clase Fecha
Para empezar a hacer uso de la sobrecarga de operadores, vamos a crear una nueva clase
Fecha que nos permita pedir de forma sencilla una fecha, imprimirla, comparar dos fechas y
sumarles días a una fecha, lo cual haremos gracias a la sobrecarga de los operadores
respectivos ( >>, <<, + y = =). A continuación se le dará el código de este ejercicio. Como ya
se les ha dicho en reiteradas ocasiones, no se dedique sólo a escribir el código, debe tratar de
entenderlo:
#include <iostream.h>
//fichero Fecha.h
class Fecha
{
int dia,mes,ano;
public:
Fecha(int d=1, int m=1, int a=1900);
Fecha( Fecha &f);
//constructor copia
};
friend ostream &operator<<(ostream &co, Fecha &f);
friend istream &operator>>(istream &ci, Fecha &f);
friend bool operator==(Fecha &f1, Fecha &f2);
Fecha operator+(int d);
//fichero Fecha.cpp
#include <iostream.h>
#include <iomanip.h>
#include “Fecha.h”
Fecha::Fecha(int d, int m, int a)
{
dia=d; mes=m; ano=a;
}
Fecha::Fecha(Fecha &f)
{
dia = f.dia ;
mes = f.mes;
ano = f.ano;
}
Fecha Fecha::operator +(int dias)
{
Informática II – Fundamentos de Programación - Tecnun
Practica Nº11 Programación en C++
Pág. 2
Fecha temp;
//poner aqui el codigo para sumar dias a una fecha
return temp;
}
ostream &operator<<(ostream &co, Fecha &f)
{
cout << setfill('0') << setw(2) << f.dia << '/'
<< setw(2) << f.mes << '/' << setw(4) << f.ano;
return co;
}
istream &operator>>(istream &ci, Fecha &f)
{
char ch;
cout << "Escriba Fecha de la forma dd/mm/aa:";
ci >> f.dia >> ch >> f.mes >> ch >> f.ano;
return ci;
}
bool operator==(Fecha &f1, Fecha &f2)
{
if (f1.dia==f2.dia && f1.mes==f2.mes && f1.ano==f2.ano) return true;
else return false;
}
//fichero principal.cpp
#include <iostream.h>
#include “Fecha.h”
void main()
{
Fecha f1(12,4,2001); //crear una fecha
Fecha f2;
//crear una fecha con valores por defecto
cin >> f2;
//pedir fecha 2
cout << "Fecha 1: " << f1 << endl;
cout << "Fecha 2: " << f2 << endl;
Fecha f3;
f3 = f1 + 180;
//sumar 180 dias
cout << f1 <<" + 180 dias = " << f3 << endl;
if (f3 == f2) cout << f3 << " y " << f2 << " son Fechas iguales";
else cout << f3 << " y " << f2 << " son Fechas diferentes";
}
cout << " \nHe terminado.." << endl;
Recuerde que es preferible que utilice el entorno para crear la nueva clase (Menu
Insert->Add New Class) ya que de esta forma se crean los 2 ficheros para la clase: Fecha.cpp
y Fecha.h. Utilice para el programa principal el fichero Principal.cpp. Al proyecto puede
asignarle el nombre de Ejer1.
Informática II – Fundamentos de Programación - Tecnun
Practica Nº11 Programación en C++
Pág. 3
1.2 Ejercicio 2: Clase Fraccion, versión 1.1
Para recordar, la clase Fraccion tiene dos variables miembro privadas (long num, den), para
almacenar el numerador y denominador respectivamente. Debe crear un proyecto Ejer2 y los
ficheros respectivos para la clase Fraccion, en los cuales va a escribir el código:
1. Debe crear una función miembro privada, llamada simplificar( ), que permita
expresar la fracción en su forma más simplificada posible, manteniendo que tanto el
numerador como el denominador sean enteros. Por ejemplo, al simplificar la fracción 2/4 se
debe obtener 1/2. La simplificación se basa en la división por el máximo común divisor del
numerador y denominador. Para ello se puede seguir el algoritmo de Euclides presentado en
las transparencias de clase de “Algoritmos de búsqueda y ordenación”.
void Fraccion::simplificar()
{
long m, n, r;
if (num<den) { m=den; n=num; }
else { m=num; n=den; }
while ((r=m%n) != 0) {
m=n;
n=r;
} //n es el m.c.d
num /= n;
den /= n;
//r=resto de m/n
}
Se trata de una función privada, lo que significa que sólo puede ser llamada desde las
funciones miembro o funciones friend. Se pide utilizarla desde todas las funciones y
operadores que modifiquen el valor del denominador o del numerador (incluidos los
constructores). Esto significa que si por ejemplo inicializáramos a 4/8, el valor almacenado
debería ser 1/2.
2. Trate de crear una serie de funciones friend que permitan pre/post-multiplicar y
pre/post-dividir una fracción por un número entero (int). Los prototipos de estas funciones
para las variables de tipo int son los siguientes:
//Pre multiplicar y dividir:
friend Fraccion operator* (int, const Fraccion&);
friend Fraccion operator/ (int, const Fraccion&);
//Post multiplicar y dividir:
friend Fraccion operator* (const Fraccion&, int);
friend Fraccion operator/ (const Fraccion&, int);
3. Sobrecargar el operador de extracción “>>” para poder pedir el valor de la fracción
de la forma 2/6 directamente y que a su vez simplifique y guarde 1/3. También sobrecargar el
operador de inserción “<<” para poder sacar directamente por consola los valores de las
fracciones.
4. Finalmente, deben sobrecargar los operadores de suma y multiplicación para que
permitan sumar y multiplicar dos fracciones, tal como se puede apreciar en el código de la
función principal main.
A continuación se da el código que debe ir en main():
Informática II – Fundamentos de Programación - Tecnun
Practica Nº11 Programación en C++
Pág. 4
void main()
{
Fraccion f1(1,4);
Fraccion f2(1,2);
Fraccion f3;
cin >> f3;
//pide datos para f3
Fraccion fr = f1 + f2;
cout << f1 << " + " << f2 << " = " << fr << endl;
Fraccion fm = f1 * f2;
cout << f1 << " * " << f2 << " = " << fm << endl;
int k=4;
fr = k * f1;
//Pre-multip
cout << k << " * "<<f1<<" = "<< fr << endl;
fr = k / f3;
//Pre-division
cout << k << " / "<<f3<<" = "<< fr << endl;
k=2;
fr =
cout
fr =
cout
f2
<<
f3
<<
* k;
//Post-multip
f2 << " * "<<k<<" = "<< fr << endl;
/ k;
//Post-division
f3 << " / "<<k<<" = "<< fr << endl;
Fraccion f4;
cin >> f4;
cout << f4;
}
1.3 Ejercicio 3: Clase Complejo, versión 1.1
Este ejercicio consiste en sobrecargar todos los operadores que intervengan en el programa
que se describe a continuación. Puede utilizar las versiones anteriores de la clase Complejo,
dadas en clase o en la práctica anterior. Recuerde crear los ficheros y el proyecto
correspondiente.
//principal.cpp
#include <iostream.h>
void main()
{
Complejo c1(2.5,3),c2;
cin >> c2;
//pedir datos para c2
Complejo c3 = c1 + c2;
// c1.operator+(c2)
cout << c1 << " + " << c2 << " = " << c3 <<endl;
c3 = c1 * c2;
cout << c1 << " * " << c2 << " = " << c3 <<endl;
c1==c2? cout << c1 << " y " << c2 << " son Iguales\n":
cout << c1 << " y " << c2 << " son Diferentes\n";
if ( c1 > c2 ) cout << c1 << " es > que " << c2;
else cout << c1 << " es < que " << c2;
cout << "\nHe terminado.." << endl;
}
Informática II – Fundamentos de Programación - Tecnun
Practica Nº11 Programación en C++
Pág. 5
1.4 Ejercicio 4: Clase String, versión 1.1
Ha llegado el momento de hacer la versión 1.1 de la clase String, para lo cual vamos a partir
de la clase de la práctica anterior, implementando la sobrecarga de los operadores de tal
forma que me permitan escribir un programa de la siguiente manera:
void main()
{
String cs1,cs2;
//crear objetos
cout << "\nDame tu nombre:";
cin >> cs1;
cout << "Hola:" << cs1;
cout << "\nAhora Dame tus Apellidos:";
cin >> cs2;
cs1 += " ";
cs1 += cs2;
//agregar 1 espacio
//agregar los apellidos al nombre
int len = cs1.GetLen();
cout << "\nAhora te escribo invertido:\n";
for (int i=len-1;i>=0;i--)
cout << cs1[i];
}
cout << "\n\nAdios " << cs1 << endl;
Recuerde que si no ha llegado a terminar la practica, debe hacerlo en horas de estudio
dedicadas a la asignatura, semanalmente, para no acumular los temas anteriores.
Informática II – Fundamentos de Programación - Tecnun