ich würde euch gerne meine Fraction Klasse vorstellen(zumindest das was ich selbst geschafft habe). Ich bitte euch darum, um Konstruktive Kritik mit Erklärung zu dem was es zu kritisieren gibt und mir noch Verbesserungsvorschläge vorschlagt. Außerdem bitte ich um Erklärung von Erweiterungen wenn ihr welche machen würdet. Weiterhin wollte ich fragen was ich alles ändern müsste oder ob es überhaupt Sinn macht wenn ich das ganze als Template machen.

Fraction.h

#ifndef FRACTION_H_INCLUDED
#define FRACTION_H_INCLUDED
    class Fraction
    {
        private:
                int zaehler;
                int nenner;
        public:

        ///Konstruktor
        Fraction(int z,int n);
        Fraction() {}
        ///Überladene Operatoren
        Fraction operator+(const Fraction &right)const;
        Fraction operator+(const float right)const;
        Fraction operator-(const Fraction &right)const;
        Fraction operator-(const float right)const;
        Fraction operator*(const Fraction &fraction)const;
        Fraction operator*(const float fraction)const;
        Fraction operator/(const Fraction &right)const;
        Fraction operator/(const float right)const;
        ///Ende Überladene Operatoren
        friend std::ostream &operator<<(std::ostream &ostr, const Fraction &f);
        friend std::istream &operator>>(std::istream &inside,Fraction &f);
        ///Getter und Setter für "zaehler"
        int get_zaehler()const;
        void set_zaehler(int z);
        ///Getter und Setter für "nenner"
        int get_nenner()const;
        void set_nenner(int n);

        ///Methoden zum Bearbeiten des "Bruches"
        void kuerzen();
        int ggT(int a,int b);

};

#endif // FRACTION_H_INCLUDED

Fraction.cpp

#include "includes.h"

Fraction::Fraction(int z,int n)
{
    Fraction::zaehler = z;
    Fraction::nenner = n;

    Fraction::kuerzen();
}
////////////////////////////////////////
int Fraction::get_zaehler()const
{
    return Fraction::zaehler;
}
void Fraction::set_zaehler(int z)
{
    Fraction::zaehler = z;
}
////////////////////////////////////////
int Fraction::get_nenner()const
{
    return Fraction::nenner;
}
void Fraction::set_nenner(int n)
{
    Fraction::nenner = n;
}
////////////////////////////////////////
int Fraction::ggT(int a,int b)
{
    while(b != 0)
    {
        int temp = a%b;
        a = b;
        b = temp;
    }
    return a;
}

/////////////////////////////////////////
void Fraction::kuerzen()
{

    int ggt = ggT(zaehler,nenner);

    zaehler = zaehler / ggt;
    nenner = nenner / ggt;

}

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

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

    result.kuerzen();
    return result;
}
///////////////////////////////////////////////
Fraction Fraction::operator-(const Fraction &right)const
{
    Fraction result( zaehler * right.nenner - right.zaehler * nenner, nenner * right.nenner );

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

    result.kuerzen();
    return result;
}
//////////////////////////////////////////////
Fraction Fraction::operator*(const Fraction &fraction) const
{
    Fraction result(zaehler*fraction.zaehler, nenner*fraction.nenner);
    result.kuerzen();
    return result;
}
//////////////////////////////////////////////
Fraction Fraction::operator*(const float fraction) const
{
    Fraction result(zaehler*fraction, nenner*fraction);
    result.kuerzen();
    return result;
}
//////////////////////////////////////////////
Fraction Fraction::operator/(const Fraction &right) const
{
    Fraction result(zaehler*right.nenner, nenner*right.zaehler);
    result.kuerzen();
    return result;
}
//////////////////////////////////////////////
Fraction Fraction::operator/(const float right) const
{
    Fraction result(zaehler*right, nenner*right);
    result.kuerzen();
    return result;
}
//////////////////////////////////////////////
std::ostream &operator<<(std::ostream &ostr, const Fraction &f)
{
    return ostr<<f.zaehler<<"/"<<f.nenner;
}
//////////////////////////////////////////////
std::istream &operator>>(std::istream &inside,Fraction &f)
{
    std::string bruch;
    std::string str_nenner;
    std::string str_zaehler;
    std::stringstream string_to_int;
    int gefunden;
    int neuerzaehler;
    int neuernenner;

    inside>>bruch;
    ///Finden des Slashzeichen und Rückgabe desen Position
    gefunden = bruch.find("/");
    ///Aufspaltung in zaehler und nenner
    ///Teilstring von "bruch" bilden(zaehler). Von der Stelle 0 bis zur Stelle "gefunden"
    str_zaehler = bruch.substr(0,gefunden);
    ///Teilstring von Bruch bilden(nenner). Von der Stelle gefunden+1 bis zum Ende des Stringes
    str_nenner = bruch.substr(gefunden+1,bruch.length());

   ///Umwandlung von String in Int
   ///Umwandlung für den "zaehler"
   string_to_int<<str_zaehler;
   string_to_int>>f.zaehler;

   ///Umwandlung von String in Int
   ///Umwandlung für den "nenner"
   string_to_int.clear();
   string_to_int<<str_nenner;
   string_to_int>>f.nenner;

    return inside;
}

includes.h

#ifndef INCLUDES_H_INCLUDED
#define INCLUDES_H_INCLUDED

#include <iostream>
#include <string>
#include <sstream>
#include "Fraction.h"

#endif // INCLUDES_H_INCLUDED

main.cpp

#include "includes.h"

using namespace std;

int main()
{

    Fraction fraction1;
    Fraction fraction2;

    cout<<"Geben Sie Ihren 1. Bruch ein!(Inklusive des \" / \")"<<endl;
    cin>>fraction1;
    cout<<"Geben Sie Ihren 2. Bruch ein!(Inklusive des \" / \")"<<endl;
    cin>>fraction2;

    cout<<"Addition: "<<fraction1+fraction2<<endl;
    cout<<"Multiplikation: "<<fraction1*fraction2<<endl;
    cout<<"Subtraktion: "<<fraction1-fraction2<<endl;
    cout<<"Division: "<<fraction1/fraction2<<endl;

}

Ich hoffe es macht nicht zu viel Umstände.

Schönen Samstag noch.

EDIT:Achja ist mit Code::Blocks geschrieben wurden.

Sieht auf den ersten Blick gut aus! Ich hätte aber noch ein paar kleine Verbesserungsvorschläge:
- Mir fehlen operator== und !=, außerdem +=, -=, *=, /=
- Die Methoden "kuerzen" und "ggT" würde ich private oder protected machen; gekürzt wird sowieso von alleine und die ggT-Methode gehört eher in eine Mathe-Bib (btw, ggT könnte auch static sein)
- Eventuell die Stream-Operatoren auslagern? Brauchen dank get_nenner und get_zaehler auch nicht friend zu sein.

edit:

FireFighter schrieb:

Ich hoffe es macht zu viel Umstände.

Das hoffe ich auch

Achso, und wegen der Template-Sache: Wäre evtl nicht schlecht, vor allem da man u.U. doch mal größere Zähler und Nenner braucht als 2 Mrd Obwohl das manches vielleicht auch schwieriger macht, denn du bräuchtest dann evtl auch eine Konvertierung von Fraction<int> nach Fraction<unsigned long> oder so..

Oh, und evtl eine Methode "double asDouble() const" oder so? Falls man den Wert dann doch als Fließkomma-Zahl braucht, wäre das wahrscheinlich nicht schlecht.

P.S. Ich habe den Fehler geändert

Bei den ganzen Operatoren muss du ne Referenz zurückgeben

Wie kommst Du denn darauf? Das wäre tötlich.

Er hat das mit den Operatoren eh völlig falsch gemacht. Die verändern das Objekt ja gar nicht! Normalerweise gibt man *this zurück als Referenz.

Ist alles gut.

Fraction a(1,2);
Fraction b(1,3);
Fraction c = a + b;

Sollte danach a etwa auch 5/6 sein? Ich denke nicht.

Fraction x = 1;

Sinnvoll würde man hier wohl mit Defaultargumenten arbeiten - insofern halte ich den jetzigen Defaultkonstruktor nicht für günstig, weil er keine Initialisierung durchführt (das kann nat. auch Absicht sein). Für günstiger halte ich

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

aber man kann das diskutieren.
ggT hat nichts mit einer konkreten Instanz von Fraction zu tun, und sollte folglich wenigstens static sein - tatsächlich hat es nicht mal entfernt etwas mit Fraction zu tun - eine freie Funktion ist hier weitaus sinnvoller. Das Problem mit der Interaktion mit float wurde schon angesprochen - das kann man machen, aber da float nicht exakt ist, kann das Ergebnis auch nicht exakt sein, und sollte folglich float sein (analog double, long double). Schließlich erlauben diese Operatoren float-Argumente nur für den rechten Operanden, das ist unintuitiv - die Benutzung von freien Operatoren ist hier absolut angebracht.

Ob die Streamoperatoren dagegen in der Klasse (+friend) definiert werden, oder erst außerhalb (und möglicherweise nicht friend) ist dagegen absolut und völlig egal. Für den Benutzer spielt es keine Rolle, und auch an der Implementation ändert sich nichts und eine 3. interessierte Partei existiert nicht. Der Kommentar darüber ist allerdings falsch! Was sollen die denn sonst sein, wenn nicht überladene Operatoren?!?

EDIT: Genau was meinst du mit den unären + -

EDIT: Genau was meinst du mit den unären + -

Für positive und negative Zahlen.

Fraction a(1,2);
Fraction b = -a;

Ui, den unären Operator '+' kannte ich gar nicht - sollte der einfach "leer" implementiert werden?

Er sollte den Wert der Zahl zurückgeben (also keine Referenz, wie man versucht sein könnte). Natürlich macht er nichts interessantes.

Unäre Operatoren sind solche, die nur einen Operanden haben. Wir möchten z.B. Schreiben:

Fraction x = ...
x = -x; // unäres Minus
x = +x; // unäres Plus - macht im Prinzip gar nichts, existiert der Systematik wegen

Mal eine Frage wie müsste ich denn += Operator für 2 FRaction objekte bauen?

So evtl.:

Fraction& operator+=(const Fraction& right)
{
    m_numerator = m_numerator * right.m_denominator + right.m_numerator * m_denominator;
    m_denominator = m_denominator * right.m_denominator;
    return *this;
}

Edit: Das const vor der zurückgegebenen Referenz war mist.

Die Problematik interner Überläufe muss man allerdings in jedem Falle betrachten, solange die Typen für Zähler und Nenner nicht beliebig große Zahlen erfassen können. Dabei gibt es wahrscheinlich keine richtig gute Lösung.
Schlecht dürfte sein, diese Fälle als Fehler aufzufassen und etwa mit Exceptions zu reagieren. Man kann im Voraus kürzen (dann sollte die Klasse besser rational heißen) aber das ist keine sichere Lösung. Letztlich bleibt dann nur die Möglichkeit, einen genäherten Wert darzustellen - in diesem Moment ist die Klasse dann aber nicht mehr exakt, und die Argumentation hinsichtlich der Interaktion mit float&Co. kehrt sich um. Es kommen auch mehrere Möglichkeiten der Näherung in Frage, boost:rational etwa benutzt den größten darstellbaren Nenner und wählt den Zähler entsprechend. Eine andere Möglichkeit könnte im "übermäßigen" Kürzen bestehen (also Kürzen mit einer Zahl die nicht Teiler von sowohl Zähler als auch Nenner ist). Am Besten - in meinen Augen - dürfte noch sein, die dem exakten Ergebnis nächste darstellbare Zahl zu wählen: das läuft auf eine Kettenbruchentwicklung hinaus (oder vielleicht geht es auch eleganter, meine Mathekenntnisse sind ein bisschen eingerostet), ist also etwas komplexer aber nicht sehr kompliziert.

Weiterhin wollte ich fragen was ich alles ändern müsste oder ob es überhaupt Sinn macht wenn ich das ganze als Template machen.

Macht absolut Sinn. Allerdings sollte für diesen Schritt die jetzige Klasse erstmal einwandfrei funktionieren.

Badestrand schrieb:

Ui, den unären Operator '+' kannte ich gar nicht - sollte der einfach "leer" implementiert werden?

Nein, schliesslich muss der ja etwas zurückgeben. Eine Möglichkeit wäre folgende:

Fraction operator +() const
	{
		return Fraction(+zaehler, nenner);
	}

@Firefighter
Noch ein Tipp, binäre Non-Assignment Operatoren solltest du ausserhalb der Klasse, im Namensraum definieren. Notfalls in der Klasse als friend deklarieren, falls du auf non-public Member zugreifen möchtest. Nur mal ein Beispiel, was gegen Member-Funktionen spricht:

Fraction(1, 3) * 1.5
1.5 * Fraction(1, 3)

Noch ein Tipp, binäre Non-Assignment Operatoren solltest du ausserhalb der Klasse, im Namensraum definieren. Notfalls in der Klasse als friend deklarieren, falls du auf non-public Member zugreifen möchtest.

Oder einfach über die Assignment-Operatoren:

Fraction operator+( const Fraction& frac, const float val )
{
    Fraction ret( frac );
    ret += val;
    return ret;
}

So bleibt die Logik in der Klasse; und Redundanz und so.