Différence entre la boucle "while" et "do while" en boucle

: votre condition est au début du bloc de boucle, et rend possible pour ne jamais entrer dans la boucle.

Do While: votre condition est à la fin du bloc de boucle, et rend obligatoire pour entrer dans la boucle au moins une fois.

do {
    printf("Word length... ");
    scanf("%d", &wdlen);
} while(wdlen<2);

garantit l'exécution de la boucle au moins une fois car elle vérifie la condition de la boucle après l'itération de la boucle. Par conséquent, il imprimera la chaîne de caractères et appellera scanf, mettant ainsi à jour la variable wdlen.

while(wdlen<2){
    printf("Word length... ");
    scanf("%d", &wdlen);
} 

pour le while boucle, il évalue l'état de la boucle avant que le corps de boucle ne soit exécuté. wdlen probablement commence comme plus de 2 dans votre code c'est pourquoi vous n'atteindrez jamais le corps de la boucle.

do dans une boucle de contrôle de sortie. while est une boucle de contrôle d'entrée.

la différence est dans quand la condition est évaluée. Dans un do..while boucle, la condition n'est évaluée qu'à la fin de chaque boucle. Cela signifie qu'un do..while boucle toujours exécuter au moins une fois. Dans un while boucle, la condition est évaluée au départ.

Ici je suppose que wdlen est évalué à false (i.e., il est plus grand que 1) au début de la while boucle, donc la boucle while ne tourne jamais. Dans le do..while boucle, il n'est pas vérifié jusqu'à ce que le fin de la première boucle, donc vous obtenez le résultat que vous attendez.

Do while boucle sera exécutée au moins une fois.......mais boucle de vérifier l'état en premier et ensuite il peut ou ne peut pas exécuté selon la condition.

dans votre exemple wdlen peut supposer n'importe quelle valeur d'ordures qui est > 2 donc boucle ne sera jamais exécuté.

alors que do while boucle sera ececuted et vous dira d'entrer la valeur et de vérifier que la valeur en finissant condition

Alors:

1. boucle de contrôle d'entrée

2. condition est vérifiée avant l'exécution de la boucle

3. n'exécute jamais de boucle si la condition est fausse

4. il n'y a pas de point-virgule à la fin de l'instruction while

Do-while:

1. boucle de contrôle de sortie

2. l'état est vérifié à la fin de boucle

3. exécute false condition au moins une fois puisque la condition est cochée plus tard

4. il y a un point-virgule à la fin de la déclaration while.

Probablement wdlen commence avec une valeur >=2, donc dans le second cas la condition de boucle est initialement false et la boucle n'est jamais entrée.

dans le second cas le corps de boucle est exécuté avant le wdlen<2 condition est vérifiée pour la première fois, de sorte que le printf/scanf est exécutée au moins une fois.

faire pendant que loop sera exécuté au moins une fois.......mais pendant que loop vérifiera la condition d'abord et puis il peut ou ne peut pas être exécuté en fonction de la condition. Tout : votre état est au début de la boucle bloc, et permet de ne jamais entrer dans la boucle.

faire pendant que: votre condition est à la fin du bloc de boucle, et rend obligatoire d'entrer dans la boucle au moins une fois.

tester le condition avant d'exécuter instructions dans le boucle.

do while tester le condition après avoir exécuté déclaration dans la boucle.

source: laissez-nous C

tout en testant la condition avant exécuter des instructions dans la boucle while.

do while test de la condition après instruction exécutée à l'intérieur de la boucle.

In tout d'abord vérifier la condition et ensuite exécuter le programme Dans do-WHILE loop, exécutez d'abord le programme au moins une fois, puis vérifiez la condition

la différence entre do while (exit check) Et while (entry check) est que lors de l'entrée dans do alors qu'il ne vérifiera pas mais qu'il vérifiera d'abord

L'exemple est comme suit:

programme 1:

int a=10;
do{
System.out.println(a);
}
while(a<10);

//here the a is not less than 10 then also it will execute once as it will execute do while exiting it checks that a is not less than 10 so it will exit the loop

programme 2:

int b=0;
while(b<10)
{
System.out.println(b);
}
//here nothing will be printed as the value of b is not less than 10 and it will not let enter the loop and will exit

programme de sortie 1:

10

programme de sortie 2:

[rien n'est imprimé]

remarque:

sortie du programme 1 et programme 2 sera même si nous cédons a=0 et b=0 et aussi mettre un++; b++; dans le corps du programme.

Boucle While:

while(test-condition)
{
      statements;
      increment/decrement;
}

1. Réduction Du Temps d'exécution et de la vitesse
2. Entrée Boucle Conditionnée
3. Pas de nombre fixe d'itérations

Boucle Do While:

do
{
      statements;
      increment/decrement;
}while(test-condition);

1. plus de temps et de vitesse d'exécution
2. Boucle Conditionnée À La Sortie
3. Minimum un nombre d'itération

en savoir plus sur ce sujet ici: Différence Entre Les et la Boucle Do While

ceci est valable pour la programmation C, la programmation Java et d'autres langages aussi parce que les concepts restent les mêmes, seulement la syntaxe change.

aussi, un autre petit mais différenciant facteur à noter est que la boucle do while se compose d'un point-virgule à la fin de la condition while.

La différence entre un while construit à partir de L'Étape 1 versus a do while c'est que toutes les expressions au sein de la do {} sera exécuté au moins une fois quelle que soit la condition dans le while() l'article.

println("\nStep 2: How to use do while loop in Scala")
var numberOfDonutsBaked = 0
do {
  numberOfDonutsBaked += 1
  println(s"Number of donuts baked = $numberOfDonutsBaked")
} while (numberOfDonutsBaked < 5)

Voici une explication détaillée:Explication Visitez: coderforevers

while(wdlen<2){
  ...
 }  

si wdlen (en supposant qu'il s'agit d'une variable de pile) n'est pas initialisée ou assignée une valeur avant que la boucle while soit entrée, elle contiendra ce qui était dans cet espace en mémoire avant (c'est-à-dire les ordures). Donc si la valeur de la corbeille est < 2, la boucle s'exécute, sinon elle ne s'exécute pas.

do{
 ...
}while(wdlen<2)

exécutera une fois et puis vérifiera la condition pour lancer à nouveau loop, et cette fois il pourrait réussir si par hasard wdlen qui est uninitialized est trouvé à moins de 2.