"For (;;)" é mais rápido que "while (TRUE)"? Se não, por que as pessoas o usam?

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

Já vi esse tipo de coisa ser muito usada, mas acho que é bastante estranho ... Não seria muito mais claro dizer while(true)algo assim?

Estou supondo que (como é o motivo de muitos programadores recorrerem a códigos enigmáticos) essa é uma margem minúscula mais rápida?

Por que e realmente vale a pena? Se sim, por que não apenas defini-lo desta maneira:

#define while(true) for(;;)

Veja também: O que é mais rápido: while (1) ou while (2)?

1. Não é mais rápido.
2. Se você realmente se importa, compile com a saída do assembler para sua plataforma e veja.
3. Não importa. Isso nunca importa. Escreva seus loops infinitos como quiser.

Eu prefiro for(;;)por duas razões.

Uma é que alguns compiladores produzem avisos while(true)(algo como "condição de loop é constante"). Evitar avisos é sempre uma boa coisa a fazer.

Outra é que eu acho for(;;) mais claro e revelador. Eu quero um loop infinito. Literalmente não tem condição, não depende de nada. Eu só quero que continue para sempre, até que eu faça algo para sair disso.

Considerando que while(true), bem, o que é verdade tem a ver com alguma coisa? Não estou interessado em fazer loop até que true se torne falso, que é o que esta forma literalmente diz (faça loop enquanto true for verdadeiro). Eu só quero fazer um loop.

E não, não há absolutamente nenhuma diferença de desempenho.

Pessoalmente, eu uso for (;;)porque não há números, é apenas uma palavra-chave. I preferem a while (true), while (1), while (42), while (!0)etc etc.

Por causa de Dennis Ritchie

• Comecei a usar for (;;)porque é assim que Dennis Ritchie o faz em K&R e, ao aprender um novo idioma, sempre tento imitar os caras espertos.

• Isso é C / C ++ idiomático. Provavelmente, a longo prazo, é melhor se acostumar com isso, se você planeja fazer muito no espaço C / C ++.

• Você #definenão funcionará, já que a coisa que está sendo definida deve se parecer com um identificador C.

• Todos os compiladores modernos geram o mesmo código para as duas construções.

Certamente não é mais rápido em nenhum compilador são. Ambos serão compilados em saltos incondicionais. A versão for é mais fácil de digitar (como Neil disse) e ficará clara se você entender a sintaxe do loop.

Se você está curioso, aqui está o que o gcc 4.4.1 me fornece para x86. Ambos usam a instrução x86 JMP .

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

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

compila para (em 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

Eu prefiro for (;;)porque é o mais consistente em diferentes idiomas do tipo C.

Em C ++ while (true)é bom, mas em C você depende de um cabeçalho para definir true, mas também TRUEé uma macro comumente usada. Se você usá- while (1)lo, está correto em C e C ++ e JavaScript, mas não em Java ou C #, que exigem que a condição do loop seja booleana, como while (true)ou while (1 == 1). No PHP, as palavras-chave não diferenciam maiúsculas de minúsculas, mas o idioma prefere a capitalização TRUE.

No entanto, for (;;)sempre está completamente correto em todos esses idiomas.

Pessoalmente, prefiro o for (;;)idioma (que será compilado com o mesmo código que while (TRUE).

Usando while (TRUE)pode ser mais legível em um sentido, eu decidi usar o for (;;)idioma porque ele se destaca .

Uma construção de loop infinito deve ser facilmente percebida ou destacada no código, e eu pessoalmente acho que o for (;;)estilo faz isso um pouco melhor que while (TRUE)ou while (1).

Além disso, lembro que alguns compiladores emitem avisos quando a expressão de controle de um loop while é uma constante. Não acho que isso aconteça demais, mas apenas o potencial de avisos falsos é suficiente para que eu queira evitá-lo.

Eu já vi algumas pessoas preferirem porque têm um #define em algum lugar como este:

#define EVER ;;

O que lhes permite escrever isso:

for (EVER)
{
    /* blah */
}

E se (se o seu idioma suportar):

start:
/* BLAH */
goto start;

Não há diferença em termos do código de máquina que é gerado.

No entanto, apenas para reverter a tendência, eu argumentaria que a forma while (TRUE) é muito mais legível e intuitiva do que para (;;), e que legibilidade e clareza são razões muito mais importantes para diretrizes de codificação do que quaisquer outras razões pelas quais eu ' ouvi falar da abordagem for (;;) (prefiro basear minhas diretrizes de codificação em raciocínio sólido e / ou prova de eficácia).

Não apenas um padrão conhecido, mas um idioma padrão em C (e C ++)

while(true)

gera um aviso com o Visual Studio (a condição é constante). Na maioria dos lugares em que trabalhei, a produção de compilação é criada com avisos como erros. assim

for(;;)

é preferível.

Ambos devem ser iguais se o seu código for otimizado pelo compilador. Para explicar o que quero dizer com otimização, aqui está um código de exemplo escrito no MSVC 10:

int x = 0;

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

    printf("%d", x);
}

Se você construí-lo no modo Debug ( sem qualquer otimização (/ Od) ), a desmontagem mostra a clara diferença. Há instruções extras para a truecondição interna 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)  

No entanto, se você criar seu código no modo Release (com Maximize Speed ​​(/ O2) padrão ), obterá a mesma saída para ambos. Ambos os loops são reduzidos a uma instrução 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)  

O que você usar não importa para um compilador decente com a otimização de velocidade ativada.

É uma questão de preferência pessoal para que lado é mais rápido. Pessoalmente, sou um datilógrafo e nunca olho para o meu teclado durante a programação - posso digitar todas as 104 teclas do teclado.

Acho que se for mais rápido digitar "while (TRUE)".

Eu adicionei mentalmente algumas medidas de movimento dos dedos e as totalizei. "for (;;)" possui cerca de 12 larguras de teclas dos movimentos para trás e para a quarta (entre as teclas iniciais e as teclas e entre as teclas iniciais e a tecla SHIFT) "enquanto (TRUE)" possui cerca de 14 larguras de teclas dos movimentos para trás e quarto.

No entanto, sou muito menos propenso a erros ao digitar o último. Penso mentalmente em palavras de cada vez, por isso acho mais rápido digitar coisas como "nIndex" do que acrônimos como "nIdx" porque tenho que soletrar mentalmente as letras em vez de falar dentro da minha mente e deixar meus dedos automaticamente - digite a palavra (como andar de bicicleta)

(Meu benchmark TypingTest.com = 136 WPM)

Todas as boas respostas - o comportamento deve ser exatamente o mesmo.

NO ENTANTO - apenas suponha que isso fez a diferença. Suponha que um deles tenha mais 3 instruções por iteração.

Você deveria se importar?

SOMENTE se o que você faz dentro do loop é quase nada , o que quase nunca acontece.

O que quero dizer é que há micro-otimização e macro-otimização. Micro-otimização é como "cortar o cabelo para perder peso".

Não consigo imaginar que um compilador que valha a pena gere qualquer código diferente. Mesmo que isso acontecesse, não haveria maneira de determinar sem testar o compilador específico que era mais eficiente.

No entanto, sugiro que você prefira for(;;)pelos seguintes motivos:

• vários compiladores que eu usei gerarão um aviso de expressão constante por enquanto (true) com as configurações apropriadas do nível de aviso.

• no seu exemplo, a macro TRUE pode não ser definida como você espera

• existem muitas variantes possíveis do infinito quando laço, tais como while(1), while(true), while(1==1)etc .; então for(;;)é provável que resulte em maior consistência.

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

É mais claro que:

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

Não que isso se aplique se você não estiver usando Sleep().

O loop "para sempre" é popular em sistemas incorporados como um loop em segundo plano. Algumas pessoas o implementam como:

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

E às vezes é implementado como:

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

E ainda outra implementação é:

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

Um compilador de otimização deve gerar o mesmo código de montagem ou similar para esses fragmentos. Uma observação importante: o tempo de execução dos loops não é uma grande preocupação, pois esses loops duram para sempre e é gasto mais tempo na seção de processamento.

Presumo que (true) seja mais legível do que para (;;) - parece que o programador perde algo no loop for :)

O motivo mais importante para usar "for (;;)" é o medo de usar "while (TRUE)" ao executar a programação exploratória. É mais fácil controlar a quantidade de repetições com "for" e também mais fácil converter o loop "for" em um infinito.

Por exemplo, se você estiver construindo uma função recursiva, poderá limitar a quantidade de chamadas para a função antes de converter em um loop infinito.

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

Quando tenho certeza da minha função, eu a converto em um loop infinito:

    for(;;) recursiveFunction(oneParam);