¿Es “for (;;)” más rápido que “while (TRUE)”? Si no, ¿por qué la gente lo usa?

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

He visto que este tipo de cosas se usan mucho, pero creo que es bastante extraño ... ¿No sería mucho más claro decir while(true) , o algo por el estilo?

Supongo que (como es la razón por la cual muchos programadores recurren al código críptico), ¿esto es un pequeño margen más rápido?

¿Por qué, y realmente vale la pena? Si es así, ¿por qué no simplemente definirlo de esta manera?

#define while(true) for(;;)

Ver también: ¿Cuál es más rápido: while (1) o while (2)?

1. No es mas rapido.
2. Si realmente te importa, compila con la salida del ensamblador para tu plataforma y mira para ver.
3. No importa. Esto nunca importa. Escribe tus bucles infinitos como quieras.

Prefiero for(;;)por dos razones.

Una es que algunos compiladores producen advertencias sobre while(true) (algo así como "la condición del bucle es constante"). Evitar las advertencias siempre es algo bueno.

Otra es que creo que for(;;)es más clara y más reveladora. Quiero un bucle infinito. Literalmente tiene no condición, no depende de nada. Solo quiero que continúe para siempre, hasta que haga algo para salir de eso.

Mientras que con while(true) , bueno, ¿qué tiene que ver algo con algo? No estoy interesado en hacer un bucle hasta que verdadero se convierta en falso, que es lo que esta forma literalmente dice (bucle mientras que verdadero es verdadero). Solo quiero hacer un bucle.

Y no, no hay absolutamente ninguna diferencia de rendimiento.

Personalmente lo uso for (;;)porque no contiene ningún número, es solo una palabra clave. Yo prefiero a while (true), while (1), while (42), while (!0), etc, etc.

Por Dennis Ritchie

• Empecé a usarlo for (;;)porque así es como lo hace Dennis Ritchie en K&R, y cuando aprendo un nuevo idioma siempre trato de imitar a los tipos inteligentes.

• Esto es idiomático C / C ++. Probablemente sea mejor a largo plazo acostumbrarse si planea hacer mucho en el espacio C / C ++.

• Su #definevoluntad no funciona, ya que lo de ser #define tiene que parecer un identificador C.

• Todos los compiladores modernos generarán el mismo código para las dos construcciones.

Ciertamente no es más rápido en ningún compilador cuerdo. Ambos serán compilados en saltos incondicionales. La versión for es más fácil de escribir (como dijo Neil) y será clara si comprende la sintaxis de bucle.

Si tienes curiosidad, esto es lo que gcc 4.4.1 me da para x86. Ambos usan la instrucción x86 JMP .

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

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

compila a (en 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

yo prefiero for (;;) porque es el más consistente en diferentes lenguajes tipo C.

En C ++ while (true)está bien, pero en C depende de un encabezado para definir true, pero también TRUEes una macro de uso común. Si lo usa while (1), es correcto en C y C ++, y JavaScript, pero no en Java o C #, que requieren que la condición del bucle sea booleana, como while (true)o while (1 == 1). En PHP, las palabras clave no distinguen entre mayúsculas y minúsculas, pero el lenguaje prefiere las mayúsculas TRUE.

Sin embargo, for (;;)siempre es completamente correcto en todos esos idiomas.

Personalmente prefiero el for (;;)idioma (que se compilará con el mismo código que while (TRUE).

El uso while (TRUE)puede ser más legible en un sentido, he decidido usar el for (;;)idioma porque se destaca .

Una construcción de bucle infinito debería notarse fácilmente o llamarse en código, y personalmente creo que el for (;;)estilo lo hace un poco mejor que while (TRUE)o while (1).

Además, recuerdo que algunos compiladores emiten advertencias cuando la expresión controladora de un ciclo while es una constante. No creo que eso suceda demasiado, pero solo el potencial de advertencias espurias es suficiente para querer evitarlo.

He visto que algunas personas lo prefieren porque tienen un #definir en algún lugar como este:

#define EVER ;;

Lo que les permite escribir esto:

for (EVER)
{
    /* blah */
}

¿Qué pasa (si su idioma lo admite):

start:
/* BLAH */
goto start;

No hay diferencia en términos del código de máquina que se genera.

Sin embargo, solo para contrarrestar la tendencia, argumentaría que la forma while (TRUE) es mucho más legible e intuitiva que para (;;), y que la legibilidad y la claridad son razones mucho más importantes para las pautas de codificación que cualquier otra razón I ' He escuchado el enfoque for (;;) (prefiero basar mis pautas de codificación en razonamiento sólido y / o prueba de efectividad por mí mismo).

No solo un patrón bien conocido, sino un idioma estándar en C (y C ++)

while(true)

genera una advertencia con Visual Studio (la condición es constante). La mayoría de los lugares en los que he trabajado compilan compilaciones de producción con advertencias como errores. Entonces

for(;;)

se prefiere.

Ambos deberían ser iguales si su compilador optimiza su código. Para explicar lo que quiero decir con optimización, aquí hay un código de muestra escrito en MSVC 10:

int x = 0;

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

    printf("%d", x);
}

Si lo compila en modo de depuración ( sin optimización (/ Od) ), el desmontaje muestra la clara diferencia. Hay instrucciones adicionales para la truecondición en el interior 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)  

Sin embargo, si construye su código en modo Release (con la velocidad de maximización predeterminada (/ O2) ) obtendrá la misma salida para ambos. Ambos bucles se reducen a una instrucción de 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)  

Cualquier cosa que use no importa para un compilador decente con optimización de velocidad activada.

Es una cuestión de preferencia personal qué camino es más rápido. Personalmente, soy un touchtypist y nunca miro mi teclado, durante la programación, puedo tipear las 104 teclas de mi teclado.

Me parece más rápido escribir "while (TRUE)".

Agregué mentalmente algunas medidas de movimiento de los dedos y las totalicé. "for (;;)" tiene aproximadamente 12 anchuras de tecla de movimientos hacia atrás y cuarto (entre las teclas de inicio y las teclas, y entre las teclas de inicio y la tecla MAYÚS) "while (TRUE)" tiene aproximadamente 14 anchuras de teclas de movimientos hacia atrás y cuarto.

Sin embargo, soy mucho menos propenso a errores al escribir este último. Pienso mentalmente en palabras a la vez, por lo que me resulta más rápido escribir cosas como "nIndex" que acrónimos como "nIdx" porque tengo que deletrear mentalmente las letras en lugar de decirlas dentro de mi mente y dejar que mis dedos se auto -tipear la palabra (como andar en bicicleta)

(Mi referencia de TypingTest.com = 136 WPM)

Todas buenas respuestas: el comportamiento debe ser exactamente el mismo.

SIN EMBARGO - Solo suponga que HIZO la diferencia. Supongamos que uno de ellos toma 3 instrucciones más por iteración.

¿Te debería importar?

SOLO si lo que haces dentro del bucle es casi nada , lo cual casi nunca es el caso.

Mi punto es que hay micro-optimización y macro-optimización. La microoptimización es como "cortarse el pelo para perder peso".

No puedo imaginar que un compilador valioso generaría un código diferente. Incluso si lo hiciera, no habría forma de determinar sin probar el compilador particular que era más eficiente.

Sin embargo, sugiero que prefiera for(;;)por las siguientes razones:

• Varios compiladores que he utilizado generarán una advertencia de expresión constante para while (verdadero) con la configuración de nivel de advertencia adecuada.

• en su ejemplo, la macro VERDADERO puede no estar definida como espera

• Hay muchas posibles variantes de la infinita mientras bucle tales como while(1), while(true), while(1==1)etc .; así for(;;)es probable que resulte en una mayor consistencia.

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

Es más claro que:

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

No es que esto se aplique si no lo está usando Sleep().

El bucle "para siempre" es popular en los sistemas integrados como un bucle de fondo. Algunas personas lo implementan como:

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

Y a veces se implementa como:

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

Y otra implementación más es:

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

Un compilador de optimización debería generar el mismo código de ensamblaje o uno similar para estos fragmentos. Una nota importante: el tiempo de ejecución de los bucles no es una gran preocupación ya que estos bucles duran para siempre y se dedica más tiempo a la sección de procesamiento.

Supongo que while (true) es más legible que for (;;): parece que el programador pierde algo en for loop :)

La razón más importante para usar "for (;;)" es el miedo a usar "while (TRUE)" cuando haces programación exploratoria. Es más fácil controlar la cantidad de repeticiones con "for", y también, es más fácil convertir el bucle "for" en un infinito.

Por ejemplo, si está construyendo una función recursiva, puede limitar la cantidad de llamadas a la función antes de convertirla en un bucle infinito.

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

Cuando estoy seguro de mi función, la convierto en un bucle infinito:

    for(;;) recursiveFunction(oneParam);