Est-ce que «for (;;)» est plus rapide que «while (TRUE)»? Sinon, pourquoi les gens l'utilisent-ils?

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

J'ai beaucoup vu ce genre de chose utilisé, mais je pense que c'est plutôt étrange ... Ne serait-il pas beaucoup plus clair à dire while(true), ou quelque chose du genre ?

Je suppose que (comme c'est la raison pour laquelle beaucoup de programmeurs ont recours au code cryptique), c'est une petite marge plus rapide?

Pourquoi, et en vaut-il vraiment la peine? Si tel est le cas, pourquoi ne pas simplement le définir de cette façon:

#define while(true) for(;;)

Voir aussi: Quel est le plus rapide: while (1) ou while (2)?

1. Ce n'est pas plus rapide.
2. Si vous vous souciez vraiment, compilez avec la sortie de l'assembleur pour votre plate-forme et regardez pour voir.
3. Cela n'a pas d'importance. Cela n'a jamais d'importance. Écrivez vos boucles infinies comme vous le souhaitez.

Je préfère for(;;)pour deux raisons.

La première est que certains compilateurs produisent des avertissements sur while(true)(quelque chose comme "la condition de boucle est constante"). Éviter les avertissements est toujours une bonne chose à faire.

Un autre est que je pense que for(;;)c'est plus clair et plus révélateur. Je veux une boucle infinie. Cela n'a littéralement aucune condition, cela ne dépend de rien. Je veux juste que ça continue pour toujours, jusqu'à ce que je fasse quelque chose pour m'en sortir.

Alors qu'avec while(true), eh bien, qu'est-ce qui est vrai a à voir avec quoi que ce soit? Je ne suis pas intéressé par la boucle jusqu'à ce que true devienne faux, ce que dit littéralement cette forme (boucle alors que true est vrai). Je veux juste faire une boucle.

Et non, il n'y a absolument aucune différence de performance.

Personnellement, j'utilise for (;;)parce qu'il n'y a pas de chiffres, c'est juste un mot-clé. Je préfère à while (true), while (1), while (42), while (!0)etc , etc.

À cause de Dennis Ritchie

• J'ai commencé à utiliser for (;;)parce que c'est ainsi que Dennis Ritchie le fait en K&R, et lorsque j'apprends une nouvelle langue, j'essaie toujours d'imiter les gars intelligents.

• C'est du C / C ++ idiomatique. Il est probablement préférable à long terme de s'y habituer si vous prévoyez de faire beaucoup dans l'espace C / C ++.

• Votre #definevolonté de travail pas, puisque la chose étant # define'd doit ressembler à un identifiant C.

• Tous les compilateurs modernes généreront le même code pour les deux constructions.

Ce n'est certainement pas plus rapide dans un compilateur sensé. Ils seront tous deux compilés en sauts inconditionnels. La version for est plus facile à taper (comme l'a dit Neil) et sera claire si vous comprenez la syntaxe de la boucle for.

Si vous êtes curieux, voici ce que me donne gcc 4.4.1 pour x86. Les deux utilisent l' instruction JMP x86 .

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

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

compile en (en partie):

.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

Je préfère for (;;)parce que c'est le plus cohérent dans différents langages de type C.

En C ++, while (true)c'est bien, mais en C vous dépendez d'un en-tête à définir true, mais TRUEc'est aussi une macro couramment utilisée. Si vous utilisez, while (1)c'est correct en C et C ++ et JavaScript, mais pas en Java ou C #, qui nécessitent que la condition de boucle soit un booléen, tel que while (true)ou while (1 == 1). En PHP, les mots-clés sont insensibles à la casse mais le langage préfère la capitalisation TRUE.

Cependant, for (;;)est toujours tout à fait correct dans toutes ces langues.

Je préfère personnellement l' for (;;)idiome (qui compilera avec le même code que while (TRUE).

L'utilisation while (TRUE)peut être plus lisible dans un sens, j'ai décidé d'utiliser l' for (;;)idiome car il se démarque .

Une construction de boucle infinie devrait être facilement remarquée ou appelée dans le code, et je pense personnellement que le for (;;)style le fait un peu mieux que while (TRUE)ou while (1).

Aussi, je rappelle que certains compilateurs émettent des avertissements lorsque l'expression de contrôle d'une boucle while est une constante. Je ne pense pas que cela arrive trop souvent, mais juste le potentiel d'avertissements fallacieux est suffisant pour que je veuille l'éviter.

J'ai vu que certaines personnes la préfèrent parce qu'elles ont un #define quelque part comme ceci:

#define EVER ;;

Ce qui leur permet d'écrire ceci:

for (EVER)
{
    /* blah */
}

Qu'en est-il (si votre langue le prend en charge):

start:
/* BLAH */
goto start;

Il n'y a aucune différence en termes de code machine généré.

Cependant, juste pour renverser la tendance, je dirais que le formulaire while (TRUE) est beaucoup plus lisible et intuitif que pour (;;), et que la lisibilité et la clarté sont des raisons beaucoup plus importantes pour les directives de codage que toutes les raisons pour lesquelles je '' J'ai entendu parler de l'approche for (;;) (je préfère fonder mes directives de codage sur un raisonnement solide et / ou une preuve d'efficacité moi-même).

Pas seulement un modèle bien connu, mais un idiome standard en C (et C ++)

while(true)

génère un avertissement avec Visual Studio (la condition est constante). La plupart des endroits où j'ai travaillé compilent des versions de production avec des avertissements comme des erreurs. Alors

for(;;)

est préféré.

Les deux doivent être identiques si votre code est optimisé par le compilateur. Pour expliquer ce que j'entends par optimisation, voici un exemple de code écrit dans MSVC 10:

int x = 0;

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

    printf("%d", x);
}

Si vous le construisez en mode Débogage ( sans aucune optimisation (/ Od) ), le démontage montre la différence claire. Il y a des instructions supplémentaires pour l' trueétat à l'intérieur 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)  

Cependant, si vous créez votre code en mode Release (avec Maximize Speed ​​(/ O2) par défaut ), vous obtenez la même sortie pour les deux. Les deux boucles sont réduites à une instruction de saut.

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)  

Celui que vous utiliserez n'a pas d'importance pour un compilateur décent avec l'optimisation de la vitesse.

C'est une question de préférence personnelle qui est le plus rapide. Personnellement, je suis un touchtypist et je ne regarde jamais mon clavier, pendant la programmation - je peux toucher les 104 touches de mon clavier.

Je trouve plus rapide de taper "while (TRUE)".

J'ai ajouté mentalement quelques mesures de mouvement des doigts et les ai totalisées. "for (;;)" a environ 12 largeurs de touches de mouvements en arrière et en quatrième (entre les touches d'accueil et les touches, et entre les touches d'accueil et la touche SHIFT) "tandis que (TRUE)" a environ 14 largeurs de touches de mouvements en arrière et Quatrième.

Cependant, je suis beaucoup moins sujet aux erreurs lors de la saisie de ce dernier. Je pense mentalement en mots à la fois, donc je trouve plus rapide de taper des choses comme "nIndex" que des acronymes comme "nIdx" parce que je dois en fait épeler mentalement le lettrage plutôt que de le dire dans mon esprit et laisser mes doigts s'auto -tapez le mot (comme faire du vélo)

(Mon benchmark TypingTest.com = 136 WPM)

Toutes les bonnes réponses - le comportement doit être exactement le même.

TOUTEFOIS - Supposons simplement que cela ait fait une différence. Supposons que l'un d'eux prenne 3 instructions supplémentaires par itération.

Devez-vous vous en soucier?

UNIQUEMENT si ce que vous faites à l'intérieur de la boucle n'est presque rien , ce qui n'est presque jamais le cas.

Mon point est, il y a la micro-optimisation et la macro-optimisation. La micro-optimisation, c'est comme «se faire couper les cheveux pour perdre du poids».

Je ne peux pas imaginer qu'un compilateur valable générerait un code différent. Même si c'était le cas, il n'y aurait aucun moyen de déterminer sans tester le compilateur particulier qui était plus efficace.

Cependant, je vous suggère de préférer for(;;)pour les raisons suivantes:

• un certain nombre de compilateurs que j'ai utilisés généreront un avertissement d'expression constante pour while (true) avec les paramètres de niveau d'avertissement appropriés.

• dans votre exemple, la macro TRUE peut ne pas être définie comme prévu

• il existe de nombreuses variantes possibles de l'infini en boucle tels que while(1), while(true), while(1==1)etc .; il for(;;)en résultera probablement une plus grande cohérence.

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

Est un plus clair que:

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

Non pas que cela s'applique si vous n'utilisez pas Sleep().

La boucle «pour toujours» est populaire dans les systèmes embarqués en tant que boucle d'arrière-plan. Certaines personnes l'implémentent comme:

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

Et parfois, il est implémenté comme:

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

Et encore une autre implémentation est:

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

Un compilateur d'optimisation doit générer le même code d'assembly ou un code similaire pour ces fragments. Une note importante: le temps d'exécution des boucles n'est pas un gros problème car ces boucles durent indéfiniment, et plus de temps est passé dans la section de traitement.

Je suppose que while (true) est plus lisible que for (;;) - il semble que le programmeur manque quelque chose dans la boucle for :)

La raison la plus importante d'utiliser "for (;;)" est la peur d'utiliser "while (TRUE)" lorsque vous faites de la programmation exploratoire. Il est plus facile de contrôler le nombre de répétitions avec "for", et aussi, plus facile de convertir la boucle "for" en une boucle infinie.

Par exemple, si vous construisez une fonction récursive, vous pouvez limiter le nombre d'appels à la fonction avant de la convertir en une boucle infinie.

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

Lorsque je suis sûr de ma fonction, je la convertis en une boucle infinie:

    for(;;) recursiveFunction(oneParam);