Hola estuve dos dias estudiando POO y vine para corroborar si aprendí o no POO, despues sigo pasando programas para que me den sus opiniones
Tengo la clase Racional el fichero racional.h

#ifndef RACIONAL_H
#define RACIONAL_H
 
#include <iostream>
#include <math.h>
 
using namespace std;
 
class racional{
	public:
		racional(int a2=0, int b2=0) : num(a2), den(b2) {}
 
		void guardar(int a2, int b2);
		void leer(int &a2, int &b2);
 
		void suma(const racional, const racional);
		void resta(const racional, const racional);
		void potencia(const racional &, int valor);
 
		float decimal(float d);
 
		void mostrar();
	private:
		int num, den;
};
 
void racional::guardar(int a2, int b2)
{
	num=a2;
	den=b2;
}
 
void racional::leer(int &a2, int &b2)
{
	a2=num;
	b2=den;	
}
 
void racional::suma(const racional Uno, const racional Dos)
{
	num=Uno.num*Dos.den+Uno.den*Dos.num;
	den=Uno.den*Dos.den;
}
 
void racional::resta(const racional Uno, const racional Dos)
{
	num=Uno.num*Dos.den-Uno.den*Dos.num;
	den=Uno.den*Dos.den;
}
 
void racional::potencia(const racional &R, int valor)
{
	num=pow(R.num,valor);
	den=pow(R.den,valor);
}
 
float racional::decimal(float d)
{
	d=float(num)/float(den);
	return d;
}
 
void racional::mostrar()
{
	cout<<"Racional: "<<num<<"/"<<den<<endl;
}
#endif

Y el main

#include "racional.h"
 
int main()
{
	racional uno(3,4), dos(1,4), tres;
	float decimal;
 
	tres.suma(uno,dos);
	cout<<"Suma ";tres.mostrar();
 
	tres.resta(uno,dos);
	cout<<"Resta ";tres.mostrar();
 
	tres.potencia(uno,3);
	cout<<"Potencia ";tres.mostrar();
 
	cout<<"Decimal: "<<uno.decimal(decimal)<<endl;
 
	system("pause");
	return 0;
}

A mi hay cositas que no me convence como el metodo potencia de la clase racional

A mí lo que se me hace raro es el método <float racional::decimal(float)>. Es decir, para qué se le pasa un parámetro de tipo float? .
Digo yo que lo suyo sería pasarle el parámetro de tipo <float> por referencia y quitar el valor de retorno o bien dejar como valor de retorno un <float> y quitar el parámetro... no??

void racional::decimal(float &dec)const{
    dec = float(num) / float(den);
}
 
float racional::decimal()const{
    float dec = float(num) / float(den);
    return dec;
} 

El comentario no viene al caso. Favor de no hacer SPAM,


El metodo toma los valores de la variable uno, le hace la operacion de potencia con 3 y lo guarda en la variable tres que es la que terminas imprimiendo en pantalla.

En realidad no afecta el uso de "&". Es más, en objetos que sean muy grandes es recomendable pasar los parámetros constantes y por referencia ya que si no lo pasas por referencia la función va a hacer una copia del parámetro para lo que va a tener que reservar más memoria. En este caso que el objeto no es muy grande no tiene mucha importancia.