Ist "für (;;)" schneller als "während (WAHR)"? Wenn nicht, warum benutzen die Leute es?

for (;;) {
    //Something to be done repeatedly
}

Ich habe gesehen, dass so etwas oft benutzt wird, aber ich finde es ziemlich seltsam ... Wäre es nicht viel klarer zu sagen while(true)oder etwas in dieser Richtung?

Ich vermute, dass dies (wie es der Grund für viele Programmierer ist, auf kryptischen Code zurückzugreifen) ein winziger Rand schneller ist?

Warum und ist es das wirklich wert? Wenn ja, warum nicht einfach so definieren:

#define while(true) for(;;)

Siehe auch: Was ist schneller: während (1) oder während (2)?

1. Es ist nicht schneller.
2. Wenn Sie sich wirklich interessieren, kompilieren Sie mit der Assembler-Ausgabe für Ihre Plattform und sehen Sie nach.
3. Es spielt keine Rolle. Das ist nie wichtig. Schreiben Sie Ihre Endlosschleifen, wie Sie möchten.

ich bevorzuge for(;;) aus zwei Gründen.

Zum einen erzeugen einige Compiler Warnungen while(true) (so etwas wie "Schleifenbedingung ist konstant"). Das Vermeiden von Warnungen ist immer eine gute Sache.

Ein weiterer Grund ist, dass ich denke, dass dies for(;;)klarer und aussagekräftiger ist. Ich möchte eine Endlosschleife. Es buchstäblich hat keine Bedingung, es hängt von nichts. Ich möchte nur, dass es für immer weitergeht, bis ich etwas tue, um daraus auszubrechen.

Während mit while(true) , na ja, was stimmt denn damit zu tun? Ich bin nicht daran interessiert, eine Schleife zu erstellen, bis wahr falsch wird, was in dieser Form wörtlich gesagt wird (Schleife, während wahr wahr ist). Ich möchte nur eine Schleife machen.

Und nein, es gibt absolut keinen Leistungsunterschied.

Persönlich benutze ich, for (;;)weil es keine Zahlen enthält, es ist nur ein Schlüsselwort. Ich ziehe es zu while (true), while (1), while (42), while (!0)etc etc.

Wegen Dennis Ritchie

• Ich habe angefangen, es zu verwenden, for (;;)weil Dennis Ritchie es in K & R so macht, und wenn ich eine neue Sprache lerne, versuche ich immer, die klugen Jungs nachzuahmen.

• Dies ist idiomatisches C / C ++. Auf lange Sicht ist es wahrscheinlich besser, sich daran zu gewöhnen, wenn Sie vorhaben, viel im C / C ++ - Bereich zu tun.

• Sie #definewerden nicht funktionieren, da das Ding, das # define'd ist, wie eine C-Kennung aussehen muss.

• Alle modernen Compiler generieren denselben Code für die beiden Konstrukte.

In keinem vernünftigen Compiler ist es sicher schneller. Sie werden beide zu bedingungslosen Sprüngen zusammengestellt. Die for-Version ist einfacher zu tippen (wie Neil sagte) und wird klar, wenn Sie die Schleifensyntax verstehen.

Wenn Sie neugierig sind, gibt mir gcc 4.4.1 Folgendes für x86. Beide verwenden die x86- JMP- Anweisung.

void while_infinite()
{
    while(1)
    {
    puts("while");
    }
}

void for_infinite()
{
    for(;;)
    {
    puts("for");
    }
}

kompiliert zu (teilweise):

.LC0:
.string "while"
.text
.globl while_infinite
    .type   while_infinite, @function
while_infinite:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
.L2:
    movl    $.LC0, (%esp)
    call    puts
    jmp .L2
    .size   while_infinite, .-while_infinite
    .section    .rodata
.LC1:
    .string "for"
    .text
.globl for_infinite
    .type   for_infinite, @function
for_infinite:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
.L5:
    movl    $.LC1, (%esp)
    call    puts
    jmp .L5
    .size   for_infinite, .-for_infinite

ich bevorzuge for (;;) weil es in verschiedenen C-ähnlichen Sprachen am konsistentesten ist.

In C ++ while (true)ist das in Ordnung, aber in C sind Sie auf einen Header angewiesen, um ihn zu definieren true, aber es TRUEist auch ein häufig verwendetes Makro. Wenn Sie es verwenden, ist while (1)es in C und C ++ und in JavaScript korrekt, jedoch nicht in Java oder C #, für die die Schleifenbedingung ein Boolescher Wert sein muss, z. B. while (true)oder while (1 == 1). In PHP wird bei Schlüsselwörtern die Groß- und Kleinschreibung nicht berücksichtigt, aber die Sprache bevorzugt die Großschreibung TRUE.

Allerdings for (;;)ist immer ganz korrekt in all diesen Sprachen.

Ich persönlich bevorzuge die for (;;)Redewendung (die mit demselben Code kompiliert wird wie while (TRUE).

Die Verwendung while (TRUE)ist in gewisser Hinsicht besser lesbar. Ich habe mich für die Verwendung der for (;;)Redewendung entschieden, weil sie auffällt .

Ein Endlosschleifenkonstrukt sollte im Code leicht zu erkennen oder aufzurufen sein, und ich persönlich denke, der for (;;)Stil macht dies ein bisschen besser als while (TRUE)oder while (1).

Ich erinnere mich auch, dass einige Compiler Warnungen ausgeben, wenn der steuernde Ausdruck einer while-Schleife eine Konstante ist. Ich denke nicht, dass das zu viel passiert, aber nur das Potenzial für falsche Warnungen reicht aus, um dies zu vermeiden.

Ich habe gesehen, dass einige Leute es vorziehen, weil sie irgendwo ein #define haben:

#define EVER ;;

Was ihnen erlaubt, dies zu schreiben:

for (EVER)
{
    /* blah */
}

Was ist mit (wenn Ihre Sprache dies unterstützt):

start:
/* BLAH */
goto start;

Es gibt keinen Unterschied in Bezug auf den generierten Maschinencode.

Um dem Trend zu trotzen, würde ich jedoch argumentieren, dass die while (TRUE) -Form viel lesbarer und intuitiver ist als für (;;) und dass Lesbarkeit und Klarheit viel wichtigere Gründe für Codierungsrichtlinien sind als alle Gründe, die ich habe. Ich habe für den for (;;) - Ansatz gehört (ich ziehe es vor, meine Kodierungsrichtlinien auf soliden Argumenten und / oder dem Nachweis der Wirksamkeit selbst zu basieren).

Nicht nur ein bekanntes Muster, sondern eine Standardsprache in C (und C ++)

while(true)

generiert mit Visual Studio eine Warnung (Bedingung ist konstant). Die meisten Orte, an denen ich gearbeitet habe, kompilieren Produktions-Builds mit Warnungen als Fehlern. So

for(;;)

Ist bevorzugt.

Beide sollten gleich sein, wenn Ihr Code vom Compiler optimiert wird. Um zu erklären, was ich unter Optimierung verstehe, finden Sie hier einen in MSVC 10 geschriebenen Beispielcode:

int x = 0;

while(true) // for(;;)
{
    x +=1;

    printf("%d", x);
}

Wenn Sie es im Debug-Modus ( ohne Optimierung (/ Od) ) erstellen, zeigt die Demontage den deutlichen Unterschied. Es gibt zusätzliche Anweisungen für den trueZustand im Inneren while.

while(true)
00D313A5  mov         eax,1                //extra 
00D313AA  test        eax,eax              //extra
00D313AC  je          main+39h (0D313B9h)  //extra
    {
        x +=1;
00D313AE  mov         eax,dword ptr [x]  
00D313B1  add         eax,1  
00D313B4  mov         dword ptr [x],eax  
    printf("%d", x);
    ...
    }
00D313B7  jmp         main+25h (0D313A5h)  


for(;;)
    {
        x +=1;
00D213A5  mov         eax,dword ptr [x]  
00D213A8  add         eax,1  
00D213AB  mov         dword ptr [x],eax  
    printf("%d", x);
    ...
    }
00D213AE  jmp         main+25h (0D213A5h)  

Wenn Sie Ihren Code jedoch im Release-Modus erstellen (mit der Standardgeschwindigkeit maximieren (/ O2) ), erhalten Sie für beide die gleiche Ausgabe. Beide Schleifen werden auf einen Sprungbefehl reduziert.

for(;;)
    {
        x +=1;
01291010  inc         esi  

        printf("%d", x);
    ...
    }
0129101C  jmp         main+10h (1291010h)  

    while(true)
    {
        x +=1;
00311010  inc         esi  

        printf("%d", x);
    ...
    }
0031101C  jmp         main+10h (311010h)  

Was auch immer Sie verwenden, spielt für einen anständigen Compiler mit Geschwindigkeitsoptimierung keine Rolle.

Es ist eine Frage der persönlichen Präferenz, welcher Weg schneller ist. Persönlich bin ich ein Tipptypist und schaue während der Programmierung nie auf meine Tastatur - ich kann alle 104 Tasten auf meiner Tastatur tippen.

Ich finde, wenn schneller "while (TRUE)" einzugeben.

Ich fügte mental einige Fingerbewegungsmessungen hinzu und summierte sie. "for (;;)" hat ungefähr 12 Tastenbreiten der Bewegungen zurück und viertens (zwischen den Home-Tasten und den Tasten sowie zwischen den Home-Tasten und der UMSCHALTTASTE) "während (TRUE)" ungefähr 14 Tastenbreiten der Bewegungen zurück und hat vierte.

Ich bin jedoch weitaus weniger fehleranfällig, wenn ich letzteres schreibe. Ich denke mental in Worten zu einer Zeit, daher finde ich es schneller, Dinge wie "nIndex" einzugeben als Akronyme wie "nIdx", weil ich den Schriftzug tatsächlich mental buchstabieren muss, anstatt ihn in meinem Kopf zu sprechen und meine Finger automatisch sprechen zu lassen -Typ das Wort (wie Fahrrad fahren)

(Mein TypingTest.com-Benchmark = 136 WPM)

Alle guten Antworten - Verhalten sollte genau gleich sein.

JEDOCH - Nehmen wir nur an, es hat einen Unterschied gemacht. Angenommen, einer von ihnen hat 3 weitere Anweisungen pro Iteration ausgeführt.

Sollte es dich interessieren?

NUR wenn das, was Sie in der Schleife tun, fast nichts ist , was fast nie der Fall ist der Fall ist.

Mein Punkt ist, es gibt Mikrooptimierung und Makrooptimierung. Mikrooptimierung ist wie "einen Haarschnitt bekommen, um Gewicht zu verlieren".

Ich kann mir nicht vorstellen, dass ein lohnender Compiler einen anderen Code generieren würde. Selbst wenn dies der Fall wäre, gäbe es keine Möglichkeit zu bestimmen, ohne den jeweiligen Compiler zu testen, der effizienter war.

Ich schlage jedoch vor, Sie bevorzugen for(;;)aus folgenden Gründen:

• Eine Reihe von Compilern, die ich verwendet habe, generiert eine Warnung für konstante Ausdrücke für while (true) mit entsprechenden Einstellungen für die Warnstufe.

• In Ihrem Beispiel ist das Makro TRUE möglicherweise nicht wie erwartet definiert

• gibt es viele mögliche Varianten der unendlichen while - Schleife wie while(1), while(true), while(1==1)etc .; so for(;;)ist wahrscheinlich , in einem größeren Kohärenz führen.

for(;;Sleep(50))
{
    // Lots of code
}

Ist klarer als:

while(true)
{
    // Lots of code
    Sleep(50);
}

Nicht, dass dies gilt, wenn Sie nicht verwenden Sleep().

Die "für immer" -Schleife ist in eingebetteten Systemen als Hintergrundschleife beliebt. Einige Leute implementieren es als:

for (; ;)
{
 // Stuff done in background loop
}

Und manchmal wird es implementiert als:

while (TRUE /* or use 1 */)
{
 // Stuff done in background loop
}

Und noch eine andere Implementierung ist:

do
{
 // Stuff done in background loop
} while (1 /* or TRUE */);

Ein optimierender Compiler sollte für diese Fragmente denselben oder einen ähnlichen Assembler-Code generieren. Ein wichtiger Hinweis: Die Ausführungszeit für die Schleifen ist kein großes Problem, da diese Schleifen für immer andauern und mehr Zeit im Verarbeitungsabschnitt verbracht wird.

Ich nehme an, während (true) besser lesbar ist als für (;;) - es sieht so aus, als würde der Programmierer etwas in der for-Schleife verpassen :)

Der wichtigste Grund für die Verwendung von "for (;;)" ist die Angst, "while (TRUE)" zu verwenden, wenn Sie explorative Programmierung durchführen. Es ist einfacher, die Anzahl der Wiederholungen mit "for" zu steuern und die "for" -Schleife in eine Endlosschleife umzuwandeln.

Wenn Sie beispielsweise eine rekursive Funktion erstellen, können Sie die Anzahl der Aufrufe der Funktion begrenzen, bevor Sie sie in eine Endlosschleife konvertieren.

    for(int i=0;i<1000;i++) recursiveFunction(oneParam);

Wenn ich mir meiner Funktion sicher bin, konvertiere ich sie in eine Endlosschleife:

    for(;;) recursiveFunction(oneParam);