[C++] Soluzione esercizio: numeri razionali

[starsuper]

Salve a tutti, sono alle prese con un altro esercizio che stavolta ho risolto per conto mio . Dato un main, devo scrivermi una classe che rappresenti i numeri razionali.

main.cpp
#include "rat.hpp"
#include <iostream>

using namespace std;

int main() {
    rat r1(2,7);
    rat r2(8,6);
    rat r3(4,14);
    int n, d;
    r3.unpack(n,d);
    cout << "r3=" << n << "/" << d << endl; // 2/7
    (r1+r2).print(); // prints 34/21
    (r1-r2).print(); // prints -22/21
    (r1*r2).print(); // prints 8/21
    (r1/r2).print(); // prints 3/14
    return 0;
}

rat.hpp--> Header file
class rat {
    int n, d;
public:
    rat(int a, int b);
    rat operator+(const rat&);
    rat operator-(const rat&);
    rat operator*(const rat&);
    rat operator/(const rat&);
    void unpack(int&, int&);
    void print();
};

rat.cpp


#include <iostream>
#include "rat.hpp"

static int gcd(int x, int y) {
    if (y == 0) return x;
    return gcd(y, x % y);
}

rat::rat(int a, int b) {
    int sgn = (a < 0) ^ (b < 0);
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    int g = gcd(a,b);
    n = sgn ? -a/g : a/g;
    d = b/g;
}

rat rat::operator+(const rat& o) {
    return rat(o.d*n+d*o.n, d*o.d);
}

rat rat::operator-(const rat& o) {
    return rat(o.d*n-d*o.n, d*o.d);
}

rat rat::operator*(const rat& o) {
    return rat(n*o.n, d*o.d);
}

rat rat::operator/(const rat& o) {
    return rat(n*o.d, d*o.n);
}

void rat::unpack(int& a, int& b) {
    a = n; 
    b = d;
}
    
void rat::print() {
    std::cout << n << "/" << d << std::endl;
}

Allora questa è la soluzione proposta. Mi torna tutto ma la soluzione da errore perche i vari operator restituiscono un int mentre lui si aspetta un rat in uscita.
Allora io ho risolto cosi:

rat rat::operator+(const rat& o)
{
    int f=((o.d*n)+(o.n*d));
    int g=d*o.d;
    rat temp(f,g);
    return temp;
    //return ((o.d*n)+(o.n*d),d*o.d);
    //this->n=((o.d*n)+(o.n*d));
    //this->d=(d*o.d);
    //return this->n;
    //return this->d;
}
rat rat::operator-(const rat& o)
{
   
    //return ((o.d*n)-(o.n*d),d*o.d);
    int f=(o.d*n)-(o.n*d);
    int g=d*o.d;
    rat temp(f,g);
    return temp;
    
    
}
rat rat::operator*(const rat& o)
{
    //return((o.n*n),(o.d*d));
    int f=(o.n*n);
    int g=(o.d*d);
    rat temp(f,g);
    return temp;
    
    
    
}
rat rat::operator/(const rat& o)
{
    //return ((n*o.d),(d*o.n));
    int f=(n*o.d);
    int g=(d*o.n);
    rat temp(f,g);
    return temp;
    
    
}

Ovvero visto che restituisco i valori "by-value" mi creo due variabili temporanee in cui storo numeratore e denominatore e poi invoco il costruttore passando questi due valori.

Questa soluzione è corretta secondo voi o ci sarebbero anche altre soluzioni? Se avessi restituito un reference (rat&) cosa sarebbe cambiato? Grazie!

[apatriarca]

Non mi è chiaro l'errore che ti viene restituito. Non posso in questo momento provare a compilare il codice, ma mi sembra strano tu debba fare qualcosa del genere per farlo funzionare. Posta l'errore che ti fornisce il compilatore.

[starsuper]

L'errore è in corrispondenza di ogni return di ogni funzione operator

Ecco qua l'errore restituito:

http://imgur.com/a/S2Nqt

[apatriarca]

Ma da errore perché non stai chiamando il costruttore di rat, ma stai restituendo un intero (in quel caso d*o.d). Ma la soluzione postata era quella del tuo professore? Il codice alla fine è del tutto identico dal punto di vista del compilatore a quello che ha scritto il tuo professore sopra restituendo semplicemente rat(..). L'unica differenza è che tu hai separato tutte le espressioni e gli hai dato un nome.

[starsuper]

Si ho capito solo ora, infatti se scrivessi return rat(....) il codice verrebbe eseguito senza problemi! Meglio cosi allora ! Grazie