Prácticas de C++

Prácticas de C++
Practica Nº 6
Informática II
Fundamentos de Programación
Prof. Dr. Paul Bustamante
Practica Nº 6 Programación en C++
Pág. 1
ÍNDICE
ÍNDICE ........................................................................................................................................ 1
1. Introducción...................................................................................................................... 1
1.1
Ejercicio 1: Clase Complejo, versión 1.1................................................................... 1
1.2
Ejercicio 2: Clase Fraccion v1.1 ................................................................................ 2
1.3
Ejercicio 3: Clase Vector............................................................................................ 3
1.4
Ejercicio 5: Mi clase MiString, versión 1.0 ............................................................... 4
1. Introducción.
En esta práctica nos introduciremos en la sobrecarga de operadores, un concepto
nuevo visto esta semana en las clases de teoría.
1.1 Ejercicio 1: 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. Sólo se da a modo de ejemplo cómo se
sobrecarga el operador “+”.
class Complejo
{
double r,i;
public:
Complejo( double r1, double i1);
~Complejo();
Complejo operator+(Complejo &c){
Complejo tmp;
tmp.r = r + c.r;
tmp.i = i + c.i;
return tmp;
}
};
//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;
}
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Practica Nº 6 Programación en C++
Pág. 2
1.2 Ejercicio 2: Clase Fraccion v1.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 Ejer1 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():
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Practica Nº 6 Programación en C++
Pág. 3
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 Vector
Este ejercicio consiste en hacer una clase Vector que permita crear vectores de una forma más
intuitiva. Aunque el vector es de enteros, se puede extender a cualquier tipo (double, float).
El código es el mismo que el que está en los apuntes de las transparencias de clases. Tiene
una función miembro (Ordena) añadida que permitirá ordenar el vector de forma ascendente
o descendente, según el argumento que se le pase. A continuación puede ver la definición de
la clase,
//vector.h
class Vector
{
int *pV;
int num;
//numero de elementos
public:
Vector(int);
~Vector();
int& operator[](int index);
void Ordena(bool ord);
//true=asc. false=desc
};
Y el código del programa principal:
//principal.cpp
void main()
{
int num;
cout << "Num:";
cin >> num;
Vector v(num);
//crear vector
for (int i=0;i<num;i++)
cin >> v[i];
//imprimir vector
cout << "El vector es:\n";
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Practica Nº 6 Programación en C++
Pág. 4
for (i=0;i<num;i++)
cout << v[i] << endl;
//ordenar
char orden;
cout << "Como lo quiere ordenar (A=asc D=desc):?";
cin >> orden;
cout << "\nEl vector es ordenado es:\n";
if ( orden=='A' || orden=='a') v.Ordena(true);
else v.Ordena(false);
for (i=0;i<num;i++)
cout << v[i] << endl;
cout << "Adios.."<<endl;
//asc
}
1.4 Ejercicio 5: Mi clase MiString, versión 1.0
En este ejercicio vamos a crear la clase MiString, la cual permite utilizar de manera más
intuitiva las cadenas. Ahora sólo se dará la definición de la clase y el código de la función
principal main, desde dónde se deben crear los objetos de la clase MiString. El resto debe
tratar de implementarlo Ud. solo.
//MiString.h
class MiString
{
char *str;
//cadena
public:
MiString();
MiString(char *t);
~MiString(){ delete [] str; }
//destructor
friend istream &operator>>(istream &ci, MiString &s);
friend ostream &operator<<(ostream &co, MiString &s);
char operator[](int i);
bool operator==(char*t);
void operator=(char *t);
//sobrecarga
int GetLen(){ return strlen(str); }
};
Se deben sobrecargar los siguientes operadores:
• De inserción << y de extracción >> para poder pedir el texto e imprimirlo.
• Operador = = para comparar con una cadena de texto.
• El operador [ ] para poder acceder directamente a un elemento de la cadena.
//main.cpp
void main()
{
MiString cs;
while(1) {
cout << "\nDar una frase:?";
cin >> cs;
cout << "La frase al reves es:";
for (int i=cs.GetLen()-1; i>=0;i--){
cout<<cs[i];
}
cout << "\nDesea Salir? SI o NO:?";
MiString cs1;
cin >> cs1;
if (cs1 == "SI") break;
}
cout << "\nAdios.."<<endl;
}
Compile el proyecto y ejecútelo, observando el resultado.
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra