Faire des boucles à faire dans la langue C

Les boucles conditionnelles sont une excellente ressource dans la programmation. Ils peuvent être trouvés dans de nombreuses fonctions dans les différentes bibliothèques de langage C et avoir la tâche de répéter un extrait de code jusqu'à ce qu'il soit libéré de la boucle par une condition d'évasion.

Dans cet article de Linux Hint, vous apprendrez à utiliser la boucle conditionnelle à faire, une variante de la boucle «while» avec une méthode d'évasion différente qui est très utile dans certains cas.

Nous verrons les différentes options que le langage C offre pour les boucles conditionnelles et une brève description de chacun. Ensuite, nous allons jeter un aperçu détaillé du fonctionnement de la boucle de bricolage et d'expliquer sa méthode d'évasion et les opérations relationnelles qui le contrôlent. Nous appliquerons également ce que nous avons appris à travers les exemples pratiques avec des extraits de code et des images qui montrent l'utilisation de cette boucle conditionnelle dans différents cas.

Boucles conditionnelles dans le langage C

Une boucle conditionnelle répète l'exécution du code qu'elle ferment en accolades bouclées jusqu'à ce que la condition d'échappement soit remplie, qui libère le programme à partir de la boucle.

La condition d'échappement est déterminée par une opération relationnelle où un «faux» résultat quitte la boucle de programme tandis qu'un «vrai» résultat le maintient à l'intérieur.

L'expression de cette opération doit être enfermée entre parenthèses et doit être précédé du nom de la boucle comme indiqué dans les éléments suivants:

tandis que (opération relationnelle)

Ensuite, examinons une brève description des deux options de boucle conditionnelle qui sont fournies par la langue C. Chacun d'eux a une fonctionnalité qui s'adapte aux exigences particulières de l'affaire. Ensuite, nous examinerons la déclaration do-while, une variante de la boucle while, en détail.

Pendant la boucle

La boucle «while» conditionnelle répète son cycle tant que la valeur d'une variable ne satisfait pas à la condition d'échappement. Examinons un exemple où la condition d'échappement dans ce cas est «A» est égal à «0»:

tandis que (un!= 0)
//code…

Pour boucle

La boucle «pour» fournit un moyen de déclarer une variable et d'appliquer une opération relationnelle au résultat d'une opération arithmétique ou logique sur cette variable. Si le résultat de la relation est faux, le programme quitte la boucle et poursuit son exécution. Si le résultat ne correspond pas, la boucle se répète de la même manière que la boucle «while». Regardons la syntaxe de cette boucle conditionnelle:

pour (Déclaration variable, opération relationnelle, opération arithmétique)

Dans l'illustration suivante, nous voyons un fragment de code dans lequel la variable a est déclarée avec la valeur 0, l'opération arithmétique «A + 2» est appliquée, et l'opération relationnelle «A!= 100 ”est appliqué au résultat:

pour (int a = 0; a!= 100; a + 2)
//code

Dans ce cas, le programme passe à travers 50 cycles de la boucle «pour» avant de sortir de celui-ci.

Syntaxe de boucle à faire dans le langage C

faire
code…
while (condition);

Description et des exemples de la déclaration de bricolage conditionnelle dans la langue C

L'énoncé de bricolage conditionnel fonctionne de la même manière que la déclaration While, mais dans l'ordre inverse. Autrement dit, «While» analyse la condition d'échappement au début de la boucle, et «faire» le fait à la fin. Cela garantit que le programme traverse le code en entourant la boucle au moins une fois, que la condition d'échappement soit remplie ou non.

La différence entre les instructions «while» et «do- while» est le point de la boucle où la sortie est déterminée. Examinons ce qui se passe dans une boucle «while» lorsque la condition d'échappement est spécifiée avant de l'entrer:

#inclure
vide main ()

printf ("\ nstart Program… \ n");
pendant (0 != 0)
printf ("\ ninside boucle \ n");

printf ("\ nend programme \ n");

Dans la figure suivante, nous voyons le résultat de la compilation et de l'exécution de ce code. Étant donné que la condition d'échappement a été donnée avant la fin de la boucle «while», le programme saute jusqu'à la fin de la boucle sans exécuter le code à l'intérieur.

Voyons ce qui se passe si nous remplissons l'instruction «while» par une instruction «do-while» par la même condition:

#inclure
vide main ()

printf ("\ nstart Program… \ n");
faire
printf ("\ ninside boucle \ n");
while (0 != 0);
printf ("\ nend programme \ n");

Dans la figure suivante, nous voyons le résultat de la compilation et de l'exécution de ce code.
Comme vous pouvez le voir, bien que la condition d'échappement soit spécifiée avant d'entrer dans la boucle, comme dans l'exemple précédent, le programme dans ce cas s'y entre et exécute le code One Pass.

Boucs à faire à faire dans la langue C

Tout comme les autres boucles conditionnelles, la langue C permet la nidification des boucles «do- while». Nous voyons un exemple où l'une de ces boucles est imbriquée à l'intérieur d'un autre comme indiqué dans ce qui suit:

#inclure
vide main ()

int a = 3;
int b = 3;
printf ("\ nstart Program…");
faire
printf ("\ nloop 1");
un--;
faire
printf ("\ n Loop 2");
b--;
tandis que (b != 0);
b = 3;
tandis que (un != 0);
printf ("\ nend programme \ n");

L'image que nous voyons dans l'illustration suivante montre la compilation et l'exécution de ce code où deux boucles «à faire» imbriquées sont exécutées.

Conclusion

Dans cet article de Linux Hint, nous vous avons montré comment utiliser la boucle «Do-While» conditionnelle.
Nous avons commencé par une introduction qui explique de quoi consistent les boucles conditionnelles et discutées des différentes options disponibles dans la langue C, décrivant brièvement chacun d'eux, leur développement et leur utilisation.

Nous avons également discuté des détails avec l'explication théorique de la boucle «do-.

Nous mettons ensuite ce que nous avons appris en pratique avec des extraits de code et des images qui montrent comment développer un programme avec les boucles «à faire» simples ou imbriquées.