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

164
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)?

Chris Cooper
la source
51
Qu'est-ce que TRUE???
Du
20
@Steven Sudit: Qu'est-ce qui TRUEa à voir avec C? La macro standard pour le résultat boolen vrai dans C99 est toujours true. D'où TRUEvient le?
Du
31
Cette macro ne fonctionne pas, #define EVER ;;a été utilisée dans IOCCC cependant .. :)
18
N'est-ce pas cette macro pour #define while(TRUE)déclarer une macro qui prend un argument appelé TRUEqui n'est jamais utilisé, transformant donc chaque boucle while de votre programme en une boucle infinie?
AshleysBrain
9
@Steven Sudit: Non. Il n'y a pas de "macro standard dans VS 6.0". La macro TRUEprovient des fichiers d'en-tête associés à l'API Windows. Il n'est en aucun cas lié à VS 6.0. Et, comme je l'ai déjà dit, cela n'a rien à voir avec C ou C ++. En C ++, le "vrai" littéral est juste true(dans VS 6.0 également), en C89 / 90 il n'y a rien de tel du tout, et en C99 c'est macro true. Cela s'applique à tous les compilateurs C / C ++.
Du

Réponses:

262
  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.
Ben Zotto
la source
227
Intuitivement, l'optimisation d'une boucle infinie offre un potentiel d'accélération infinie. Heureusement que nous ne programmons pas sur l'intuition. :-)
Steven Sudit
5
Je suppose que tu as raison. Je pense que j'étais pris dans des débats «religieux» sur de petites choses. Merci d'avoir secoué ma conscience. : D
Chris Cooper
6
@Steven LOL, c'est intéressant, mais considérez que le seul scénario où vous avez réellement atteint ce potentiel d'accélération infinie est lorsque la boucle ne se rompt jamais et s'exécute vraiment à l'infini, ce qui est probablement un bogue, ou si prévu, sera une attente infinie avant d'atteindre ce potentiel.
AaronLS
7
@Chris. Dans la programmation comme dans la vie, les débats religieux ne valent que pour les choses qui comptent vraiment. Ce n'est tout simplement pas une de ces choses. Comme vous pouvez le voir, tout le monde a une façon familière d'écrire une boucle sans fin. Choisissez vous-même ce qui vous rend le plus heureux pour les petites choses, puis exécutez votre profileur sur le code qui compte. :)
Ben Zotto
3
Cela importait, car certains premiers compilateurs sur certaines plates-formes chargeaient une constante et en faisaient un saut conditionnel. Lequel de ces jours-là, le matériel importait.
peterchen
176

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.

jalf
la source
73
+1 pour éviter les avertissements. Mais quant à la clarté, je trouve bien plus clair que pour dans ce contexte. Je suppose que cet aspect se résume simplement à des préférences personnelles.
Tim
14
Oui, préférence et habitude. Si vous n'êtes pas habitué à voir for(;;), cela vous semblera évidemment étrange. Mais je vous conseille d' essayer de s'y habituer car il est un idiome commun, et vous allez courir en elle à nouveau. ;)
jalf
7
Le commentaire de jalf sur le fait qu'il est idiomatique est vraiment la réponse ici. Il est couramment utilisé pour « boucle infinie » tout simplement parce qu'il est le moyen couramment utilisé pour écrire « boucle infinie » en C. Il ne doit pas être une bonne raison pour un idiome - c'est juste une convention d'auto-renforcement.
caf
7
@ Steve: Je ne vois pas pourquoi je jamais utiliser for(;condition;). C'est ce qu'une boucle while est pour . Mais comme je l'ai dit, avec une boucle infinie, je ne veux pas vraiment que le compilateur compare n'importe quelle condition. Naïvement, avec une whileboucle, il faudrait tester truechaque itération (évidemment, même le compilateur le plus stupide ne le ferait pas, mais c'est le principe qui me dérange. Cela me semble trop spécifier votre code), alors qu'avec un for(;;)vous dites littéralement "il n'y a aucune condition à tester. Juste une boucle". Je le trouve l'équivalent le plus proche de votre imaginaireloop {...}
jalf
32
Votre compilateur est nul s'il while(true)donne un avertissement.
Albert
56

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.

ta.speot.is
la source
38
0, 1 et l'infini sont des nombres magiques acceptables, étendre 0 et 1 à faux et vrai n'est pas une perte. truen'est pas plus un nombre magique qu'un formot clé magique ou qui for(;;)utilise un infini magique implicite. ( while (42)est en effet une abomination.)
38
Tangente: un de mes professeurs CS a dit "il n'y a que trois nombres dans la programmation: 0, 1 et n. Tout le reste s'appelle un nombre magique."
Ben Zotto
21
while (42) est le plus cool, ne produit aucun résultat différent par rapport à while (1) ou while (true) ou while (! 0), et a une signification philosophique . Je suppose qu'il for(;;)est analysé plus rapidement que les autres de toute façon
ShinTakezou
2
@ShinTakezou beaucoup mieux à #define LIFE 42 while (LIFE):)
mr5
1
bien while(true)ne contient aucun numéro aussi. et pour (;;) n'est pas un mot
RiaD
49

À 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.

Mark Harrison
la source
10
Oui, c'est ainsi que vous savez que quelqu'un a appris le C de K&R, comme cela devrait être appris. Chaque fois que je vois while(TRUE), je soupçonne que le programmeur est un débutant en C, ou a appris le C à partir d'un livre For Dummies.
Kristopher Johnson
13
J'entends que ces débutants utilisent également un style de définition de fonction nouveau .
Justin
46

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
Matthew Flaschen
la source
Je doute que ce soit plus rapide même en mode débogage.
Steven Sudit
106
for_infiniteest plus rapide; 2 caractères de moins à puts.
Dave Jarvis
43

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.

Boann
la source
9
Merci pour votre réponse! Je pense que c'est en fait la première réponse qui montre une manière objective qui for (;;)est meilleure.
Chris Cooper le
8
Je ne pense pas avoir jamais eu besoin d'écrire un code correct en C, C ++, JavaScript, Java et C #. Ce sont des langues différentes.
Keith Thompson
6
@KeithThompson il ne s'agit pas d'écrire du code correct dans de nombreuses langues; Je pense qu'il s'agit d'éviter les erreurs d'interprétation entre des développeurs d'horizons différents.
Mauro Sampietro
6
@sam: Les deux while (1)et for (;;)sont des idiomes courants pour des boucles infinies en C. Quiconque lit un programme C qui a du mal à comprendre l'un ou l'autre aura probablement des problèmes avec le reste du code. Cela ne vaut pas la peine d'écrire du code C qui peut être facilement lu par quelqu'un qui ne connaît pas C.
Keith Thompson
6
@KeithThompson Alors qu'un lecteur compétent de C devrait certainement être familier avec les deux idiomes, cela pourrait également être utile si l'écrivain est un programmeur polyglotte. Lors de mon dernier travail, j'ai travaillé quotidiennement dans JS, ActionScript et PHP, et unifier la façon dont on écrit le code (là où cela est logique) peut rendre la programmation plus rapide et la maintenance plus facile.
Ionoclast Brigham
21

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.

Michael Burr
la source
17

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 */
}
rmeador
la source
24
J'ai vu ça aussi; mais ce n'est pas une bonne raison de le préférer. En tant que responsable, vous devrez toujours vérifier la définition de la macro pour être certain qu'elle a fait ce que vous attendez, alors que le code d'origine était assez clair. Le RTOS VxWorks a une macro FOREVERdéfinie for(;;), mais ce n'est pas mieux. Les macros de l'OMI ne doivent pas être utilisées pour «inventer» une nouvelle langue.
Clifford le
8
En fait, le but des macros dans certaines langues est d'inventer une nouvelle syntaxe. Mais peu importe «pour (EVER)» en C / C ++ est odieux.
Dan Olson
15
Certaines personnes font des choses amusantes, comme si elles aiment Pascal, elles disent #define BEGIN {et #define END }. J'ai même vu #define DONKEYS_FLY (0)pour qu'ils puissent dire if DONKEYS_FLY .... Qui a dit que le logiciel était ennuyeux?
Mike Dunlavey
11
En Californie, je crois que vous devez #define pour (;;) LIKE_FOREVER
Martin Beckett
1
Je n'ai pas pu résister: #define never while(0)et#define always
alfC
16

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

start:
/* BLAH */
goto start;
bungle
la source
... qui devrait générer une sortie identique entre les mains de tout compilateur raisonnable.
Ben Zotto
9
+1! Cela n'améliore pas gotoles nombreux inconvénients, mais si l'algorithme que vous essayez d'implémenter provient d'un organigramme, c'est la traduction la plus directe.
Edmund
4
Personnellement, j'ai une opinion utilitaire sur goto. Il n'y a pas de rapaces. Les rapaces sont des gens. Et ce sont les gens qui ont commencé à utiliser goto pour créer du code spaghetti. De plus, la sortie assemblée pour une boucle ressemble à peu près à ceci. Les jeux d'instructions pour les ordinateurs n'ont pas de concepts de "for" ou "while", juste "jump".
josaphatv
jamais jamais utilisergoto
Edward Karak
Ce qui est vraiment bien, gotoc'est que vous n'avez pas à vous soucier que quelqu'un ajoute un breakpour rendre votre boucle moins infinie. (sauf si vous êtes déjà dans une autre whileou une forboucle bien sûr ...)
12

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).

Jason Williams
la source
6
Cela dépend de votre langue. for(;;)est la manière traditionnelle de faire cela en C et C ++. while(true)semble être la convention en C # et Java et dans d'autres langages. Votre kilométrage peut varier.
Billy ONeal
9
Oui, et quelqu'un qui n'est pas très familier avec C ou C ++ pourrait trouver STRING_SCAN_FORMATTED plus lisible que sscanf, mais vous ne voyez personne mettre #define STRING_SCAN_FORMATTED sscanf en haut de leur code.
ta.speot.is
4
Je dirais que la façon de le faire idiomatiques avait mieux être le plus facile à lire à votre développeur. Sinon, vous avez vraiment besoin de meilleurs développeurs.
jalf
5
@despart: Si quelqu'un n'est pas assez familier avec C ++ pour reconnaître cet idiome pour ce qu'il est, alors il doit rester loin de ma base de code.
Billy ONeal
4
Je conviens que la manière idiomatique doit être la plus lisible. C'est pourquoi les manières idiomatiques doivent toujours être remises en question et modifiées à mesure que les langues et les pratiques évoluent. Il a fallu des années pour que le terrible style de codage «idiomatique» de K&R soit remplacé par un style moderne et plus lisible, mais cela s'est produit.
Jason Williams
11

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

James McLeod
la source
3
Oui, et je pense que certains compilateurs mettent en garde while (true)pour la même raison qu'ils le font if (true).
Steven Sudit
11
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é.

Michael
la source
7
quelle version de Visual Studio utilisez-vous? Avec 2008, je ne reçois pas cet avertissement, même au niveau d'avertissement 4.
Jörgen Sigvardsson
11

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.

SylvanNoir
la source
C'est en fait un très bon point! Sans optimisation, même les compilateurs modernes diffèrent par plusieurs instructions.
9

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)

Mark Rejhon
la source
3
Je crois que l'OP faisait référence à la vitesse d'exécution, pas à la vitesse de frappe.
Je connais. Je devais juste couvrir cette base aussi.
Mark Rejhon
7
s / préférence personnelle / habitude individuelle /
SamB
@SamB: Commentez-votez pour s ///. xD Et oui, même si j'ai suggéré que cela pouvait être dû à la vitesse d'exécution, je ne connaissais pas la réponse réelle. Si c'était ça, j'aurais été heureux.
Chris Cooper
Exécutez time head -10 >/dev/null, tapez chaque 10 fois et mesurez les résultats. Je parie que vous serez plus rapide à for(;;)moins de tricher. J'étais à environ 14%.
PSkocik
6

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».

Mike Dunlavey
la source
3
Comment voyez - vous souvent les gens ont dit préférer ++iplus i++?
Dennis Zickefoose
7
@Dennis Zickefoose: La différence entre ++iet i++peut être potentiellement significative si iest une instance d'une classe plutôt qu'une instance intégrée et que le compilateur n'applique pas l'optimisation triviale. Le conseil est d'acquérir une habitude pour qu'elle ne vous surprenne pas quand cela compte.
Clifford
5
Le truc à propos de ++ivs i++est que cela ne vous coûte rien pour faire "l'optimisation". Certes, dans la plupart des cas, cela ne fait absolument aucune différence, mais ils sont tout aussi faciles à taper, alors pourquoi ne pas préférer le plus efficace par défaut? Et je suppose que la même chose s'applique ici. Si l'un était un peu plus rapide que l'autre, pourquoi ne pas opter pour le plus rapide? Que perdrions-nous en le faisant? Les deux sont assez faciles à lire et à taper.
jalf
2
@Dennis Zickefoose: Vous avez raison. Je vois beaucoup cela sur SO, et le commentaire de Clifford est juste. De plus, il y a quelque chose que je ne vois pas beaucoup sur SO, et c'est comment faire de la macro-optimisation, comme un speedup 43x: stackoverflow.com/questions/926266/… . Je m'interroge donc sur nos priorités.
Mike Dunlavey
2
@Mike: Ouais, mais c'est une comparaison entre des pommes et des oranges. Se faire couper les cheveux prend du temps, et probablement même de l'argent. Je conviens que c'est une telle microoptimisation que cela n'a pas vraiment d'importance. Mais cela ne nous coûte rien non plus. si je peux choisir d'aller à gauche ou à droite et que la distance est la même, le terrain est le même, tout est pareil, sauf que le chemin de gauche a un avantage microscopique marginal, pourquoi ne pas aller à gauche? Vous avez raison, ce n'est pas un argument impressionnant. Mais lorsque le coût est littéralement nul, je ne vois aucune raison de préférer l'itinéraire le moins optimal.
jalf
5

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.

Clifford
la source
TRUE peut ne pas être #define TRUE 1, mais toute base de code dans laquelle while(TRUE)évalue comme while(0)n'est pas susceptible d'en bénéficier for(;;).
Justin
@Justin: Je suis d'accord, ce serait vraiment pervers, et ce n'est pas le plus fort des trois arguments, mais Bjarne Stoustrup utilise un argument similaire pour éviter la macro NULL en C ++. while(true)devrait être préféré dans tous les cas. En C ++ boolest réservé, et en C défini en C stdbool.h (ce qui le rend moins sûr en C). for(;;)supprime tout doute.
Clifford
5
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().

Armada
la source
1
C'est sacrément mauvais code, la minuterie devrait être utilisée au lieu de dormir, donc c'est un mauvais exemple
ST3
12
@ ST3 - Oui, vous avez raison. Mon code est horrible. Je devrais essayer plus fort la prochaine fois que je ferai une boucle infinie.
Armada
1
@Frammo - dépend de votre système d'exploitation, mais généralement quelque chose commetimerService.scheduleRepeating (50, [] () { /* lots of code */ });
Periata Breatta
2
Il n'y a rien de propre à appeler une fonction comme le sommeil à l'intérieur d'une boucle for comme ça
Greg
1
OMG, timerService.scheduleRepeating (50, [] () {}) est tellement plus facile à taper et à comprendre que sleep (50).
Cool Javelin
4

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.

Thomas Matthews
la source
8
Si un compilateur génère un code différent pour ceux-ci, il est temps d'abandonner le compilateur et d'en obtenir un des deux dernières décennies.
GManNickG
5
"le temps d'exécution des boucles n'est pas un gros problème puisque ces boucles
durent
3
@Blindy - parce que c'est faux, ce qui est préoccupant, c'est la fraction du temps d'exécution passé à traiter la logique de bouclage, ou la quantité de logique de bouclage par unité de travail utile, qui ne sont aidés par la boucle infinie
Ben Voigt
3

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

nik
la source
Je me soucie de la vitesse. Surtout s'il y a une optimisation qui affectera mon code des fois infinies.
Kowalski
2

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);
Ignacio Cortorreal
la source
3
La première boucle a une erreur de syntaxe (il manque un point-virgule).
Jens
3
Ha! Démontrant ainsi les inconvénients de for (;;);)
Andrew