Foro de elhacker.net

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?

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

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

#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;
}
 
 

int a = 5, b = 2;
double res = a / b;
cout << res; 

int a = 5, b = 2;
double res = (double)a / b; // o a / (double)b el resultado es el mismo