"For (;;)" è più veloce di "while (TRUE)"? In caso contrario, perché le persone lo usano?

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

Ho visto questo genere di cose usate molto, ma penso che sia piuttosto strano ... Non sarebbe molto più chiaro da dire while(true), o qualcosa del genere?

Immagino che (com'è la ragione per cui molti programmatori ricorrono al codice criptico) questo è un piccolo margine più veloce?

Perché e ne vale davvero la pena? In tal caso, perché non definirlo in questo modo:

#define while(true) for(;;)

Vedi anche: Quale è più veloce: while (1) o while (2)?

1. Non è più veloce
2. Se ti interessa davvero, compila con l'output dell'assemblatore per la tua piattaforma e guarda per vedere.
3. Non importa Questo non ha mai importanza. Scrivi i tuoi loop infiniti come preferisci.

Preferisco for(;;)per due motivi.

Uno è che alcuni compilatori generano avvisi while(true)(qualcosa come "condizione del loop è costante"). Evitare gli avvisi è sempre una buona cosa da fare.

Un altro è che penso for(;;)sia più chiaro e più significativo. Voglio un ciclo infinito. Letteralmente non ha condizioni, non dipende da nulla. Voglio solo che continui per sempre, fino a quando non faccio qualcosa per uscirne.

Mentre con while(true), beh, cosa c'entra la verità con qualcosa? Non mi interessa il looping fino a quando true non diventa falso, che è ciò che dice letteralmente questa forma (loop mentre true è vero). Voglio solo fare un giro.

E no, non c'è assolutamente alcuna differenza di prestazioni.

Personalmente lo uso for (;;)perché non ci sono numeri, è solo una parola chiave. Lo preferisco a while (true), while (1), while (42), while (!0)etc etc.

Per colpa di Dennis Ritchie

• Ho iniziato a usarlo for (;;)perché è così che fa Dennis Ritchie in K&R, e quando imparo una nuova lingua cerco sempre di imitare i ragazzi intelligenti.

• Questo è idiomatico C / C ++. A lungo termine è probabilmente meglio abituarsi se si prevede di fare molto nello spazio C / C ++.

• Il tuo #definenon funzionerà, dal momento che la cosa che si definisce # deve apparire come un identificatore C.

• Tutti i compilatori moderni genereranno lo stesso codice per i due costrutti.

Non è certamente più veloce in nessun compilatore sano di mente. Entrambi saranno compilati in salti incondizionati. La versione for è più facile da digitare (come ha detto Neil) e sarà chiara se si capisce la sintassi del loop.

Se sei curioso, ecco cosa mi dà gcc 4.4.1 per x86. Entrambi usano l' istruzione x86 JMP .

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

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

compila in (in parte):

.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

Preferisco for (;;)perché è il più coerente in diversi linguaggi simili a C.

In C ++ while (true)va bene, ma in C dipende da un'intestazione da definire true, ma TRUEè anche una macro comunemente usata. Se lo usi while (1)è corretto in C e C ++ e JavaScript, ma non Java o C #, che richiedono che la condizione del ciclo sia booleana, come while (true)o while (1 == 1). In PHP, le parole chiave non fanno distinzione tra maiuscole e minuscole, ma la lingua preferisce la maiuscola TRUE.

Tuttavia, for (;;)è sempre completamente corretto in tutte quelle lingue.

Personalmente preferisco il for (;;)linguaggio (che verrà compilato con lo stesso codice di while (TRUE).

L'uso while (TRUE)può essere più leggibile in un certo senso, ho deciso di usare il for (;;)linguaggio perché si distingue .

Un costrutto a ciclo infinito dovrebbe essere facilmente notato o richiamato nel codice, e personalmente penso che lo for (;;)stile lo faccia un po 'meglio di while (TRUE)o while (1).

Inoltre, ricordo che alcuni compilatori emettono avvisi quando l'espressione di controllo di un ciclo while è una costante. Non penso che ciò accada troppo, ma solo il potenziale di avvertimenti spuri è sufficiente per volerlo evitare.

Ho visto alcune persone preferirlo perché hanno un #define da qualche parte come questo:

#define EVER ;;

Che consente loro di scrivere questo:

for (EVER)
{
    /* blah */
}

Che dire (se la tua lingua lo supporta):

start:
/* BLAH */
goto start;

Non c'è alcuna differenza in termini di codice macchina che viene generato.

Tuttavia, solo per invertire la tendenza, direi che la forma while (TRUE) è molto più leggibile e intuitiva rispetto a (;;), e che la leggibilità e la chiarezza sono motivi molto più importanti per le linee guida di codifica rispetto a qualsiasi motivo io ' ho sentito l'approccio for (;;) (preferisco basare le mie linee guida sulla codifica su solidi ragionamenti e / o prove di efficacia me stesso).

Non solo un modello ben noto, ma un linguaggio standard in C (e C ++)

while(true)

genera un avviso con Visual Studio (la condizione è costante). La maggior parte dei posti in cui ho lavorato compilano build di produzione con avvisi come errori. Così

for(;;)

è preferito.

Entrambi dovrebbero essere gli stessi se il tuo codice è ottimizzato dal compilatore. Per spiegare cosa intendo per ottimizzazione, ecco un codice di esempio scritto in MSVC 10:

int x = 0;

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

    printf("%d", x);
}

Se lo costruisci in modalità Debug ( senza alcuna ottimizzazione (/ Od) ) lo smontaggio mostra la chiara differenza. Ci sono ulteriori istruzioni per la truecondizione all'interno 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)  

Tuttavia, se si crea il codice in modalità di rilascio (con la velocità di massimizzazione predefinita (/ O2) ) si ottiene lo stesso output per entrambi. Entrambi i loop sono ridotti a un'istruzione di salto.

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)  

Qualunque cosa tu usi, non importa per un compilatore decente con l'ottimizzazione della velocità attiva.

È una questione di preferenze personali in che modo è più veloce. Personalmente, sono un touchtypist e non guardo mai la mia tastiera, durante la programmazione - posso toccare tutti i 104 tasti della mia tastiera.

Trovo più veloce digitare "while (TRUE)".

Ho aggiunto mentalmente alcune misurazioni del movimento delle dita e le ho sommate. "for (;;)" ha circa 12 larghezze di chiave dei movimenti indietro e quarta (tra i tasti home e le chiavi e tra i tasti home e il tasto SHIFT) "mentre (TRUE)" ha circa 14 larghezze di chiave dei movimenti indietro e il quarto.

Tuttavia, sono immensamente meno soggetto a errori durante la digitazione di quest'ultimo. Penso mentalmente alle parole alla volta, quindi trovo più velocemente digitare cose come "nIndex" rispetto agli acronimi come "nIdx" perché devo effettivamente scrivere mentalmente le lettere piuttosto che parlarle nella mia mente e lasciare che le mie dita si auto -tipo la parola (come andare in bicicletta)

(Benchmark My TypingTest.com = 136 WPM)

Tutte le risposte valide: il comportamento dovrebbe essere esattamente lo stesso.

TUTTAVIA - Supponiamo solo che abbia fatto la differenza. Supponiamo che uno di loro abbia preso altre 3 istruzioni per iterazione.

Dovrebbe interessarti?

SOLO se ciò che fai all'interno del loop è quasi nulla , cosa che non accade quasi mai .

Il mio punto è che ci sono micro-ottimizzazione e macro-ottimizzazione. La micro-ottimizzazione è come "ottenere un taglio di capelli per perdere peso".

Non riesco a immaginare che un compilatore utile genererebbe un codice diverso. Anche se così fosse, non ci sarebbe modo di determinare senza testare il compilatore specifico che era più efficiente.

Tuttavia ti consiglio di preferire for(;;)per i seguenti motivi:

• un certo numero di compilatori che ho usato genererà un avviso di espressione costante per while (true) con le impostazioni appropriate del livello di avviso.

• nel tuo esempio la macro TRUE potrebbe non essere definita come previsto

• ci sono molte possibili varianti del ciclo while quali while(1), while(true), while(1==1)ecc .; quindi for(;;)è probabile che si traduca in una maggiore coerenza.

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

È più chiaro di:

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

Non che ciò si applichi se non lo stai utilizzando Sleep().

Il ciclo "per sempre" è popolare nei sistemi embedded come un ciclo in background. Alcune persone lo implementano come:

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

E a volte è implementato come:

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

E ancora un'altra implementazione è:

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

Un compilatore di ottimizzazione dovrebbe generare lo stesso o simile codice assembly per questi frammenti. Una nota importante: il tempo di esecuzione dei loop non è una grande preoccupazione poiché questi loop durano per sempre e nella sezione di elaborazione viene dedicato più tempo.

Suppongo che (true) sia più leggibile che per (;;) - sembra che il programmatore non abbia qualcosa nel ciclo :)

Il motivo più importante per usare "for (;;)" è la paura di usare "while (TRUE)" durante la programmazione esplorativa. È più facile controllare la quantità di ripetizioni con "for" e anche, più facile convertire il ciclo "for" in un infinito.

Ad esempio, se si sta costruendo una funzione ricorsiva, è possibile limitare la quantità di chiamate alla funzione prima di convertirla in un ciclo infinito.

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

Quando sono sicuro della mia funzione, la converto in un ciclo infinito:

    for(;;) recursiveFunction(oneParam);