Le code «while (condition);» est-il valide et que signifie-t-il?

Peut-on mettre un point-virgule comme while(condition); dans une programmation en C? Si while(condition); est valide, qu’est-ce que cela signifie?

 while (condition); 

est le même que

 while (condition) { } 

Il peut être utilisé pour les boucles d’attente, par exemple:

 while (!isLightGreen()); // waits until isLightGreen() returns true go(); 

Cela signifie que le corps de la boucle est vide. Généralement, ce modèle est utilisé lorsque la condition elle-même fonctionne.

Par exemple, cette boucle peut copier des octets dans la condition:

 while ( '\0' != (*pt++ = *ps++)) ; 

Si vous utilisez un point-virgule, c’est une bonne idée de le mettre sur une ligne distincte afin qu’il ressemble moins à une erreur. Personnellement, j’ai tendance à utiliser des accolades vides – {}, et parfois un commentaire indiquant que le bloc vide est intentionnel.

Modifier:

Dans le deuxième commentaire, Tom Anderson note une amélioration par rapport à un point-virgule isolé. Le guide de style C ++ de Google recommande soit ceci, soit {}.

 while ( '\0' != (*pt++ = *ps++)) continue; 

Oui, vous pouvez. Cela signifie simplement que la boucle while continuera à boucler jusqu’à ce que la condition soit fausse. Par exemple:

 #include int x = 10; int func() { printf("%d\n", x); return --x; } int main() { while(func()); return 0; } 

Mais généralement, les gens ne le font pas, car il serait plus logique de mettre la logique dans le corps de la boucle.

Modifier:

Il y a quelques exemples de cela en cours d’utilisation, par exemple, la copie d’une chaîne terminée par un zéro:

 char dest[256]; char *src = "abcdefghijklmnopqrstuvwxyz"; while(*(dest++) = *(src++)); 

Étant donné que la condition peut en réalité avoir des effets secondaires, une telle construction est autorisée. Considérer ce qui suit:

 while (*p && *p++ != ' '); 

Cela ferait avancer le pointeur p sur le premier caractère qui est un espace.

Vous pouvez même utiliser l’opérateur virgule pour avoir des déclarations ordinaires dans la condition:

 while (do_something(), do_something_else(), i < n); 

Etant donné que les instructions liées à l'opérateur de virgule sont évaluées à l'extrême droite, dans ce cas, i < n , ce qui précède est identique à

 do { do_something(); do_something_else(); } while (i < n); 

Il continuera d’évaluer la condition jusqu’à ce qu’elle soit fausse. C’est une boucle sans corps.

Les programmeurs ajoutent souvent un espace avant le point-virgule, c’est-à-dire

 while(condition) ; 

ou accolades vides:

 while(condition) {} 

montrer le corps vide est intentionnel et pas seulement une faute de frappe. Si vous lisez du code source existant et que vous vous demandez pourquoi il y a une boucle vide, vous devriez également lire les quelques lignes suivantes pour voir si le point-virgule doit vraiment être là ou non (c’est-à-dire que les lignes suivantes ressemblent au corps d’un message). boucle ou pas?).

Oui c’est correct. Il va boucler la condition jusqu’à ce que ce soit faux.

 while ( condition() ); 

J’écris toujours ceci comme:

 while (condition()) continue; 

Il est donc évident que ce n’était pas une erreur. Comme d’autres l’ont déjà dit, cela n’a de sens que lorsque condition () a des effets secondaires.

while () est une boucle. Vous cherchez probablement à faire une boucle “do-while”. Les boucles Do-While s’exécutent dans ce format:

 do { // Your process // When something goes wrong or you wish to terminate the loop, set condition to 0 or false } while(condition); 

Celui que vous avez énuméré ci-dessus, cependant, est une boucle vide.

tandis que les boucles () fonctionnent presque de la même façon; il n’y a tout simplement pas de “faire”.

Bonne chance!

Cela signifie que continuer à vérifier la condition jusqu’à ce qu’il soit évalué à faux

La clé pour comprendre cela est que la syntaxe de la boucle while en “C” est la suivante:

 while (condition) statement 

déclaration peut être toute déclaration “C” valide. Voici toutes les déclarations “C” valides:

 { statements } // a block statement that can group other statements statement; // a single statement terminated by a ; ; // a null statement terminated by a ; 

Ainsi, selon les règles de la boucle while , la partie instruction (instruction null dans votre exemple) sera exécutée (ne fera rien) tant que la condition est vraie . Ceci est utile car cela équivaut à une attente occupée jusqu’à ce que la condition devienne fausse . Pas un bon moyen d’attendre, mais utile quand même. Vous pouvez utiliser cette construction, par exemple, si vous souhaitez attendre qu’un autre thread (ou un gestionnaire de signal) définisse une variable avec une valeur avant de poursuivre.

Le code while(condition); est un code parfaitement valide, bien que ses utilisations soient peu nombreuses. Je présume que la condition est une variable et non une fonction – les autres discutent ici de la condition fonctionnelle.

Une utilisation de while(condition); peut être bloquer en attendant un signal, par exemple SIGHUP , où le gestionnaire de signal modifie la condition variable. Cependant, ce n’est généralement pas la meilleure façon d’attendre un signal. On utiliserait typiquement un sleep dans la boucle, c’est-à-dire while(condition) { sleep(1); } while(condition) { sleep(1); } .

L’absence de sleep signifie que la boucle sera continuellement traitée dans l’intervalle et entraînera probablement des cycles de traitement vides. À moins que le processus ait ses ressources gérées (et même là …), je pense que cela ne convient que lorsque la boucle doit être cassée dans un intervalle inférieur à la granularité de la commande de sleep disponible (c.-à-d. Que le sumil est granulé à la seconde, mais vous avez besoin du code après le look exécuté avec un temps de réponse inférieur à la seconde). Cela dit, un tuyau ou une prise de blocage peut être préférable aux signaux, en ce qui concerne les performances – bien que je ne dispose d’aucune donnée empirique à l’appui, et que les performances peuvent varier considérablement en fonction de la plate-forme.

Une condition peut être modifiée par un fil parallèle du même processus, mais je pense que nous devrions préférer le faire au moyen d’un mutex ou d’un sémaphore (la condition peut nécessiter davantage qu’une simple variable).

J’espère que c’est utile, ou du moins matière à reflection!

C’est juste une boucle vide. Cela aiderait si vous expliquiez quelle est la condition.

Si l’évaluation de la condition ne modifie pas une valeur qui influence la condition elle-même, while(condition); est une boucle infinie vide, ce qui signifie qu’elle ne se terminera jamais (et ne fera jamais que consumr du temps CPU).

c’est absolument correct. cela signifie ne rien faire dans la boucle, il suffit de scruter la condition. Et cela est courant dans les codes du système intégré.

C’est juste une boucle while sans corps d’exécution

 while(condition); 

est identique à

 while(condition) { } 

Juste un autre usage non décrit ici:

 do { if(out_of_memory) break; if(file_does_not_exist) break; return ok; } while(0); return error; 

Cela vous permet d’éviter plusieurs appels en retour ou instructions goto.