Autor
|
Tema: Sobre el truncamiento - Consulta (Leído 1,559 veces)
|
Cero++
|
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?
|
|
|
En línea
|
Ser diligente es lo ÚNICO que importa para lograr el éxito[c/ode]
|
|
|
MAFUS
Desconectado
Mensajes: 1.603
|
Mete el valor en un double y castea uno de los operandos a double.
|
|
|
En línea
|
|
|
|
Cero++
|
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?
|
|
|
En línea
|
Ser diligente es lo ÚNICO que importa para lograr el éxito[c/ode]
|
|
|
MAFUS
Desconectado
Mensajes: 1.603
|
Puedo intuir qué es Racional, pero ¿Què es exactamente?
|
|
|
En línea
|
|
|
|
Cero++
|
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
|
|
|
En línea
|
Ser diligente es lo ÚNICO que importa para lograr el éxito[c/ode]
|
|
|
K-YreX
|
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
|
|
|
En línea
|
cout << "Todos tenemos un defecto, un error en nuestro código" << endl;
|
|
|
Cero++
|
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 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
|
|
|
En línea
|
Ser diligente es lo ÚNICO que importa para lograr el éxito[c/ode]
|
|
|
|
|