Falsche Operator+ Methode

Firefighter

Bezugnehmend auf diese Thread :

Habe ich folgendes Problem. Wenn ich den Operator+ für ein native Werte und ein Fraction Objekt überladen will, also sowas hier:

fraction1 + 0.5
//oder
fraction + 2

Rechnet meine Überladene Funktion bis jetzt noch Falsch denn sie bekommt ja einen normalen Float übergeben somit weiß sie ja nicht den den Zähler oder/und Nenner.

Beispiel

Fraction Fraction::operator+(const float right)const
{
    Fraction result( zaehler * right + right * nenner, nenner * right );
    result.kuerzen();
    return result;
}

Das ist der Überladene Operator. Nur dieser bekommt wenn ich fracttion +2 mache ja nur diese 2,also kann ich ihm nicht sagen "multipliziere den zähler mit dem nenner des anderen bruches und addiere ihn mit dem produkt aus nenner mit dem zähler des anderen nenners" wie hier

Fraction Fraction::operator+(const Fraction &right)const
{
    Fraction result( zaehler * right.nenner + right.zaehler * nenner, nenner * right.nenner );

    result.kuerzen();
    return result;
}

Wie kann ich nun eine gescheite operator+ methode schreiben die wirklich richtig rechnet, weil zurzeit kommen falsch ergebnisse raus.

Danke für eure Mühe zu dieser Späten Stunde.

Th69

Wie Tachyon doch schon geschrieben hat, macht diese Überladung keinen Sinn (denn entweder du rechnest mit Brüchen, d.h. Zahler und Nenner sind nur ganze Zahlen), oder aber du verwendest in einem Programm nur Fließkommazahlen.

Es gibt außerdem keinen eindeutigen Algorithmus, um aus einer Fließkommazahl einen (exakten) Bruch zu bestimmen (bzw. die Genauigkeit würde die Grenzen eines ints sprengen, z.B. 1.0e-10 = 1 / 1.0e10 = 1 / 10 000 000 000).

Und für ganze Zahlen brauchst du die Operatoren auch nicht überladen, da der Konstruktor

Fraction(int z, int n=1) // mit Standardparameter

dafür ausreicht, damit der Compiler die nötigen Konvertierungen selber durchführt.

pumuckl

Ich würd einen float zurückgeben bzw. einen double:

double operator+ (Fraction const& frac, double d) {
  d += (1.0* frac.zaehler)/frac.nenner;
  return d;
}

double operator+ (double d, Fraction const& frac) {
  return frac+d;
}

die binären operatoren +,-,*,/ würd ich eigentlich immer als freie Funktionen implementieren, um implizite Konvertierungen des ersten Operanden zu erlauben.