Problem bei eigener Rationalklasse

Tachyon

Firefighter schrieb:

ohh danke Felix, aber wie würde das bei meinem operator+ aussehen?

Genau so?

Firefighter

ja schon klar...nur er übergibt ja dem konstruktor in der operator* methode die werte der zaehler und nenner, aber beim operator+ muss ich die doch vorher noch überarbeiten, soll ich sie einfach am ende an den konstruktor übergeben oder wie jetzt?

Badestrand

Du könntest die Methoden auch so implementieren:

Fraction Fraction::operator*(Fraction const &rhs) const
{
    Fraction result( *this );
    result *= rhs; // Hier halt entsprechenden Operator
    return result;
}

So ist der Code der */+- Operatoren unabhängig von der Implementierung.

Tachyon

Firefighter schrieb:

ja schon klar...nur er übergibt ja dem konstruktor in der operator* methode die werte der zaehler und nenner, aber beim operator+ muss ich die doch vorher noch überarbeiten, soll ich sie einfach am ende an den konstruktor übergeben oder wie jetzt?

Jup, im Prinzip alles so machen wie vorher, bloß halt immer mit dem temporären Objekt und nicht mit dem Original.

Firefighter

Fraction Fraction::operator+(Fraction &fraction)
{

    fraction.set_zaehler(fraction.get_zaehler()*nenner);             // Zähler des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren
    zaehler = zaehler*fraction.get_nenner();                         // Zähler des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    nenner = nenner *fraction.get_nenner();                          // Nenner des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    fraction.set_nenner(fraction.get_nenner()*nenner);               // Nenner des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren

    zaehler = zaehler+fraction.get_zaehler();                        // Addition der beiden neuen Zähler
    Fraction result(zaehler,nenner);
    result.kuerzen();
    std::cout<<result<<std::endl;
    return result;
}

würde das dann so richtig sein bei dem operator+? das ich ganz unten dann ein tempobjekt erzeuge und dort dann die neuen zaehler und nenner übergebe?? oder muss ich das anders machen?

Tachyon

Firefighter schrieb:

Fraction Fraction::operator+(Fraction &fraction)
{

    fraction.set_zaehler(fraction.get_zaehler()*nenner);             // Zähler des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren
    zaehler = zaehler*fraction.get_nenner();                         // Zähler des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    nenner = nenner *fraction.get_nenner();                          // Nenner des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    fraction.set_nenner(fraction.get_nenner()*nenner);               // Nenner des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren

    zaehler = zaehler+fraction.get_zaehler();                        // Addition der beiden neuen Zähler
    Fraction result(zaehler,nenner);
    result.kuerzen();
    std::cout<<result<<std::endl;
    return result;
}

würde das dann so richtig sein bei dem operator+? das ich ganz unten dann ein tempobjekt erzeuge und dort dann die neuen zaehler und nenner übergebe?? oder muss ich das anders machen?

Nein, das ist schlecht so. Du veränderst damit Deinen rechten Operanden, da er als Referenz übergeben wird. Du musst in der Funktion erst ein lokales, temporäres Fraction-Objekt anlegen. Und damit musst Du dann arbeiten.
Das Interface der Operator-Funktion würde ich so gestalten:

Fraction operator+(const Fraction& right) const;

Dann kannst Du keine der Fraction-Objekte ändern die nicht geändert weden dürfen, da der Compiler meckert.

Firefighter

sorry könnt ihr mir mal auf die srpünge helfen, ich habe es jetzt versucht umzuändern, jedoch mit liefert mir das ein falsches ergebnis...und so richtig durchblick hatte ich dann auch nicht mehr

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

    result.zaehler = result.zaehler * right.nenner;             // Zähler des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren
    result.zaehler = result.zaehler * result.nenner;            // Zähler des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    result.nenner = result.nenner * right.nenner;               // Nenner des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    result.nenner = result.nenner * result.nenner ;             // Nenner des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren

    result.set_zaehler(result.get_zaehler()+result.get_zaehler());                        // Addition der beiden neuen Zähler

    result.kuerzen();
    std::cout<<result<<std::endl;
    return result;
}

wäre echt dankbar

Tachyon

Firefighter schrieb:

sorry könnt ihr mir mal auf die srpünge helfen, ich habe es jetzt versucht umzuändern, jedoch mit liefert mir das ein falsches ergebnis...und so richtig durchblick hatte ich dann auch nicht mehr

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

    result.zaehler = result.zaehler * right.nenner;             // Zähler des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren
    result.zaehler = result.zaehler * result.nenner;            // Zähler des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    result.nenner = result.nenner * right.nenner;               // Nenner des 1. Bruches mit dem Nenner des 2. Bruches multiplizieren
    result.nenner = result.nenner * result.nenner ;             // Nenner des 2. Bruches mit dem Nenner des 1. Bruches multiplizieren

    result.set_zaehler(result.get_zaehler()+result.get_zaehler());                        // Addition der beiden neuen Zähler

    result.kuerzen();
    std::cout<<result<<std::endl;
    return result;
}

wäre echt dankbar

So in etwa:

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

Firefighter

ja naklar....danke euch vielmals...wenn ich fertig bin, würde ich es hier gerne mal vorstellen um mich eurer Kritik anzunehmen

Firefighter

ich hätte aber noch eine frage, wie kann ich jetzt zum beispiel das ergebnis von

fraction1+fraction2 mit dem cout ausgeben lassen, zurzeit kommt immer ein fehler.
also es soll dann so aussehen

cout<<fraction<+fraction2<<endl;

Nexus

Der Fehler kommt, weil der Operator << nicht für deine Bruch-Klasse überladen wurde. Du musst eben eine Methode schreiben, die den Zähler durch den Nenner dividiert und das Ergebnis als float oder double zurückgibt.

Noch zu den Operatoren: Wäre es nicht das einfachste, einfach globale Operatoren zu haben, wenn ja sowieso 2 Klassen benötigt werden? Und dass sie als friend deklariert wird, wäre ja auch kein Weltuntergang, oder?

Also etwa so:

Fraction operator+(const Fraction &right, const Fraction &left)
{
    Fraction Result;
    // hier führst du die Operationen mit Result aus
    return Result;
}

Firefighter

nee da haste was falsch verstanden, ich habe 1. nur eine Klasse und ich habe den << operator schon überladen,und außerdem will ich ja gar keine dezimalzahl am ende haben
hier meine überladung:

std::ostream &operator<<(std::ostream &ostr, Fraction &f)
{
    return ostr<<f.get_zaehler()<<"/"<<f.get_nenner();
}

Tachyon

Firefighter schrieb:

nee da haste was falsch verstanden, ich habe 1. nur eine Klasse und ich habe den << operator schon überladen,und außerdem will ich ja gar keine dezimalzahl am ende haben
hier meine überladung:
std::ostream &operator<<(std::ostream &ostr, Fraction &f)
{
    return ostr<<f.get_zaehler()<<"/"<<f.get_nenner();
}

Also wenn Dein überladener <<-Operator ein Friend Deiner Fraction Klasse ist, kannst Du direkt auf die Zähler- und Nennervariablen Zugreifen. Also ohne setter und getter Methoden.
Außerdem sollte es so aussehen:

std::ostream &operator<<(std::ostream &ostr, const Fraction &f)