Klasse für Bruchzahlen gesucht

[Ingo]

Das hier läuft auch einwandfrei:

Header:

#ifndef _FRAC_
#define _FRAC_

#include <iostream>
#include <string>

class frac
{
private:
	long m_zaehler, m_nenner;
	long ggt(long, long);
	void kuerzen(const long, const long);
public:
	frac(long z = 0, long n = 1);
	const float frac::getq();
	const std::string frac::getstr();
	frac operator-() const
	{
		return frac(-m_zaehler, m_nenner);
	}
	frac& operator+=(const frac& a)
	{
		m_zaehler = a.m_zaehler * m_nenner + m_zaehler * a.m_nenner;
		m_nenner *= a.m_nenner;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator-=(const frac& a)
	{
		*this += -a;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator++() //Präfix
	{
		m_zaehler += m_nenner;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator++(int empty) //Postfix
	{
		m_zaehler += m_nenner;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator--() //Präfix
	{
		m_zaehler -= m_nenner;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator--(int empty) //Postfix
	{
		m_zaehler -= m_nenner;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator*=(const frac& a)
	{
		m_zaehler = a.m_zaehler * m_zaehler;
		m_nenner = a.m_nenner * m_nenner;
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	frac& operator/=(const frac& a)
	{
		m_zaehler = a.m_nenner * m_zaehler;
		m_nenner = a.m_zaehler * m_nenner;
		if (m_nenner < 0)
		{
			m_zaehler = -m_zaehler;
			m_nenner = -m_nenner;
		}
		kuerzen(m_zaehler, m_nenner);
		return *this;
	}
	friend frac operator+ (const frac&, const frac&);
	friend frac operator- (const frac&, const frac&);
	friend frac operator* (const frac&, const frac&);
	friend frac operator/ (const frac&, const frac&);
	friend std::ostream& operator<< (std::ostream& os, const frac& a);
	friend std::istream& operator>> (std::istream& is, frac& a);
};

#endif

Implementation:

#include <iostream>
#include <sstream>
#include "fraction.h"

using namespace std;

frac::frac(long z, long n)
{
	if (n < 0)
	{
		z = -z;
		n = -n;
	}
	m_zaehler = z;
	m_nenner = n;
}

const float frac::getq()
{
	return static_cast<float>(m_zaehler) / static_cast<float>(m_nenner);
}

const string frac::getstr()
{
	kuerzen(m_zaehler, m_nenner);
	ostringstream z, n;
	z <<m_zaehler;
	n <<m_nenner;
	if (m_zaehler == 0) //statt 0/1 soll 0 zurück gegeben werden
		return "0";
	else if (m_nenner  == 1) //statt 3/1 soll 3 zurück gegeben werden
		return z.str();
	else if (m_zaehler == m_nenner) //statt 3/3 soll 1 zurück gegeben werden
		return "1";
	else
		return z.str() + "/" + n.str();
}

long frac::ggt(long z, long n)
{
	//z soll größer als n sein
	z = abs(z);
	n = abs(n); 
	if (n > z)
		return ggt(n, z);
	else if (n != 0)
		return ggt(n, z % n);
	else
		return z; //z ist Hauptnenner
}

void frac::kuerzen(const long z, const long n)
{
    m_zaehler /= ggt(z, n);
    m_nenner /= ggt(z, n);
}

frac operator+(const frac& a, const frac& b)
{
	frac temp;
	temp.m_nenner = a.m_nenner * b.m_nenner;
	temp.m_zaehler = a.m_zaehler * b.m_nenner + b.m_zaehler * a.m_nenner;
	temp.kuerzen(temp.m_zaehler, temp.m_nenner);
	return temp;
}

frac operator-(const frac& a, const frac& b)
{
	frac temp = a;
	temp += -b;
	temp.kuerzen(temp.m_zaehler, temp.m_nenner);
	return temp;
}

frac operator*(const frac& a, const frac& b)
{
	frac temp;
	temp.m_zaehler = a.m_zaehler * b.m_zaehler;
	temp.m_nenner = a.m_nenner * b.m_nenner;
	temp.kuerzen(temp.m_zaehler, temp.m_nenner);
	return temp;
}

frac operator/(const frac& a, const frac& b)
{
	frac temp;      
	temp.m_zaehler = a.m_zaehler * b.m_nenner;
	temp.m_nenner = a.m_nenner * b.m_zaehler;
	if (temp.m_nenner < 0)
	{
		temp.m_zaehler = -temp.m_zaehler;
		temp.m_nenner = -temp.m_nenner;
	}
	temp.kuerzen(temp.m_zaehler, temp.m_nenner);
	return temp;
}

ostream& operator<<(ostream& os, const frac& a)
{
	frac temp;
	temp.m_zaehler = a.m_zaehler;
	temp.m_nenner = a.m_nenner;
	temp.kuerzen(temp.m_zaehler, temp.m_nenner);
	if (temp.m_zaehler == 0) //statt 0/1 soll 0 ausgegeben werden
		os <<"0";
	else if (temp.m_nenner == 1) //statt 3/1 soll 3 ausgegeben werden
		os <<temp.m_zaehler;
	else if (temp.m_zaehler == temp.m_nenner) //statt 3/3 soll 1 ausgegeben werden
		os <<"1";
	else
		os <<temp.m_zaehler <<"/" <<temp.m_nenner;
	return os;
}

istream& operator>>(istream& is, frac& a)
{
	is >>a.m_zaehler;
	is >>a.m_nenner;
	if (!is) 
		return is;
	if (a.m_nenner < 0)
	{
		a.m_zaehler = -a.m_zaehler;
		a.m_nenner = -a.m_nenner;
	}
	return is;
}

main:

#include <iostream> 
#include "fraction.h" 

using namespace std; 

int main() 
{ 
    const int m_zeilen = 2; 
    const int m_spalten = 3; 

    frac m_arr[m_zeilen][m_spalten] = 
    { 
        frac(16,4), frac(0,1), frac(17,4), 
        frac(3,1),  frac(4,4), frac(-3,12) 
    };    

    frac a; 
    frac b(12,9); 
    a = frac(-3,11); 
    frac c = a * b / m_arr[1][2]; 
	c *= 33;
	c++;
	c--;
	--c;
	++c;
	c *= 2;
	c /= 3;
	c /= frac(12,11);
    cout << c << endl; //=88/3
    return 0; 
}

Habs noch etwas erweitert.

[interpreter]

Warum eigentlich nur die Präfix Inkrement/Dekrement-Operatoren? Aus Geschwindigkeitsgründen?

[Gast]

Hilfe! m_
Ein klein geschriebener Klassenname.
Wieso ist ggT nicht statisch, wenn es doch die beiden Zahlen kriegt?
Wieso kriegt kuerzen() die beiden Zahlen, wenn es nicht statisch ist?

[interpreter]

Und warum sind die arithm. Operatoren nicht über die X= definiert?

[Erhard Henkes]

dein Code ist IMHO totaler Schrott.
Das ist doch gar nicht von Erhard! Hat er doch nur kopiert von der Seite!

@kingruedi: du solltest deinen Job als Moderator wirklich überdenken, wenn du keine Zeit hast, die Beiträge komplett zu lesen.

Ich habe den Code gepostet, damit man den Unterschied (Vorteile/Nachteile) zu Shlo's Code sieht. Nun liegt ja noch ein dritter Entwurf auf dem Tisch. Ein interessanter Wettbewerb. Bin auf kingruedi's Klasse gespannt.

[Walli]

boost::rational

[interpreter]

template <typename IntType>
class rational :
    less_than_comparable < rational<IntType>,
    equality_comparable < rational<IntType>,
    less_than_comparable2 < rational<IntType>, IntType,
    equality_comparable2 < rational<IntType>, IntType,
    addable < rational<IntType>,
    subtractable < rational<IntType>,
    multipliable < rational<IntType>,
    dividable < rational<IntType>,
    addable2 < rational<IntType>, IntType,
    subtractable2 < rational<IntType>, IntType,
    subtractable2_left < rational<IntType>, IntType,
    multipliable2 < rational<IntType>, IntType,
    dividable2 < rational<IntType>, IntType,
    dividable2_left < rational<IntType>, IntType,
    incrementable < rational<IntType>,
    decrementable < rational<IntType>
    > > > > > > > > > > > > > > > >

Sieht zumindest witzig aus...

[otze]

fehlt da nicht public oder ein andres keyword?

[Erhard Henkes]

http://www.boost.org/libs/rational/rational.html#Interface

Bei boost gibt es eben (fast) alles.

#include <iostream>
#include <conio.h>
#include <boost/rational.hpp>
using namespace std;
using namespace boost;

int main()
{
  rational<int> a,b,c;
  cout << "Bruch 1:  "; cin >> a;
  cout << "Bruch 2:  "; cin >> b;
  c = a*b;
  cout << "Resultat: " << c << " = " << rational_cast<double>(c);
  getch();
}

Ausgabe:
Bruch 1: 2/33
Bruch 2: 5/55
Resultat: 2/363 = 0.00550964

Der Nachteil bei boost ist allerdings, dass man nicht auf einfache Weise selbst die Klasse verändern kann.

[Shlo]

otze schrieb:

fehlt da nicht public oder ein andres keyword?

Wenn es eine private-Ableitung ist, warum sollte es?

[Erhard Henkes]

fehlt da nicht public oder ein andres keyword?
Wenn es eine private-Ableitung ist, warum sollte es?

//...
template <typename IntType>
class rational :
  //...
{
    typedef IntType int_type;
    typedef typename boost::call_traits<IntType>::param_type param_type;

public:
    rational() : num(0), den(1) {}
    rational(param_type n) : num(n), den(1) {}
    rational(param_type n, param_type d) : num(n), den(d) { normalize(); }

    // Default copy constructor and assignment are fine

    // Add assignment from IntType
    rational& operator=(param_type n) { return assign(n, 1); }

    // Assign in place
    rational& assign(param_type n, param_type d);

    // Access to representation
    IntType numerator() const { return num; }
    IntType denominator() const { return den; }

    //...

Wenn der Konstruktor private wäre, könnten wir wenig damit anfangen.

[Ingo]

"Hilfe! m_
Ein klein geschriebener Klassenname."

Was meinst du damit?

[Shlo]

Erhard Henkes schrieb:

Wenn der Konstruktor private wäre, könnten wir wenig damit anfangen.

Ehrlich gesagt verstehe ich den Zusammenhang nicht. Was hat das eine, mit dem anderen zu tun?

[Erhard Henkes]

Probiers doch aus.

[volkard]

Shlo schrieb:

#include <iostream>
	template<class E, class T, class A>
	std::basic_string<E,T,A> to_string() const
	{
		typedef typename std::basic_string<E,T,A>::value_type value_type;
		typedef typename std::basic_string<E,T,A>::traits_type traits_type;
		typedef typename std::basic_string<E,T,A>::allocator_type allocator_type;

		typedef std::basic_ostringstream<value_type,
			traits_type,allocator_type> ostringstream;

		ostringstream oss;
		oss << *this;

		return oss.str();
	}

wie verwendet man diese funktion? mach mal ein beispiel.

fraction operator-() const
{
	return fraction(-num_,-den_);
}

einmal - wäre ok.

[volkard]

es werden hier erstaunlich viele oo-prinzipien bemüht.
aber warum nur?
was ist dagegen zu sagen, die attribute aufzumachen, wenn eh der vollständige satz von getters/setters da ist? ok, der getter/setter sollten gar nicht alle da sein. warum, wenn man eh immer statt a.nom(5) ein a=rational(5,a.denom()) schreiben kann? ah, ich weiß schon, um ne invariante garantieren zu können. hier sollte man aber gucken, ob man eine hat, und nicht ob man unter umständen eine haben könnte. es gehört zum wesen der klasse, ob die brüche zum beispiel immer normiert vorliegen oder nicht. kann man zu schlecht nachrüsten, weil sich die anderen leutchen duchaus drauf verlassen.

das erhebt eh mal die frage, warum der op== normalerweise als return a.nom==b.nom && a.denom==b.denom und nicht als return a.nom*b.denom==b.nom*a.denom implementiert ist. eigentlich sollten doch 2/4 und -3/-6 gleich sein.
zu teuer? dann bleibt wohl nur übrig, die brüche normiert darzustellen. es bietet sich an, nur gekürzte brüche zu speichern, also nach jedem += oder so gleich zu kürzen. auch hier erhebt sich wieder eine frage, und zwar, warum fast alle hier noch vergessen, daß -2/-3 und 2/3 zwei darstellungen des gleichen wertes sind, also zur normierung noch gehört, den zähler nichtnegativ zu halten.

[Shlo]

fraction a(2);
string str = a.to_string<char,char_traits<char>,allocator<char> >();

zwar etwas unübersichtlich, aber in den meisten Fällen würde man eh die Stream Funktionen benutzen. Das zweite habe ich geändert.

[Gast]

@volkard: Zu dem -2/-3:

Ich empfehle, keine setter für die Datenelemente anzubieten. Wozu denn? Soll sich derjenige halt einen neuen Bruch erstellen mit den gewünschten Werten.
Außerdem empfiehlt es sich IMHO (jetzt, wo wir die Kontrolle wieder haben ;/), dafür zu Sorgen, dass der Nenner stets positiv ist. Sollte der Nenner negativ sein, werden jeweils Zähler und Nenner mit -1 multipliziert. Und schon gibt es auch keine zwei Darstellungen mehr für die selbe Zahl.

[volkard]

Optimizer schrieb:

@volkard: Zu dem -2/-3:

Ich empfehle, keine setter für die Datenelemente anzubieten. Wozu denn? Soll sich derjenige halt einen neuen Bruch erstellen mit den gewünschten Werten.
Außerdem empfiehlt es sich IMHO (jetzt, wo wir die Kontrolle wieder haben ;/), dafür zu Sorgen, dass der Nenner stets positiv ist. Sollte der Nenner negativ sein, werden jeweils Zähler und Nenner mit -1 multipliziert. Und schon gibt es auch keine zwei Darstellungen mehr für die selbe Zahl.

hast in beiden fällen recht. ich würde auch keine setter anbieten. aber nicht wegen berufung auf ein oo-prinzip. und genausoleicht, wie ich sie hier weglasse, baue ich sie woanders wieder hin.
und nenner positiv ist besser als mein dummvorschlag mit zähler nichtnegativ.

[volkard]

Shlo schrieb:

fraction a(2);
string str = a.to_string<char,char_traits<char>,allocator<char> >();

zwar etwas unübersichtlich, aber ...

es ist unfug. weg damit.