Buenas gente, estaba haciendo un ejercicio de Racionales,
y estaba trabajando con dos int, para representarlo respectivamente,
mi consulta es, como podría evitar que el compilador me trunque los
valores cuando los divido, para verlo con valor decimal?
Mete el valor en un double y castea uno de los operandos a double.
Cita de: MAFUS en 31 Diciembre 2018, 17:17 PM
Mete el valor en un double y castea uno de los operandos a double.
Mira, aquí te dejo una pequeña parte del código:
Racional A2(1,5), B2(3,3);
double aux=A2.Ver_num()/A2.Ver_dem();Deberia castear así?
const_cast <double>(A2.Ver_num()) o A2.Ver_dem(), cualquiera de ellos es valido?
Puedo intuir qué es Racional, pero ¿Què es exactamente?
Cita de: MAFUS en 31 Diciembre 2018, 23:01 PM
Puedo intuir qué es Racional, pero ¿Què es exactamente?
No sé si es retorica, así que, acá te adjunto el código:
#include <iostream>
#include <iomanip>
using namespace std;
class Racional{
int num,dem;
public:
Racional(int _num, int _dem): num(_num), dem(_dem){
}
int Ver_num(){
return num;
}
int Ver_dem(){
return dem;
}
Racional operator+(Racional _r){
int aux=(this->num*_r.dem)+(this->dem*_r.num);
int aux2=this->dem*_r.dem;
Racional A(aux,aux2);
return A;
}
Racional operator*(int _i){
Racional aux(this->num*_i,this->dem);
return aux;
}
Racional operator*(Racional _r){ //Ahora ya funcionaria
Racional aux(this->num*_r.num,this->dem*_r.dem);
return aux;
}
Racional& operator++(){
num+=dem;
return *this;
}
Racional operator++(int _i){
Racional aux=*this;
num+=dem;
return aux;
}
//Ejercicio 2
bool operator<(Racional _r){
float aux=this->num/this->dem;
float aux2=_r.num/_r.dem;
if(aux<aux2){
return true;
}
return false;
}
bool operator>(Racional _r){
float aux=this->num/this->dem;
float aux2=_r.num/_r.dem;
if(aux>aux2){
return true;
}
return false;
}
bool operator<=(Racional _r){
float aux=this->num/this->dem;
float aux2=_r.num/_r.dem;
if(aux<=aux2){
return true;
}
return false;
}
bool operator>=(Racional _r){
float aux=this->num/this->dem;
float aux2=_r.num/_r.dem;
if(aux>=aux2){
return true;
}
return false;
}
bool operator==(Racional _r){
float aux=this->num/this->dem;
float aux2=_r.num/_r.dem;
if(aux==aux2){
return true;
}
return false;
}
bool operator!=(Racional _r){
float aux=this->num/this->dem;
float aux2=_r.num/_r.dem;
if(aux!=aux2){
return true;
}
return false;
}
};
int main(int argc, char *argv[]) {
Racional A(3,5), B(2,3), C(0,1);
C=A+B;
cout<<C.Ver_num()<<" "<<C.Ver_dem()<<endl<<endl;
C=A*B; //Da error porque no esta sobrecargado para multiplicar por racionales...
C=A+B+C;
C=A*B*C;//solo para multiplicar por un entero
B=C++;
A=++C;
cout<<A.Ver_num()<<" "<<A.Ver_dem()<<endl<<endl;
cout<<B.Ver_num()<<" "<<B.Ver_dem()<<endl<<endl;
/*Ejercicio 2*/
Racional A2(1,5), B2(3,3);
double aux=A2.Ver_num()/const_cast<double >(A2.Ver_dem());
if(A2<B2){
cout<<"A2 es menor que B2"; //Cómo podría evitar que se trunque el valor?
}
return 0;
}
Gracias por responder, me estaba olvidando
Cuando operas dos variables de tipo <int>, el resultado resulta de tipo <int> aunque lo guardes en un <double/float>. Por ejemplo:
int a = 5, b = 2;
double res = a / b;
cout << res; Este trozo de código te mostraría por pantalla "2". Esto es porque divides (int)5 / (int)2 entonces el resultado es (int)2. Entonces aunque luego lo guardes en un <double> es como hacer <double res = 2>.
Para evitar esto se puede cambiar el tipo al menos a uno de los operandos, una operación entre dos variables numéricas distintas devuelve el resultado con el tipo más grande de los dos operandos:
- <int> / <int> = <int>
- <double> / <int> = <double> (y al revés igual)
Para no modificar el tipo puedes hacer un casting justo antes de la operación, quedaría algo así:
int a = 5, b = 2;
double res = (double)a / b; // o a / (double)b el resultado es el mismo Así conviertes la variable <a> en <double> pero sólo para hacer esa operación, después de hacer la división seguirá siendo de tipo <int>.
PD: Los últimos métodos de tu clase (los de comparación) tienen el mismo problema, prueba a comparar dos racionales que uno sea menor que otro pero por menos de una unidad, por ejemplo 1/3 < 1/2, el operador < te va a decir que el primero no es menor que el segundo (porque va a comparar 0 < 0, no 0.3 < 0.5). Suerte :-X
Cita de: YreX-DwX en 1 Enero 2019, 10:11 AM
Cuando operas dos variables de tipo <int>, el resultado resulta de tipo <int> aunque lo guardes en un <double/float>. Por ejemplo:
int a = 5, b = 2;
double res = a / b;
cout << res;
Este trozo de código te mostraría por pantalla "2". Esto es porque divides (int)5 / (int)2 entonces el resultado es (int)2. Entonces aunque luego lo guardes en un <double> es como hacer <double res = 2>.
Para evitar esto se puede cambiar el tipo al menos a uno de los operandos, una operación entre dos variables numéricas distintas devuelve el resultado con el tipo más grande de los dos operandos:
- <int> / <int> = <int>
- <double> / <int> = <double> (y al revés igual)
Para no modificar el tipo puedes hacer un casting justo antes de la operación, quedaría algo así:
int a = 5, b = 2;
double res = (double)a / b; // o a / (double)b el resultado es el mismo
Así conviertes la variable <a> en <double> pero sólo para hacer esa operación, después de hacer la división seguirá siendo de tipo <int>.
PD: Los últimos métodos de tu clase (los de comparación) tienen el mismo problema, prueba a comparar dos racionales que uno sea menor que otro pero por menos de una unidad, por ejemplo 1/3 < 1/2, el operador < te va a decir que el primero no es menor que el segundo (porque va a comparar 0 < 0, no 0.3 < 0.5). Suerte :-X
Así que así se hace un casting, la verdad es que no sabía y mire por internet pero no apareció nada, y claro, no van a funcionar los métodos por el tema de los enteros jaja eso lo sabía.
Gracias por la ayuda ;D