Sobre el truncamiento - Consulta

[Cero++]

Código (cpp) [Seleccionar] Expandir

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?

[MAFUS]

Mete el valor en un double y castea uno de los operandos a double.

[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:

Código (cpp) [Seleccionar] Expandir

Racional A2(1,5), B2(3,3);
double aux=A2.Ver_num()/A2.Ver_dem();

Deberia castear así?

Código (cpp) [Seleccionar] Expandir

const_cast <double>(A2.Ver_num()) o A2.Ver_dem(), cualquiera de ellos es valido?

[MAFUS]

Puedo intuir qué es Racional, pero ¿Què es exactamente?

[Cero++]

Puedo intuir qué es Racional, pero ¿Què es exactamente?

No sé si es retorica, así que, acá te adjunto el código:

Código (cpp) [Seleccionar] Expandir

#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

[K-YreX]

Cuando operas dos variables de tipo <int>, el resultado resulta de tipo <int> aunque lo guardes en un <double/float>. Por ejemplo:

Código (cpp) [Seleccionar] Expandir


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í:

Código (cpp) [Seleccionar] Expandir


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

[Cero++]

Cuando operas dos variables de tipo <int>, el resultado resulta de tipo <int> aunque lo guardes en un <double/float>. Por ejemplo:

Código (cpp) [Seleccionar] Expandir


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í:

Código (cpp) [Seleccionar] Expandir


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