Ejemplo de clase Racional

main.cpp

/* 
 * File:   main.cpp
 * Author: jrbalsas
 *
 * Created on 6 de febrero de 2018, 11:08
 */

#include <cstdlib>
#include <iostream>
#include "Racional.h"

using namespace std;

void visualiza(const Racional &r) {
    std::cout << r.recuperaNumerador() << "/" << r.recuperaDenominador() << std::endl;

}

int main(int argc, char** argv) {

    try {
        Racional a(2), b(3);
        Racional d={5,6};
      //  Racional d(5, 2);
      //  Racional e(7);
      //  Racional f(e);
        Racional v[]={ {3}, {3,4} }; 
        
        visualiza(v[0]);
        // Racional *p=new Racional(2,3);
        //vi7sualiza(*p);
        //a.asignaNumerador(2);
        //a.asignaDenominador(3);
        
        a.asignaNumerador(3).asignaDenominador(5);
        b.asignaNumerador(1);
        b.asignaDenominador(4);

        Racional c = a.suma(b);
        
        Racional &miotroyo=a;
        
        d= a=b;    //Operador de asignación
    
        a=miotroyo;
        
        
        Racional f = a+b; //Racional f(a+b);
        
        if (a==b) {
             std::cout << "a y b son iguales"<< std::endl;
        } else {
            std::cout << "a y b son diferentes"<< std::endl;
        }
        
        visualiza(f);
        
        std::cout << f << std::endl << a;

        //delete p;
        //p=0;
        
    } catch (std::string &e) {
        std::cerr << e << std::endl;
    } catch (RacionalError &e ) {
        std::cerr <<e.getMensaje();
    }
    return 0;
}

Racional.cpp

/* 
 * File:   Racional.cpp
 * Author: jrbalsas
 * 
 * Created on 6 de febrero de 2018, 11:24
 */

#include "Racional.h"
#include <iostream>
//Racional::Racional()
//    : numerador(0),
//    denominador(1){
////    numerador=0;
////    denominador=1; //NO!
//}

Racional::Racional(int numerador, int denominador)
: numerador(numerador),
denominador(denominador) {
    this->asignaDenominador(denominador);
    //    std::cout << "creando racional\n";
}

Racional::Racional(const Racional& orig)
: numerador(orig.numerador), denominador(orig.denominador) {
    std::cout << "copiando racional\n";
}

Racional::~Racional() {
    //    std::cout << "destruyendo racional\n";

}

//void Racional::asignaDenominador(int denominador) {
//    this->denominador=denominador;
//}

Racional& Racional::asignaNumerador(int nume) {
    numerador = nume;
    return *this;
}

int Racional::recuperaDenominador() const {
    return denominador;
}

int Racional::recuperaNumerador() const {
    return numerador;
}

Racional Racional::suma(const Racional& otro) const {

    Racional resultado(1);

    resultado.numerador = numerador * otro.denominador + denominador * otro.numerador;
    resultado.denominador = denominador * otro.denominador;
    return resultado;

}

Racional Racional::operator+(const Racional& otro) const {

    return this->suma(otro);
}

Racional& Racional::operator=(const Racional& otro) {

    if (this != &otro) {
        numerador = otro.numerador;
        denominador = otro.denominador;
    }
    return *this;
}

bool Racional::operator==(const Racional& otro) const {
    return numerador * otro.denominador == denominador * otro.numerador;
}

/**@brief Envía la información básica de un racional a un dispositivo de salida, p.e std::cout*/
std::ostream& operator<<(std::ostream& salida, const Racional &r) {
    salida << "(" << r.recuperaNumerador() << "/"
            << r.recuperaDenominador() << ")";
    return salida;
}

Racional.h

/* 
 * File:   Racional.h
 * Author: jrbalsas
 *
 * Created on 6 de febrero de 2018, 11:24
 */

#ifndef RACIONAL_H
#define RACIONAL_H
#include <string>
#include <iostream>

class RacionalError {
public:
    RacionalError(std::string mensaje): mensaje(mensaje) {};
    std::string getMensaje() const { return mensaje;}; 
private:
    std::string mensaje;
};

class Racional {
public:
    //Racional();
    Racional(int numerador=0, int denominador=1);
    Racional(const Racional& orig);
    virtual ~Racional();
    
    Racional& asignaNumerador(int nume);
    inline Racional& asignaDenominador(int denominador);
    int recuperaNumerador() const;
    int recuperaDenominador() const;
    Racional suma(const Racional &otro) const;
    Racional operator+(const Racional &otro) const;
    bool operator==(const Racional &otro) const;
    Racional& operator=(const Racional &otro);
private:
    int numerador;
    int denominador;

};

//Método inline (forma correcta)
Racional& Racional::asignaDenominador(int denominador) {
   if (denominador==0) throw RacionalError("Racional: un racional no puede tener un denominador 0");
           //std::string ("Racional: un racional no puede tener un denominador 0");
 
    this->denominador = denominador;
    return *this;
}

//Volcado rápido de un racional a un dispositivo de salida
std::ostream& operator<<(std::ostream& salida,  const Racional &r);

#endif /* RACIONAL_H */