Est-il toujours un besoin pour un “do {...} while ( )” de la boucle?

do-while est une boucle avec une post-condition. Vous en avez besoin dans les cas où le corps de la boucle est exécutée au moins une fois. Ceci est nécessaire pour que le code qui a besoin d'une action avant de la condition de la boucle peut être raisonnablement évalué. Avec boucle while vous devez appeler le code d'initialisation de deux sites, avec le faire-alors que vous ne pouvez l'appeler à partir d'un seul site.

Un autre exemple est lorsque vous avez déjà un objet valide lors de la première itération est commencé, de sorte que vous ne souhaitez pas exécuter quoi que ce soit (condition de boucle d'évaluation inclus) avant la première itération commence. Un exemple en est avec FindFirstFile/FindNextFile fonctions Win32: vous appelez FindFirstFile qui renvoie soit à une erreur ou à une recherche de la poignée pour le premier fichier, puis vous appelez FindNextFile jusqu'à ce qu'il renvoie une erreur.

Pseudocode:

Handle handle;
Params params;
if( ( handle = FindFirstFile( params ) ) != Error ) {
   do {
      process( params ); //process found file
   } while( ( handle = FindNextFile( params ) ) != Error ) );
}

C'est utile quand vous voulez "faire" quelque chose "jusqu'à" une condition est satisfaite.

Il peut être truqués dans une boucle while comme ceci:

while(true)
{

    //.... code .....

    if(condition_satisfied) 
        break;
}

Dans nos conventions de codage

• si /si /... conditions n'ont pas d'effets secondaires et
• varibles doit être initialisé.

Donc, nous n'avons presque jamais un do {} while(xx)
Parce que:

int main() {
    char c;

    do {
        printf("enter a number");
        scanf("%c", &c);

    } while (c < '0' ||  c > '9'); 
}

est remanié:

int main() {
    char c(0);
    while (c < '0' ||  c > '9');  {
        printf("enter a number");
        scanf("%c", &c);
    } 
}

et

Handle handle;
Params params;
if( ( handle = FindFirstFile( params ) ) != Error ) {
   do {
      process( params ); //process found file
   } while( ( handle = FindNextFile( params ) ) != Error ) );
}

est remanié:

Params params(xxx);
Handle handle = FindFirstFile( params );
while( handle!=Error ) {
    process( params ); //process found file
    handle = FindNextFile( params );
}

Il est tout au sujet de lisibilité.

Un code plus lisible conduit à moins de maux de tête dans la maintenance du code, et une meilleure collaboration.

D'autres considérations telles que l'optimisation) sont, de loin, le moins important dans la plupart des cas.

Je vais essayer d'approfondir, depuis que j'ai eu un commentaire ici:

Si vous avez un extrait de code Un qui utilise do { ... } while(), et c'est plus lisible que ses while() {...} équivalent B, alors je vais voter pour Un. Si vous préférez B, puisque vous voyez la condition de la boucle "à l'avant", et vous pensez que c'est plus lisible (et donc facile à gérer, etc.) - alors allez-y, utilisez B.

Mon point est: utilisez le code est plus lisible pour vos yeux (et vos collègues de travail). Le choix est subjectif, bien sûr.

C'est plus propre alternative à-tandis que j'ai vu. C'est l'idiome recommandé pour Python qui n'ont pas un do-while.

Seul inconvénient est que vous ne pouvez pas avoir un continue dans le <setup code> car il serait sauter à la condition d'arrêt, mais aucun de ces exemples qui démontrent les avantages de le faire-tout besoin d'un poursuivre, devant l'état.

while (true) {
       <setup code>
       if (!condition) break;
       <loop body>
}

Ici, il est appliqué à certains des meilleurs exemples de l', tandis que les boucles ci-dessus.

while (true);  {
    printf("enter a number");
    scanf("%c", &c);
    if (!(c < '0' ||  c > '9')) break;
} 

L'exemple suivant est un cas où la structure est plus lisible qu'un faire-alors que la condition est conservée à proximité de la haut que //get data est généralement de courte encore la //process data partie peut être longue.

while (true);  {
    //get data 
    if (data == null) break;
    //process data
    //process it some more
    //have a lot of cases etc.
    //wow, we're almost done.
    //oops, just one more thing.
} 

En réponse à une question/commentaire de l'inconnu (google) à la réponse de Dan Olson:

"do { ... } while (0) est une notion importante pour faire des macros à bien se comporter."

#define M do { doOneThing(); doAnother(); } while (0)
...
if (query) M;
...

Voyez-vous ce qui se passe sans la do { ... } while(0)? Il sera toujours exécuté doAnother().

Une boucle while peut toujours être réécrit comme une boucle while.

Que d'utiliser uniquement en boucles, ou while, do-while, et pour des boucles (ou toute combinaison de ceux-ci) dépend de votre goût pour l'esthétique et les conventions de la le projet sur lequel vous travaillez.

Personnellement, je préfère tout-boucles car il simplifie le raisonnement sur les invariants de boucle à mon humble avis.

Si il y a des situations où vous avez besoin, tandis que les boucles: au Lieu de

do
{
  loopBody();
} while (condition());

vous pouvez toujours

loopBody();
while(condition())
{
  loopBody();
}

donc, non, vous n'avez jamais besoin de l'utiliser, tandis que si vous ne pouvez pas pour une raison quelconque. (Bien entendu, cet exemple viole SEC, mais c'est seulement une preuve de concept. Dans mon expérience, il est généralement un moyen de transformer un do-while pour une boucle while et de ne pas violer SEC en aucun cas concret d'utilisation.)

"When in Rome, fais comme les Romains."

BTW: Le devis que vous cherchez est peut-être celui-ci ([1], le dernier alinéa de l'article 6.3.3):

De mon expérience, la déclaration est une source d'erreur et de confusion. La raison en est que son corps est toujours exécutée une fois avant que la condition est testée. Pour le bon fonctionnement de l'organisme, cependant, un état semblable à l'état final doit tenir dans la première manche. Plus souvent que ce que j'attendais, j'ai trouvé que ces conditions n'est pas vrai. Ce fut le cas à la fois quand j'ai écrit le programme en question à partir de zéro et puis testé ainsi qu'après un changement de code. En outre, je préfère la condition "up-front, où je peux le voir". J'ai donc tendance à éviter de faire les relevés.

(Note: C'est ma traduction de l'édition allemande. Si vous possédez l'édition en anglais, n'hésitez pas à modifier le devis pour correspondre à sa formule originale. Malheureusement, Addison-Wesley déteste Google.)

[1] B. Stroustrup: Le langage de programmation C++. La 3e Édition. Addison-Wessley, La Lecture, 1997.

envisager quelque chose comme ceci:

int SumOfString(char* s)
{
    int res = 0;
    do
    {
        res += *s;
        ++s;
    } while (*s != '
int SumOfString(char* s)
{
int res = 0;
do
{
res += *s;
++s;
} while (*s != '\0');
}
');
}

Il se trouve que le '\0' est 0, mais j'espère que vous obtenez le point.

Peut-être bien que cela remonte à quelques pas, mais dans le cas de

do
{
     output("enter a number");
     int x = getInput();

     //do stuff with input
}while(x != 0);

Il serait possible, bien que pas forcément lisible pour utiliser

int x;
while(x = getInput())
{
    //do stuff with input
}

Maintenant, si vous souhaitez utiliser un nombre autre que 0 pour quitter la boucle

while((x = getInput()) != 4)
{
    //do stuff with input
}

Mais encore une fois, il y a une perte de lisibilité, pour ne pas mentionner qu'il est considéré comme une mauvaise pratique d'utiliser une instruction d'affectation à l'intérieur d'un conditionnel, je voulais juste faire remarquer qu'il y a de plus en plus compacts façons de le faire que d'attribuer un "réservés" de la valeur à indiquer à la boucle qu'elle est la première à travers.