loop constructs c with examples
Une analyse approfondie des boucles en C ++ avec ses types.
En plus de Constructions décisionnelles que nous avons vu dans notre dernier tutoriel, il peut se produire des situations dans lesquelles nous devons exécuter un bloc d'instructions à plusieurs reprises.
Une telle situation nécessite que nous ayons une condition qui vérifie si le bloc de code doit être exécuté ou non. Ceci est fait par des constructions de boucle en programmation. C ++ a également diverses constructions de boucle qui nous permettent d'exécuter un bloc de code à plusieurs reprises ou jusqu'à ce qu'une condition soit vraie. Dans ce didacticiel, nous explorerons en détail ces constructions de boucle en C ++.
meilleur logiciel gratuit pour télécharger des vidéos youtube
Lecture suggérée => Guide de formation C ++ pour tous
Ce que vous apprendrez:
Boucles en C ++
Pour la boucle
La construction qui exécute des instructions de manière répétitive est la boucle «for».
La syntaxe générale de la boucle for est:
for(initialization; condition; increment) { Statement block; }La syntaxe générale de la boucle for montre qu'elle se compose de trois parties. L'expression d'initialisation se compose des valeurs initiales définies pour la variable de boucle. L'expression de condition fournit la condition qui est vérifiée pour quitter la boucle. La partie incrémentation est utilisée pour incrémenter la variable de boucle après chaque itération.
Initialement, la boucle «for» commence l'exécution avec l'initialisation de la variable de boucle. Ensuite, il teste la condition. Si la valeur de la variable de boucle satisfait la condition, alors elle exécute le bloc d'instructions.
Lorsque le bloc d'instructions est exécuté, la variable de boucle est incrémentée selon l'incrément spécifié et l'itération suivante est lancée. De cette façon, la boucle termine les itérations jusqu'à ce que la condition soit remplie. Ensuite, la boucle «for» est sortie.
Il s'agit du diagramme de flux de la construction de la boucle «for».
Voyons un exemple de boucle «for» en C ++ ci-dessous.
#include #include using namespace std; int main() { cout<<'Printing 2's multiples less than 20'< Production:
Impression de multiples de 2 inférieurs à 20
i = 2 i = 4 i = 6 i = 8 i = 10 i = 12 i = 14 i = 16 i = 18 i = 20
Ici, nous imprimons les multiples de 2 jusqu'à 20 en utilisant une boucle «for». Notez qu'il est pratique à utiliser lorsque l'on connaît au préalable le nombre d'itérations.
Alors que la boucle
C ++ fournit encore une autre construction de boucle qui nous permet d'exécuter un ensemble d'instructions de manière répétitive. Il s’agit d’une boucle «while».
La syntaxe générale de la boucle «while» est:
while(condition) { Statement_block; }Une boucle «while» répète un ensemble de l'instruction tant que la condition est vraie. Ainsi, avant le début de chaque itération, la condition est évaluée. S'il est rempli, statement_block est à l'intérieur de la boucle while. Sinon, la boucle est quittée.
Vous trouverez ci-dessous le diagramme de flux de la boucle «while».
Vous trouverez ci-dessous un exemple de programme pour démontrer la boucle while:
#include #include using namespace std; int main() { cout<<'Printing 2's multiples less than 20'< Production:
Impression de multiples de 2 inférieurs à 20
i = 2 i = 4 i = 6 i = 8 i = 10 i = 12 i = 14 i = 16 i = 18 i = 20
Pour simplifier le concept, nous avons modifié le même programme que celui utilisé pour démontrer la boucle «for». Ici, contrairement à la boucle for, nous spécifions la valeur initiale de la variable de boucle en dehors de la boucle while. Ensuite, nous commençons la boucle while où nous spécifions la condition.
À l'intérieur de la boucle, nous incrémentons la variable de boucle. Le code à l'intérieur de la boucle «while» est exécuté tant que la condition est satisfaite.
Lorsque nous ne sommes pas sûrs du nombre exact d'itérations pour lesquelles le code sera exécuté, nous optons pour une boucle «while».
Faire une boucle
La boucle suivante en C ++ est la boucle «do-while». Dans le cas de la boucle «while», nous vérifions d'abord la condition puis exécutons l'itération. Dans le cas de la boucle «do-while», on exécute d'abord l'itération puis on évalue la condition pour continuer avec la boucle.
La syntaxe générale de la boucle «do-while» est:
do{ … … }while(condition); L'organigramme de la boucle Do While:
Comme indiqué dans le diagramme de flux, la boucle «do-while» commence par le bloc d'instructions. Il est d'abord exécuté, puis la condition est vérifiée. Si la condition est vraie, le bloc d'instructions est exécuté à plusieurs reprises jusqu'à ce que la condition devienne fausse.
Comprenons cela à l'aide d'un exemple.
#include #include using namespace std; int main() { cout<<'Printing 2's multiples less than 20'< Production:
Impression de multiples de 2 inférieurs à 20
i = 2 i = 4 i = 6 i = 8 i = 10 i = 12 i = 14 i = 16 i = 18 i = 20
Nous avons modifié le même exemple que les boucles précédentes. Notez que la condition est vérifiée à la fin après l'exécution du bloc d'instructions. Cela garantit que la boucle est exécutée au moins une fois avant de quitter.
Déclarations Break And Continue
Chaque fois que nous devons sortir du bloc boucle / instruction sans le terminer ou si nous devons sauter une itération, nous utilisons deux instructions spéciales, c'est-à-dire break et continue.
L'instruction «break» de C ++ est utilisée pour rompre et sortir de la boucle ou du bloc d'instructions. L'instruction «break» met immédiatement fin à la boucle ou au bloc d'instructions au moment où il est rencontré.
Ceci est nécessaire lorsque nous voulons brusquement quitter une construction particulière quelle que soit la condition de test.
De même, si nous voulons sauter une instruction particulière ou passer à l'itération suivante sans terminer l'itération en cours, nous utilisons l'instruction «continue». En d'autres termes, «continuer» est utilisé pour continuer le déroulement du programme à l'étape suivante.
Vous trouverez ci-dessous le diagramme des instructions Break et Continue
Casser
Continuez
Voyons un exemple d'utilisation des instructions break et continue dans le code.
#include #include using namespace std; int main() { cout<<'Printing 2's multiples less than 20'< 20) break; } } Production:
Impression de multiples de 2 inférieurs à 20
i = 2 i = 4 i = 6 i = 8 i = 10 i = 12 i = 14 i = 16 i = 18 i = 20
Encore une fois, nous avons pris le même exemple d’impression de multiples de 2 jusqu’à 20. Dans ce cas, nous avons initialisé la variable de boucle à zéro. Ensuite, nous utilisons une boucle while infinie et à l'intérieur de la boucle, nous sautons la première itération en utilisant l'instruction continue.
Ensuite, nous utilisons l'instruction break pour sortir de la boucle au moment où la variable de boucle devient supérieure à 20.
Une autre situation où nous utilisons l'instruction break est dans le cas de l'instruction switch. Nous avons déjà vu l'instruction switch.
Lorsque l'expression correspond à n'importe quel cas de l'instruction switch, le code de ce particulier est exécuté, puis le contrôle passe aux cas suivant le cas correspondant. De cette façon, après la mise en correspondance du cas, tous les cas suivants sont également exécutés avant de quitter l'instruction switch. Cela entraîne une sortie erronée.
Afin d'empêcher les cas suivants de s'exécuter, nous introduisons l'instruction break à la fin de chaque cas. Cela rend la sortie contrôlée de l'instruction switch une fois que le cas correspondant est trouvé et que le code est exécuté.
Boucle infinie
Une boucle infinie est également appelée boucle sans fin. Une boucle infinie se produit lorsque la condition de boucle est toujours évaluée à vrai. En conséquence, il s'exécute indéfiniment.
Par exemplefor (;;) donnera une boucle infinie «for».
While (;) ou while (1) entraînera l'exécution de la boucle while indéfiniment.
Les boucles infinies ne devraient pas être encouragées dans la programmation, mais si le besoin s'en fait sentir, nous devrions être capables de sortir de la boucle en utilisant une condition de terminaison à l'intérieur de la boucle.
questions et réponses d'entrevue d'administrateur Salesforce pdf
Les boucles infinies entraînent une erreur. Nous devons être prudents lors de l'utilisation des constructions de boucle en C ++.
- Les boucles «For» doivent être utilisées lorsque nous connaissons au préalable le nombre d’itérations.
- La boucle While doit être utilisée lorsque nous connaissons la condition de fin de la boucle.
- La boucle do-while doit être utilisée lorsque nous voulons que la boucle soit exécutée au moins une fois.
Conclusion
Avec cela, nous concluons ce tutoriel sur les boucles en C ++.
Dans nos prochains tutoriels, nous aborderons en détail les tableaux et les chaînes suivis des fonctions en C ++.
=> Visitez ici pour la liste complète des didacticiels C ++.
lecture recommandée
- Types de boucle du shell Unix: boucle Do While, boucle For, boucle jusqu'à sous Unix
- Tutoriel de script Unix Shell avec des exemples
- Utilisation de Switch Case dans un script de shell Unix: instruction Case-esac
- Boucles VBScript: boucle For, boucle Do et boucle While
- Constructions de prise de décision en C ++
- Tutoriel Python DateTime avec des exemples
- Commande Cut sous Unix avec des exemples
- Fonctions de date et d'heure en C ++ avec des exemples
