Version:0.9
StartHTML:0000000105
EndHTML:0000014760
StartFragment:0000000152
EndFragment:0000014726
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/*************** Noemi Ruth Moya Hinojo ***************/
/******************************************************/
/****************** Telematica ************************/
/******************** FPII ****************************/
/****************** Practica 2 ************************/
/******************************************************/
#include <iostream.h>
#include <stdlib.h>
#include "Fraccion.h"
/*****************************************************************************
* Funcion: Asignar
* Descripcion: Almacena la fracción que tiene numerador num y denominador
* denom en el objeto fracción que recibe el mensaje.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* num E Valor para el numerador
* denom E Valor para el denominador
*
*
* Valor devuelto:
* void, no devuelve nada y modifica los parametros del objeto
*****************************************************************************/
void Fraccion::Asignar (int num, int denom)
{
if (denom != 0) // El denominador pasado debe ser distinto de cero
{
if (denom < 0) // Si el denominador es negativo pasaremos el signo al numerador
{
denom = (-1) * denom;
num = (-1) * num;
}
numerador = num;
denominador = denom;
Simplificar();
}
else
{
numerador = num;
denominador = 1; // para que el programa pueda seguir ejecutandose sin que se quede colgado
cout << endl << "Error, el denominador debe ser distinto de cero" << endl;
cout << endl << " Usaremos el denominador 1 por defecto para esta fraccion " << endl;
}
};
/*****************************************************************************
* Funcion: Leer
* Descripcion: Lee por teclado los datos de una fracción y los almacena
* en el objeto que recibe el mensaje.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
*
*
*
*
* Valor devuelto:
* void, no devuelve nada pide por teclado parametros para el objeto
*****************************************************************************/
void Fraccion::Leer()
{
do
{
cout << "Introduce numerador ->" ;
cin >> numerador;
cout << " Introduce el denominador -> ";
cin >> denominador;
if (denominador == 0)
cout << endl << " El denominador debe ser distinto de cero" << endl;
}
while (denominador == 0); // repetiremos la adquisicion de datos hasta que el denominador sea diferente a cero
if (denominador<0) // en caso de tener un denominador negativo pasaremos el signo al numerador
{
denominador = (-1) * denominador;
numerador = (-1) * numerador;
}
Simplificar();
};
/*****************************************************************************
* Funcion: Escribir
* Descripcion: Escribe por pantalla la fracción correspondiente al objeto
* que recibe el mensaje.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
*
*
*
*
* Valor devuelto:
* void, no devuelve nada, escribe la fraccion por pantalla
*****************************************************************************/
void Fraccion::Escribir()
{
cout << numerador << " / " << denominador; // Mostramos por pantalla los datos del objeto
};
/*****************************************************************************
* Funcion: Sumar
* Descripcion: Suma dos fracciones, el objeto que recibe el mensaje más el
* objeto f. Devuelve el resultado de la suma y no modifica
* ninguno de los operandos.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* f E Objeto Fraccion a sumar al objeto que hace la llamada
*
*
*
* Valor devuelto:
* Devuelve un objeto Fraccion que es el resultado de sumar los dos
* objetos, el que hace la llamada y el pasado como parametro.
*****************************************************************************/
Fraccion Fraccion::Sumar (Fraccion f) const
{
int aux;
Fraccion suma; // Objeto fraccion auxiliar donde almacenar el resultado de las operaciones
aux = ((denominador) * (f.denominador));
suma.numerador = ( ( (aux * numerador)/denominador) + ( (aux * f.numerador)/f.denominador) ); // Obtenemos el valor del numerador
suma.denominador = aux; // El denominador sera la multiplicacion entre denominadores
suma.Simplificar(); // Simplificamos el objeto fraccion obtenido
return (suma);
};
/*****************************************************************************
* Funcion: Restar
* Descripcion: Resta dos fracciones, el objeto que recibe el mensaje menos el
* objeto f. Devuelve el resultado de la resta y no modifica
* ninguno de los operandos.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* f E Objeto Fraccion a restar al objeto que hace la llamada
*
*
*
* Valor devuelto:
* Devuelve un objeto Fraccion que es el resultado de restar los dos
* objetos, el que hace la llamada y el pasado como parametro.
*****************************************************************************/
Fraccion Fraccion::Restar (Fraccion f) const
{
int aux;
Fraccion resta; // Objeto fraccion auxiliar donde almacenar el resultado de las operaciones
aux = denominador * f.denominador;
resta.numerador = (( (aux * numerador)/denominador) - ( (aux * f.numerador)/f.denominador) ); // Obtenemos el valor del numerador
resta.denominador = aux; // El denominador sera la multiplicacion entre denominadores
resta.Simplificar(); // Simplificamos el objeto fraccion obtenido
return (resta);
};
/*****************************************************************************
* Funcion: Menos
* Descripcion: Devuelve, cambiada de signo, la fracción correspondiente
* al objeto que recibe el mensaje.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
*
*
*
*
* Valor devuelto:
* Devuelve un objeto Fraccion igual al de la llamada cambiado de signo.
*****************************************************************************/
Fraccion Fraccion::Menos () const
{
Fraccion aux;
aux.numerador = (-1) * numerador; // cambiamos el signo del numerador
aux.denominador = denominador; // el denominador siempre sera positivo y no cambiara
return (aux);
};
/*****************************************************************************
* Funcion: Evaluar
* Descripcion: Devuelve el valor real equivalente a dividir el numerador y el
* denominador de la fracción correspondiente al objeto que recibe
* el mensaje.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
*
*
*
*
* Valor devuelto:
* float, que sera el valor real equivalente a realizar la division del
* numerador y el denominador del objeto que hace la llamada.
*****************************************************************************/
float Fraccion::Evaluar()
{
float aux;
aux = float(numerador) / float(denominador); // Obtenemos el valor real de la fraccion
return aux;
};
/*****************************************************************************
* Funcion: Igual
* Descripcion: Compara la fracción correspondiente al objeto que recibe el
* mensaje y la fracción f y devuelve como resultado true si las
* dos fracciones son iguales y false en caso contrario.
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* f E Objeto Fraccion a comparar con el objeto de la llamada
*
*
*
* Valor devuelto:
* Bool, como resultado de comparar los dos objetos.
*****************************************************************************/
bool Fraccion::Igual(Fraccion f)
{
bool aux;
if((numerador == f.numerador) && (denominador == f.denominador))
aux = true; // si tanto numerador como denominador de los dos objetos son iguales sera true
else
aux = false; // en caso contrario no seran objetos iguales y devolveremos false
return aux;
};
/*****************************************************************************
* Funcion: Simplificar
* Descripcion: Simplifica la fracción correspondiente al objeto que recibe el
* mensaje (es un método privado).
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
*
*
*
*
* Valor devuelto:
* void, simplifica unicamente la fraccion que le pasamos como objeto.
*****************************************************************************/
void Fraccion::Simplificar()
{
int a, b, mcd;
a = abs(numerador); // Usaremos el valor absoluto del numerador para que no de problemas el algoritmo
b = denominador; // Como el denominador siempre es positivo no hara falta usar abs.
/**************************************************************
* Algoritmo de Euclides para obtejet el Maximo Comun Divisor *
* de dos numeros para poder despues simplificar el objeto *
* fraccion con el que hemos hecho la llamada a la funcion *
* y obtener asi la forma canonica de dicha fraccion. *
**************************************************************/
if (a != 0)
{
while (a != b ) // Al final en a tendremos en maximo comun divisor de los dos numeros
{
if ( a > b)
a = a - b;
else
b = b - a;
mcd = a; // Asignamos el maximo comun divisor que sera a
};
}
else
mcd = 1; // En caso que el numerador sea cero dejaremos la fraccion tal cual esta
numerador = numerador / mcd; // Dividimos numerador y denominador por el mcd
denominador = denominador / mcd; // y asi obtendremos la fraccion canonica.
};