Klasse für rationale Zahlen (Brüche)

Hallo!
Ich bin gerade dabei eine Klasse zu programmieren, die mit rationalen Zahlen rechnen soll.

#include <iostream>
#include <iomanip>
using namespace std ;

class Ratio {
      public:
             void ein(int z,int n);
             void aus();
             void gleitkomma();

             Ratio operator*(Ratio &r);
             Ratio operator/(Ratio &r);
             Ratio operator+(Ratio &r);
             Ratio operator-();
             Ratio operator-(Ratio &r);

      private:
              int zaehler;
              int nenner;
              void kuerzen();
};

void Ratio::ein(int z,int n) {
     zaehler=z;
     nenner=n;
}

void Ratio::kuerzen() {
     int a;
     if (abs(zaehler)>abs(nenner)) { a=abs(nenner)+1; } else { a=abs(zaehler)+1; }
     do {
     a--;
     } while ((zaehler%a!=0) || (nenner%a!=0)); 

     zaehler=zaehler/a;
     nenner=nenner/a;

}

void Ratio::aus() {
     kuerzen();
     cout << zaehler << "/" << nenner << endl;
}

void Ratio::gleitkomma() {
     cout << (float)zaehler/(float)nenner << endl;     
}

Ratio Ratio::operator*(Ratio &r) {
      Ratio erg;
      erg.ein(zaehler*r.zaehler,nenner*r.nenner);     
      return(erg);
}

Ratio Ratio::operator/(Ratio &r) {
      Ratio erg;
      erg.ein(zaehler*r.nenner,nenner*r.zaehler);     
      return(erg);
}

Ratio Ratio::operator+(Ratio &r) {
      int n=nenner*r.nenner;
      Ratio erg;
      erg.ein(zaehler*n/nenner+r.zaehler*n/r.nenner,n);     
      return(erg);
}

Ratio Ratio::operator-() {
      Ratio erg;
      erg.ein(-zaehler,nenner);
      return(erg);
      }

Ratio Ratio::operator-(Ratio &r) {
      int n=nenner*r.nenner;
      Ratio erg;
      erg.ein(zaehler*n/nenner-r.zaehler*n/r.nenner,n);     
      return(erg);
}

int main()
{
    Ratio r1,r2,r3,r4,r5,erg,erg2;
    r1.ein(2,25);
    r2.ein(7,5);
    r3.ein(2,5);
    r4.ein(1,4);
    r5.ein(1,3);

    erg=r1*(r2+r3);
    erg.aus();
    erg.gleitkomma();

    system("Pause");
    return(0);
}

Nachdem ich das Problem mit einem Minus als Vorzeichen gelöst habe, ist jetzt noch das Problem der Klammern offen.
Wie kann ich der Klasse klar machen, dass sie zuerst die Klammer berechnen soll und dann die Multiplikation?
Zurzeit habe ich noch folgende Fehlermeldung:

rational.cc: In functionint main()':

rational.cc:103: error: no match for 'operator*' in 'r1 * (&r2)->Ratio::operator+(((Ratio&)(&r3)))'

rational.cc:55: note: candidates are: Ratio Ratio::operator*(Ratio&)`

Über Infos zu diesem Problem würde ich mich freuen,

Thomas

Nexus

Was die Operatorüberladung angeht, findest du in diesem Artikel sehr viele nützliche Tipps und gängige Implementierungen. Zum Beispiel sollten die Operatoren + , - , * , / (jeweils mit zwei Operanden) global deklariert werden und ihre Argumente als Const-Referenz nehmen. Dazu sollten entsprechende arithmetische Zuweisungsoperatoren in der Klasse vorhanden sein ( += , -= , *= , /= ).

Im Weiteren würde ich dir raten, statt der Methode ein() einen angemessenen Konstruktor bereitzustellen, der gleich Zähler und Nenner initialisiert. Vielleicht so:

Ratio(int zaehler = 0, int nenner = 1);

Die Klammern sollten automatisch dafür sorgen, dass der innere Ausdruck zuerst ausgewertet wird und erst dessen Ergebnis multipliziert wird.

Hi,
danke für die Antwort, Konstruktoren haben wir in der Vorlesung noch nicht behandelt und ansonsten waren nur die Operatoren +,-,+ und / verlangt, von daher kann ich mir die anderen (+=,...) sparen, aber trotzdem danke für diese Hinweise.

Das mit den Klammern funktioniert aber nicht automatisch, warum, weiß ich auch nicht, die Addition an sich sowie die Multiplikation funktionieren:

erg=r2+r3;
    erg.aus();
    erg.gleitkomma();

    erg2=r1*erg;
    erg2.aus();
    erg2.gleitkomma();

ipsec

Ratio Ratio::operator*(Ratio &r)

-->

Ratio Ratio::operator*(const Ratio &r)

(Das Gleiche bei den anderen Operatoren).

Nexus

Besser

Ratio Ratio::operator*(Ratio &r);

-->

Ratio Ratio::operator*(const Ratio &r);

-->

Ratio operator*(const Ratio& l, const Ratio& r);

Warum, steht im Artikel.