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

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?

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?

int &operator[](int _i){ 
		if(_i<=size){
			return p[_i];
		}
		return -1;	/*Que puedo retornar para saber que supere el indice?*/
 
	}
 
cout<<"Ingrese la posicion que desea modificar: "; cin>>i;
	if(V2[i-1]==/*...*/){
		cout<<"Ha superado el tamanio del arreglo"<<endl;
	}else{
		cin>>v;
		V2[i-1]=v;
	}

#include <iostream>
using namespace std;
class Instrumento{
public:
	virtual string Ver_tipo(){
		return "Sin tipo";
	};
};
class Tecla{
	int tecla; string nota;
public:
	Tecla (){
 
	}
	Tecla(string _nom){
		nota=_nom;
	}
	string Ver_nota(){
		return nota;
	}
	void Apretar(){
		tecla=1;
	}
	void Soltar(){
		tecla=0;
	}
	bool Esta_apretada(){
		if(tecla==1){
			return true;
		}
		return false;
	}
 
};
class Pedal{
	float presion;
public:
	Presion(float _p=0){
		presion=_p;
	}
	void Aumentar_presion(float _f){
		presion=_f;
	}
	void Disminuir_presion(float _f){
		presion=_f;
	}
	float Ver_presion(){
		return presion;
	}
};
class Piano:public Tecla, public Pedal, public Instrumento{
	Tecla *T[7]; Pedal P;
public:
	void Cargar_nota(){
		T[0]=new Tecla ("Do");
		T[1]=new Tecla ("Re");
		T[2]=new Tecla ("Mi");
		T[3]=new Tecla ("Fa");
		T[4]=new Tecla ("Sol");
		T[5]=new Tecla ("La");
		T[6]=new Tecla ("Si");
	}
	string Apretar_tecla(int _i){
		return T[_i]->Ver_nota();
	}
	void Soltar_tecla(int _i){
		T[_i]->Soltar();
	}
	void Presionar_pedal(float _f){
		P.Aumentar_presion(_f);
	}
	string Ver_tipo (){
		return "Piano";
	}
};
int main(int argc, char *argv[]) {
	Piano P;
	P.Cargar_nota();
	cout<<"Estas son las notas de cada tecla [1-7]"<<endl;
	cout<<endl;
	cout<<"Tecla 1: "<<P.Apretar_tecla(0)<<endl;
	cout<<"Tecla 2: "<<P.Apretar_tecla(1)<<endl;
	cout<<"Tecla 3: "<<P.Apretar_tecla(2)<<endl;
	cout<<"Tecla 4: "<<P.Apretar_tecla(3)<<endl;
	cout<<"Tecla 5: "<<P.Apretar_tecla(4)<<endl;
	cout<<"Tecla 6: "<<P.Apretar_tecla(5)<<endl;
	cout<<"Tecla 7: "<<P.Apretar_tecla(6)<<endl;
	cout<<endl<<endl;
	int i;
	cout<<"¿Que tecla desea presionar? [1-7]"; cin>>i;
	cout<<"Mostrando la nota que contiene la tecla nro "<<i<<": "<<P.Apretar_tecla(i+1)<<endl;
	cout<<"Su instrumento es de tipo : "<<P.Ver_tipo();
	return 0;
}

a. Defina una clase Tecla para representar una tecla de un piano. Cada tecla
puede estar o no apretada, y tiene ademas una nota asociada (cuyo nombre se
representará con un string). Su interfaz debe tener tener entonces:
- un constructor que reciba el nombre de la nota
- un método VerNota que retorne el nombre de la nota
- un método Apretar que cambie el estado de la tecla a apretada.
- un método Soltar que cambie el estado de la tecla a no apretada.
- un método EstaApretada que retorne true si la tecla está apretada, false en caso
contrario
b. Defina una clase Pedal para representar el pedal de un piano. El pedal debe
almacenar un valor (f loat ) que indica la presion que el musico ejerce sobre el pedal.
El constructor debe inicializar la presion en 0 , y la clase debe tener metodos para
modificarla y consultarla.
c. Reutilizando las clases Tecla , Pedal e Instrumento :
class Instrumento{
virtual string VerTipo() { return "sin_nombre"; }
};
defina una clase Piano que modele un instrumento de tipo "piano" con solo 7 teclas
(“ do”, “re”, “mi”, “fa”, “sol”, “la” y “si” ) y 1 pedal. La clase piano debe tener métodos
para:
- apretar una tecla, indicando el numero de tecla, y que retorne la nota que debería
sonar.
- soltar una tecla, indicando el numero de tecla
- presionar el pedal, indicando la presion que se aplica

#include <iostream>
using namespace std;
class Tecla{
	string nota; int tecla;
public:
	Tecla(string _t){
		nota=_t;
	}
	string Ver_nota(){
		return nota;
	}
	void Apretar(){
		tecla=1;
	}
	void Soltar(){
		tecla=0;
	}
	bool Esta_apretada(){
		if(tecla!=0){
			return true;
		}
		return false;
	}
 
};
class Pedal{
	float presion;
public:
	Pedal(){
		presion=0;
	}
	void Aumentar_presion(float _x){
		presion=_x;
	}
	void Disminuir_presion(float _x){
		presion=_x;
	}
	float Ver_presion(){
		return presion;
	}
};
 
class Ver_Tipo{
public:
	virtual string Ver_tipo(){
		return "sin nombre";
	}
};
 
class Piano{
	Tecla *T[7]; Pedal P;
public:
	string Apretar_una_tecla(int _nro){
		T[_nro]->Apretar();
		return T[_nro]->Ver_nota();
	}
	void Soltar_una_tecla(int _nro){
		T[_nro]->Soltar();
	}
	void Presionar(float _f){
		P.Aumentar_presion(_f);
	}
 
};
int main(int argc, char *argv[]) {
	Tecla *T[7]; //No se como proseguir...
	T[0]=new Tecla ("Do");
	T[1]=new Tecla ("Re");
	T[2]=new Tecla ("Mi");
	T[3]=new Tecla ("Fa");
	T[4]=new Tecla ("Sol");
	T[5]=new Tecla ("La");
	T[6]=new Tecla ("Si");
	return 0;
}