Que signifie pour (;;)?

Je suis confus par la construction for(;;) . Je pense que c’est une forme de raccourci pour une boucle illimitée, mais je ne peux pas en être sûr.

Voici le code:

 for(;;) { //whatever statements } 

Votre proposition est correcte. c’est une boucle infinie. * Ceci est un langage courant, bien que beaucoup de gens (y compris moi-même) croient que ce qui suit est moins crypté:

 while (1) { whatever statements; } 

* C’est infini en supposant qu’il n’y ait pas de break / return / etc. déclarations à l’intérieur du corps de la boucle.

C’est une boucle sans fin. Il est parfois écrit avec un while :

 while (1) 

ou même mieux:

 while (true) 

Je m’attendrais à voir une break ou un return dans une telle boucle, peu importe si elle est écrite avec for ou while . Il doit y avoir un stream de contrôle anormal ou ce sera vraiment une boucle infinie.

Oui, c’est la syntaxe for C avec des champs vides pour l’expression d’initialisation, la condition de boucle et l’expression d’incrémentation.

L’instruction for peut également utiliser plusieurs valeurs, comme dans l’exemple suivant:

 for (i=0, j=100, k=1000; j < 500 || i<50 || k==5000; i++, j+=2, k*=6) {}; 

Peut-être un pas de plus for comprendre? =)

Oui, les expressions dans la boucle for sont simplement optionnelles. si vous les omettez, vous obtiendrez une boucle infinie. Le moyen de sortir est de faire une pause ou de sortir, etc.

Cette déclaration est fondamentalement égale à:

 while(1) {} 

Il n’y a pas de début, pas de condition et pas d’étape.

Si je comprends bien, for (;;) crée une boucle délibérément non sortante. Votre code est censé quitter la boucle en fonction d’une ou de plusieurs conditions. Cela m’était une fois un moyen plus simple d’avoir une boucle do while false, qui n’était pas considérée comme une bonne syntaxe. En fonction de la condition de sortie, il est plus facile d’envoyer une fonction pour gérer le résultat, l’échec, l’avertissement ou le succès, par exemple.

Mon explication n’est peut-être pas la raison pour laquelle quelqu’un a utilisé cette construction, mais je vais expliquer plus en détail ce que cela signifie pour moi. Cette construction peut être le moyen “pur C” de créer une boucle dans laquelle vous pouvez effectuer plusieurs étapes en série, dont l’achèvement signifie que votre application a exécuté toutes les étapes de l’initialisation.

 #define GEN_FAILURE -99 #define SUCCESS 0 /* perform_init_step1() and perform_init_step2() are dummy place-holder functions that provide a complete example. You could at least have one of them return non-zero for testing. */ int perform_init_step1(); int perform_init_step2(); int perform_init_step1() { return 0; } int perform_init_step2() { return 0; } int ret_code = GEN_FAILURE; for(;;) { if(SUCCESS != perform_init_step1()) { ret_code = -1; break; } if(SUCCESS != perform_init_step2()) { ret_code = -2; break; } break; } 

Si une partie de l’initialisation échoue, la boucle est abandonnée avec un code d’erreur spécifique.

Je suis arrivé à utiliser C après avoir beaucoup travaillé avec le firmware, en écrivant en langage assembleur. Les bons programmeurs de langage d’assemblage m’ont appris à avoir un seul point d’entrée et une seule sortie. J’ai pris leurs conseils à cœur, car leur credo les a aidés énormément lors du débogage.

Personnellement, je n’ai jamais aimé la construction for (;;), car vous pouvez avoir une boucle infinie si vous oubliez de casser; à la fin.

Quelqu’un avec qui j’ai travaillé a fait do..il (FALSE), mais la quantité de C de furvor que cela a provoquée n’était pas crédible.

 #define GEN_FAILURE -99 #define SUCCESS 0 /* perform_init_step1() and perform_init_step2() are dummy place-holder functions that provide a complete example. You could at least have one of them return non-zero for testing. */ int perform_init_step1(); int perform_init_step2(); int perform_init_step1() { return 0; } int perform_init_step2() { return 0; } int ret_code = GEN_FAILURE; do { if(SUCCESS != perform_init_step1()) { ret_code = -1; break; } if(SUCCESS != perform_init_step2()) { ret_code = -2; break; } } until (FALSE); 

Cela fonctionne une fois, peu importe quoi.