Wieso schreiben C++ Progger for(int i=0; i!=99... anstatt i<99

Das hat doch nen Grund?

Tachyon

Wer schreibt was? Häh?
Progger? Ich kenne Prommer. Die braucht man für Eproms. Aber was sind Progger? Das liest man hier oft.

Nexus

Weil es keine Rolle spielt, da die Schleife bei inkrementierenden Ganzzahl-Schritten immer gleichzeitig abgebrochen wird, egal ob die Abbruchbedingung < oder != als Vergleichsoperatoren nimmt.

for (int i = 0; i < 100; i++)   { /* ... */ }
for (int i = 0; i != 100; i++)   { /* ... */ }

Überleg dir mal, wo der Unterschied liegt.

ceplusplus*loggedoff

So tun als wüsste man nicht was das Wort bedeutet ist sogar kindischer als es eben zu verwenden.
Naja, falls du es wirklich nicht weißt, dann sry

Achja, ich würde "i < 99" schreiben.
(Ist '<' nicht auch schneller? Keine Ahnung, mit Bitoperationen habe ich mich noch nicht beschäftigt)
MfG

Der Unterschied zwischen (i<99 und i!=99) liegt doch wohl auf der Hand.
i<99:Würde so lange war sein solange i<99 ist!
Und im anderen Fall i!=99 solange i nicht 99 ist dann ist es halt war.
Ergo hast du ne schleife die in einer schritten zählt ist das grob gesagt fast das
selbe... nur wenn du mehr als 2 schritte machst ebend nicht.

kreater

warum schreiben manche for(;;) statt while(true)?

is doch scheiss egal...

edit: dämliche smileys

edit: den gossenausdruck "progger" kannste aller höchstens in der sektion "webzeugs" bringen, nirgends anders.

Don06

Ist identisch mit der Iterator-Syntax.

for(container::iterator iter = c.begin(); iter != c.end; ++iter)
for(int i = 0; i != 100; ++i)

*D*

Es ist vollkommen egal. Außer du möchtest es in allen Fäälen gleich schreiben:

for (int i = 0; i != 99; ++i) /* */
for (int i = 200; i != 99; --i) /* */

otze

Don06 schrieb:

Ist identisch mit der Iterator-Syntax.

for(container::iterator iter = c.begin(); iter != c.end; ++iter)
for(int i = 0; i != 100; ++i)

Das ist denk ich mal der Hauptgrund. Wenn man viel mit iteratoren arbeitet arbeitet man sehr oft mit != in schleifen. Wenn man das nun auch auf Zählschleifen überträgt erhält man(meiner meinung nach) lesbareren Code, weil er einfacher strukturiert ist.

groovemaster

otze schrieb:

Wenn man viel mit iteratoren arbeitet arbeitet man sehr oft mit != in schleifen. Wenn man das nun auch auf Zählschleifen überträgt erhält man(meiner meinung nach) lesbareren Code, weil er einfacher strukturiert ist.

Denke ich auch. Mache ich deswegen genauso, da es einfach zur Konsistenz des Codes beiträgt.

kreater schrieb:

warum schreiben manche for(;;) statt while(true)?

Weil das diverse Compiler weniger zu Warnungen veranlasst.

Ich glaube im C++ Primer steht das auch irgendwo drin, Iteratoren waren da AFAIR auch die Begründung.

hustbaer

groovemaster schrieb:

kreater schrieb:

warum schreiben manche for(;;) statt while(true)?

Weil das diverse Compiler weniger zu Warnungen veranlasst.

Bzw. weil "for(;;)" einfach viel kuuhler ist

hustbaer schrieb:

groovemaster schrieb:

kreater schrieb:

warum schreiben manche for(;;) statt while(true)?

Weil das diverse Compiler weniger zu Warnungen veranlasst.

Bzw. weil "for(;;)" einfach viel kuuhler ist

Weil das die C-Programmierer auch schon so gemacht haben.
Und die hatten schließlich coole Frisuren und flotte Hüte!

lagalopex

Ich hatte es auch irgendwo gelesen. Zum einen ist ein for(;; ) einfach kürzer, zum anderen passt es besser zu forever .

Nexus

lagalopex schrieb:

Ich hatte es auch irgendwo gelesen. Zum einen ist ein for(;; ) einfach kürzer, zum anderen passt es besser zu forever .

Wie meinst du das? So?

#define forever for(;;)

for(;; ) finde ich jetzt aber hässlicher als while(true) - bei der While-Variante sieht man meiner Ansicht nach auch schneller, worum es sich handelt. Aber das ist natürlich Geschmackssache (einmal abgesehen davon, dass solche Endlosschleifen sowieso kaum geschrieben werden).

hustbaer

Oder gleich

#define ever (;;)

for ever
{
}

drakon

hustbaer schrieb:

Oder gleich

#define ever (;;)

for ever
{
}

:p

CppProgger schrieb:

Das hat doch nen Grund?

der grund ist fehlende weitsicht. viele c++ entwickler sind seltsamerweise der meinung, dass code nicht kindersicher sein muss, da man ihn ja selbst geschrieben hat und auch ein blinder mit krückstock sofort durchblickt.

for( int i = 0; i != 99; ++i )
{
   // paar zeilen code
}

ist unglaublich fehleranfällig. ein unbedarfter zweiter (oder derselbe entwickler, kommt vor) könnte auf die idee kommen, den code irgendwie zu "verbessern" und folgendes einbauen

for( int i = 0; i != 99; ++i )
{
   // paar zeilen code
   if( somethingImportant )
     i += 3;
}

und schon hat man die wunderschönsten fehler im programm.

Vielleicht wird != um eine Tausendstel Sekunde schneller ausgewertet als <. Wäre gar nicht so unlogisch. Bei != kann die Funktion beim erstbesten Bit zurückkehren, das nicht übereinstimmt. Bei < ist die Sache nicht so eindeutig, bzw. müssen im Durchschnitt immer ein paar Bits mehr miteinander verglichen werden -> ergo -> dauert deshalb eventuell minimal länger. Ist aber nur eine Theorie. Man würde gar nicht vermuten, in wie vielen Fällen ein Stück Code sich in Punkto Laufzeit von einem anderen Stück Code unterscheidet, das eigentlich genau das gleiche tut, aber eben mithilfe anderer Operatoren.

Kleines Beispiel:

int a = f();
if(a < 3)
 a += 3;
else
 a += 6;

Scheinbar gleichwertig ist z.B.:

int a = f();
a += a < 3 ? 3 : 6;

Der Laufzeitunterschied ist zwar minimal, aber die zweite Version ist z.B. bei 200 Mio. Schleifendurchläufen auf meinem Rechner um ca. 1/100 Sekunde schneller (extra getestet).

Es ist gut vorstellbar, dass solche mikroskopischen Laufzeitunterschiede auch zwischen dem < und dem != Operator bestehen (falls der Compiler solche Fälle automatisch erkennen sollte und dementsprechend ohne Zutun des Proggers bei der Übersetzung optimiert ist es wohl einerlei, ob man < oder != schreibt.)

Nanyuki

Theorien-Erfinder schrieb:

Bei != kann die Funktion beim erstbesten Bit zurückkehren

Was für Funktionen denn? Das ganze wird in Maschinencode übersetzt und da macht es zeitlich keinen Unterschied, ob du auf Gleichheit oder Kleinerheit (wie heisst das auf Deutsch?) überprüfst.

Nanyuki schrieb:

Theorien-Erfinder schrieb:

Bei != kann die Funktion beim erstbesten Bit zurückkehren

Was für Funktionen denn? Das ganze wird in Maschinencode übersetzt und da macht es zeitlich keinen Unterschied, ob du auf Gleichheit oder Kleinerheit (wie heisst das auf Deutsch?) überprüfst.

So, und ab sofort ist es keine Theorie mehr, sondern eine Tatsache:
!= ist geringfügig schneller als <

Dieses Programm diente zur Überprüfung:

#include <windows.h>
#include <stdio.h>

int main(){
	long dummy = 0;
	LARGE_INTEGER a,b;

	/* Erste Version */
	QueryPerformanceCounter(&a);
	for(int i = 0; i != 200000000; ++i)
		dummy += i & 1 ? 1 : 0;
	QueryPerformanceCounter(&b);
	printf("Dauer !=: %I64d QueryTakte\n"
		"Es gibt %d ungerade Zahlen\n",
		b.QuadPart-a.QuadPart,
		dummy);

	/* Zweite Version */
	dummy = 0;

	QueryPerformanceCounter(&a);
	for(int i = 0; i < 200000000; ++i)	/* Einziger Unterschied: < statt != */
		dummy += i & 1 ? 1 : 0;
	QueryPerformanceCounter(&b);
	printf("Dauer <: %I64d QueryTakte\n"
		"Es gibt %d ungerade Zahlen\n",
		b.QuadPart-a.QuadPart,
		dummy);

	fgetc(stdin);

	return 0;
}

Und das war der Output:

Dauer !=: 2358403 QueryTakte
Es gibt 100000000 ungerade Zahlen
Dauer <: 2465883 QueryTakte
Es gibt 100000000 ungerade Zahlen

Es wurde zuerst die Laufzeit der != Schleife gestoppt,
und danach die Laufzeit einer ansonsten äquivalenten < Schleife.
Der Unterschied beträgt ca. 100.000 Query-Takte, (das entspricht auf meinem Rechner ungefähr eine Vierzigstel-Sekunde).

--> Falls 2.465.883 größer als 2.358.403 sein sollte, so ist auch der != Operator schneller als der < Operator. Genau wie ich vermutet hatte. Solche Schreibweisen-Tricks haben meistens mit Laufzeit-Optimierung zu tun.

Wieso schreiben C++ Progger for(int i=0; i!=99... anstatt i&lt;99

Wieso schreiben C++ Progger for(int i=0; i!=99... anstatt i<99