while(!(a<b))
{
cout << (a<b) << "\n";
cout << (!(a<b)) << "\n";

//Viel Zeugs
}

Nun bricht die Schleife allerdings nicht ab, wenn sie soll, und ich bekomme manchmal Ausgaben wie:
1
1
was ja eigentlich nicht passieren sollte.
Woran könnte dieser komische Fehler liegen?

Vielen Dank schonmal im voraus,
etlam

@ Devil: WIeso wäre 0 0 klar?

Zum Problem: Sicher, dass du es mit "guten" Operatoren zu tun hast? Welche Werte haben a und b?

Vielen Dank schonmal im voraus,
etlam

bool x = true;
while(x)
{
    cout << x << "\n";
    //Viel Code
    if(a<b)
    {
         x = false;
    }
}

So dürfte ich eigentlich nie die Ausgabe 0 bekommen, aber ich bekomme sie.
Irgendwie ist das alles sehr seltsam....

Vielen Dank schonml im voraus,
etlam

int main()
{
  rol a = 0.0;
  rol b = 0.0001;
  cout << a << ' ' << b << ' ' << (a<b) << endl;
}

Eventuell steckt ja der Wurm irgendwo im operator<

while(a>b)
{
   cout << a << ">" << b << " : " << (a>b) << "\n";

   //Viel Code
}

Hier wird jetzt auch
+0>+0.001 : 0
ausgeben, aber das dürfte doch eigentlich nicht ausgegeben werden, da die Schleife ja dann abbrechen müsste.
Kann es vielleicht ein Fehler in GCC sein?

Vielen Dank schonmal im voraus,
etlam

a und b sind vom Typ rol (siehe Signatur)

mfg,
julian

etlam

Jetzt habe ich nichts geändert und das ganze auf mit einer anderen Live-Cd probiert - da ging es auf einmal - und das komischste ist, dass es dort wo es vorher nicht ging jetzt auf einmal auch geht!

etlam

Hört sich für mich so an, als wäre da eine temporäre Datei benutzt worden die nicht mehr auf dem aktuellsten Stand war.
Falls du mal wieder sowas hast, dann lösch alle temporäre Dateien und mach ein komplettes Rebuild.

if(a>b)
{
;
}

Komisch, oder?

etlam

Zeig mal den Code für deinen op> (also für die aktuelle Version mit der dieses Problem auftritt).

Und hast du mal folgendes versucht:

for( int i = 0; i < 20; ++i )
  cout << ( a > b ) << "\n";

Würde mich mal interressieren ob da immer das gleiche herauskommt, falls nicht ist dein op> auf jeden Fall fehlerhaft.

etlam

Also:
bevor der ganze Rest anfängt, habe ich zwei Variablen genommen, ihnen genau die selben Werte gegeben und genau gleich ausgegeben:
+0>+0.001 : 0
heißt es da.

Wenn du ihnen genau die selben Werte gegeben hast, ist doch arg verwunderlich, dass da einmal "0" und einmal "0.001" steht.
Vielleicht postest du mal kurz die relevanten Teile deiner Klassendefinition.

etlam schrieb:

Also:
bevor der ganze Rest anfängt, habe ich zwei Variablen genommen, ihnen genau die selben Werte gegeben und genau gleich ausgegeben:
+0>+0.001 : 0
heißt es da.

Wenn du ihnen genau die selben Werte gegeben hast, ist doch arg verwunderlich, dass da einmal "0" und einmal "0.001" steht.
Vielleicht postest du mal kurz die relevanten Teile deiner Klassendefinition.

Also mit dieselben Werte meine ich natürlich die selben Werte, wie sie hinterher in der Schleife vorkommen!

Das mit den verschiedenen Optionen werde ich morgen ausprobieren, Vielen Dank für den Hinweis.

etlam

bool& operator>(rol& a, rol& b)
{
	bool aistbruch=0;
	bool bistbruch=0;
	int awo = 0;
	int bwo = 0;
	int asize = a.wert.size();
	int bsize = b.wert.size();
	while(awo != asize)
	{
		if(a.wert[awo]=='|')
		{
			aistbruch=1;
		}
		awo++;
	}
	while(bwo != bsize)
	{
		if(b.wert[bwo]=='|')
		{
			bistbruch=1;
		}
		bwo++;
	}
	static bool reuckgabe;
	if((aistbruch==1)||(bistbruch==1))
	{
		if(aistbruch==0)
		{
			a.wert = bbeideszubruch(a.wert);
		}
		if(bistbruch==0)
		{
			b.wert = bbeideszubruch(b.wert);
		}
		a.wert = vmachevorzeichen(a.wert);
		b.wert = vmachevorzeichen(b.wert);
		reuckgabe = vbistgroesser(a.wert,b.wert);
	}
	else
	{
		a.wert = vmachevorzeichen(a.wert);
		b.wert = vmachevorzeichen(b.wert);
		reuckgabe = vistgroesser(a.wert,b.wert);
	}
	return(reuckgabe);
}

Vielen Dank schonmal im voraus,
etlam

Ausserdem:
- wenn du bools benutzt, solltest du auch true und false benutzen an Stelle von 0 und 1; Liest sich leichter.
- deine while Schleife laeuft weiter, auch wenn bereits ein '|' gefunden wurde. Pack da doch entweder ein break in die Schleife oder ein "&& !aistbruch" zur Bedingung dazu. Kann enorm Zeit sparen, wenn dein rol.wert so elend lang sein kann wie deine Signatur vermuten laesst.
- der vergleich von einem bool mit 1 ist doppelt gemoppelt. Es reicht ein

if (aistbruch || bistbruch)

- deine variable rueckgabe ist unnoetigerweise static. Sie wird angelegt und bleibt bestehen, auch wenn weit und breit kein operator< zu sehen ist. Und da du keine Informationen von einem Aufruf zum naechsten transportieren willst, macht static hier keinen Sinn.
- auch nonstatic waere rueckgabe einen unnoetige variable. statt der zuweisung und dem anschliessenden return kannst du auch jeweils einfach folgendes schreiben:

return vbistgroesser(a.wert,b.wert);

Wenn du uns jetzt noch ein paar Details z.B. ueber die Art der Speicherung deiner Werte in den rols erzaehlst udn uns evtl auch noch die Implementierung von "bbeideszubruch" etc. zeigst, kann man dir vielleicht sogar helfen, indem wir dir einen kuerzeren operator< ohne Seiteneffekte erstellen helfen.

Das mit dem, dass die Operanden verändert werden ist durchaus gewünscht.
Denn angenommen man hat eine irre lange Zahl (die sich selten ändert), die man in einer Schleife ganz oft mit verschiedenen anderen Zahlen vergleicht, addiert, wwas auch immer.

Dann müsste man (würde man diesen Operanden nicht dort ändern), diese Zahl jedes Mal umwandeln (Und z.B. das Bruch kürzen dauert ganz schön lange!).
Da ist es insgesamt also schneller diese Zahl einmal umzuwandeln und danach nicht mehr.

Das mit dem nicht abbrechen bei | ist ja ein dummer Fehler von mir... , vielen Dank für den Hinweis.

Vielen Dank schonmal im voraus,
etlam