Hi

Hab wieder mal was mit C++ rumexperimentiert und bin dabei auf ein Problem gestossen. Und zwar wird eine float-Zahl die 3 oder 5 Stellen hinterm Komma hat mit 6 Stellen ausgegeben und zwar mit einer falschen (und für meine Augen willkürlichen) Zahl an der sechsten Stelle hinter dem Komma. Ich habe die Zahl eingelesen (mit scanf) und dann wieder ausgelesen (mit printf) und schon war das Problem da.

Woran kann das liegen? Kennt jemand eine Lösung für das Problem oder weiss, wie ich das umgehen kann?

MfG Crash2001

Hallo,

das ist vollkommen normal.

Wenn du folgendes machst:

double d1 = 33.3;

System.out.println(d1/10); (Java Syntax, ich kann kein C++)

wirst du irgend etwas in der Art 3.3299999...6. erhalten.

Dieses Ergebniss ist die Zahl die eine Binäre Darstellung von (d1/10) am ehesten entspricht.

Du musst das Ergebniss also immer an der gewünschten Stelle runden. Wenn die Genauigkeit von double nicht reicht, musst du halt mit float rechnen, und so weiter.

Gruß Jaraz

Hi

Aha, daher kommt das also. Wenn der ne Zahl binär nicht darstellen kann, dann nimmt der die am nähesten dran ist und die er darstellen kann?

Ist aber trotzdem nervig.

MfG Crash2001

Dann schreib dir eine klasse für bruchrechnung ;-).

Hi

Ääh...k.a. wie das geht.

MfG Crash2001

Kleiner Anstoss

class CBruch  

{

public:

	CBruch() : m_nZaehler(0) , m_nNenner(1) {}

	CBruch::CBruch( CBruch& bruch ) : m_nZaehler( bruch.m_nZaehler ), m_nNenner( bruch.m_nNenner ) {}

	CBruch::CBruch( int nZahl ) : m_nZaehler( nZahl ), m_nNenner(1) {}

	CBruch::CBruch( int nZaehler, int nNenner ) : m_nZaehler( nZaehler ), m_nNenner( nNenner ) { Kuerzen(); }


	virtual ~CBruch() {}


	operator float() const { return (float) m_nZaehler / m_nNenner; }


	CBruch& operator+( CBruch& Summand )

	{

		int nNeuerNenner = m_nNenner * Summand.m_nNenner;

		m_nZaehler = m_nZaehler * Summand.m_nNenner + Summand.m_nZaehler * m_nNenner;

		m_nNenner = nNeuerNenner;

		Kuerzen();

		return *this;

	}


private:

	void Kuerzen()

	{

		if( m_nNenner < 0 ) {

			m_nZaehler *= -1;

			m_nNenner *= -1;

		}

		if( !m_nZaehler || !m_nNenner ) return;


		int nGemTeil = 2;

		while( true ) {

			if( 0 == m_nZaehler % nGemTeil && 0 == m_nNenner % nGemTeil ) {

				m_nZaehler /= nGemTeil;

				m_nNenner /= nGemTeil;

				continue;

			}

			nGemTeil++;

			if( nGemTeil > m_nZaehler || nGemTeil > m_nNenner ) return;

		}

	}


	int m_nZaehler;

	int m_nNenner;

};

[/code]

Der Kürz-Algorithmus ist noch etwas krude, und es ist auch nur ein arithmetischer und ein cast-Operator drin. Aber ich denke, das Prinzip wird klar.

@jaraz:

du meinst sicher, wenn die Genauigkeit von float nicht reicht, double nehmen, steht nämlich für "double precision"

N.B. Es gibt diverse Beispiele in der Literatur für Klassen, die eine Festkomma-Arithmetik implementiern. Natürlich weiß ich gerade keins, aber der Unterschied besteht darin, daß Fließkommazahlen durch ihre festgelegte Größe (in bit) Grenzen haben wodurch bei Überläufen Ungenauigkeiten entstehen, eine Zahl, die ich mit *allen* Ziffern darstelle, jedoch nicht. Ist dann halt sehr viel int-rechnerei auf den ganzen Stellen.

Der Käptn

Die Ungenauigkeiten bei Fließkommatypen sind nicht nur durch die festgelegte Stellenanzahl bedingt.

Jeder Bruch, dessen Nenner keine Potenz von zwei ist (z.B. 3/10), hat im Dualsystem unendlich viele Nachkommastellen. Man kann eine solche Zahl im Dualsystem nicht mit allen Stellen darstellen.

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR>du meinst sicher, wenn die Genauigkeit von float nicht reicht, double nehmen, steht nämlich für "double precision"