#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

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.

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();

-->

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

(Das Gleiche bei den anderen Operatoren).

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

-->

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

-->

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

Warum, steht im Artikel.