Introduction aux boucles en C ++
Dans cet article, nous aborderons les boucles en C ++ ainsi que l'introduction et les différents types de boucles en programmation C ++. En programmation, il y a des moments où vous avez besoin qu'un certain bloc de code soit exécuté plusieurs fois. Pour cette raison, les langages de programmation nous fournissent des structures de contrôle. Généralement, les instructions du code sont exécutées les unes après les autres, c'est-à-dire séquentiellement. Mais pour changer ce flux séquentiel du programme, on nous fournit des boucles qui nous permettent de modifier le chemin d'exécution.
Dans le monde de la programmation, la boucle est une structure de contrôle qui est utilisée lorsque nous voulons exécuter un bloc de code, plusieurs fois. Il continue généralement de fonctionner jusqu'à ce que et à moins qu'une condition de fin ne soit remplie.
Si nous n'avions pas de boucles, nous devions utiliser la méthode itérative pour imprimer un bloc répétitif d'instructions, qui ressemblerait à ceci:
#include
using namespace std;
int main()
(
cout << " Good morning \n";
cout << " Good morning \n";
cout << " Good morning \n";
cout << " Good morning \n";
cout << " Good morning \n";
)
Production:
Bonjour
Bonjour
Bonjour
Bonjour
Bonjour
Dans cet exemple, nous avons imprimé «Bonjour» cinq fois en répétant le même ensemble de lignes.
Une boucle a un certain ensemble d'instructions. Dans une boucle, nous utilisons un compteur pour vérifier la condition d'exécution de la boucle. Dans les cas où le compteur n'a pas encore atteint le nombre requis, la commande revient à la première instruction de la séquence d'instructions et continue de répéter l'exécution des instructions dans le bloc. Si le compteur a atteint le nombre requis, cela signifie que la condition a été remplie et que le contrôle sort de la boucle d'instructions et sort de la boucle, jusqu'au bloc de code restant.
Types de boucles en C ++
Maintenant que nous avons vu comment fonctionne une boucle, clarifions-la en parcourant les types de boucles disponibles. En programmation C ++, nous avons trois types de boucles en C ++:
- Pour boucle
- En boucle
- Faire en boucle
Pour boucle
La boucle est une boucle contrôlée par l'entrée, ce qui signifie que la condition spécifiée par nous est vérifiée avant d'entrer dans le bloc de boucle. Il s'agit d'une structure de contrôle de répétition. La boucle écrite par nous est exécutée un nombre spécifié de fois.
Pour contrôler la boucle, nous utilisons une variable de boucle dans la boucle For. Cette variable est d'abord initialisée à une certaine valeur, puis nous effectuons la vérification de cette variable en la comparant à la variable de compteur, et enfin, nous mettons à jour la variable de boucle.
Syntaxe:
pour (expression d'initialisation; expression de test; expression de mise à jour)
(
// instructions à exécuter dans le corps de la boucle
)
Expression d'initialisation:
Ici, nous initialisons la variable de boucle à une valeur particulière. Par exemple, int i = 1;
Expression de test:
Ici, nous écrivons la condition de test. Si la condition est remplie et renvoie true, nous exécutons le corps de la boucle et mettons à jour la variable de boucle. Sinon, nous quittons la boucle For. Un exemple d'expression de test est i <= 5;
Mettre à jour l'expression:
Une fois le corps de la boucle exécuté, nous incrémentons ou décrémentons la valeur de la variable de boucle dans l'expression de mise à jour. Par exemple, i ++;
Voyons un exemple de boucle For:
#include
using namespace std;
int main()
(
for (int i = 1; i <= 5; i++)
(
cout << " Good morning \n";
)
return 0;
)
Production:
Bonjour
Bonjour
Bonjour
Bonjour
Bonjour
En boucle
Alors que la boucle est également une boucle contrôlée par l'entrée, où nous vérifions la condition spécifiée par nous, avant d'exécuter la boucle. La différence est que nous utilisons des boucles For lorsque nous connaissons le nombre de fois que le corps de la boucle doit s'exécuter, tandis que nous utilisons des boucles while dans des circonstances où, auparavant, nous ne savons pas le nombre précis de fois où le corps de la boucle doit s'exécuter. courir. L'exécution de la boucle est terminée en fonction de la condition de test.
Syntaxe:
expression d'initialisation;
while (expression_test)
(
// instructions à exécuter dans le corps de la boucle
update_expression;
)
La syntaxe des boucles ne diffère que par le placement des trois instructions d'expression.
Voyons un exemple de boucle while:
#include
using namespace std;
int main()
(
int i = 0; // initialization expression
while (i < 5) // test expression
(
cout << "Good morning\n";
i++; // update expression
)
return 0;
)
Production:
Bonjour
Bonjour
Bonjour
Bonjour
Bonjour
Faire en boucle
Do while loop est une boucle à sortie contrôlée, ce qui signifie que la condition de test est vérifiée après l'exécution de la boucle, à la fin du corps de la boucle. Par conséquent, le corps s'exécute au moins une fois, quel que soit le résultat de la condition de test, qu'elle soit vraie ou fausse. Cela se trouve être la principale différence entre la boucle while et la fonction do while. En boucle while, la condition est testée au préalable, tandis qu'en boucle do while la condition est vérifiée à la fin du corps de la boucle.
Syntaxe:
expression d'initialisation;
faire
(
// instructions à exécuter dans le corps de la boucle
update_expression;
) while (expression_test);
Dans la boucle do while, nous terminons le corps de la boucle par un point-virgule, tandis que les deux autres boucles n'ont pas de point-virgule pour terminer le corps de leurs boucles.
#include
using namespace std;
int main()
(
int i = 2; // initialization expression
do
(
cout << " Good morning\n";
i++; // update expression
) while (i < 1); // test expression
return 0;
)
Production:
Bonjour
Dans le code ci-dessus, la condition de test indique que je devrais être inférieur à 1 (i <1), mais la boucle s'exécute toujours au moins une fois, avant de vérifier la condition, ce qui nous donne une fois la sortie "Bonjour".
Boucle infinie
Une boucle infinie ou une boucle sans fin est une boucle qui n'a pas de condition de sortie appropriée pour la boucle, ce qui la fait fonctionner à l'infini. Cela se produit lorsque la condition de test n'est pas écrite correctement et qu'elle est définitivement vérifiée. Il s'agit généralement d'une erreur dans le programme.
#include
using namespace std;
int main ()
(
int i;
for ( ; ; )
(
cout << "This loop runs indefinitely.\n";
)
)
Production:
Cette boucle fonctionne indéfiniment.
Cette boucle fonctionne indéfiniment.
Cette boucle fonctionne indéfiniment.
Dans cet exemple, nous n'avons mentionné aucune expression de test et l'avons laissé vide; par conséquent, cette boucle s'exécutera indéfiniment jusqu'à ce qu'elle soit terminée manuellement.
Conclusion - Boucles en C ++
Dans cet article, nous avons vu les différentes boucles utilisées en C ++. Chacune de ces boucles présente des avantages différents. Nous utilisons la boucle lorsque nous connaissons le nombre de fois où nous devons exécuter la boucle, nous utilisons la boucle while lorsque nous connaissons la condition de terminaison, mais nous ne connaissons pas le nombre précis d'itérations et nous utilisons la boucle do while lorsque nous avons besoin du code à exécuter au moins une fois comme dans les programmes de menu.
Articles recommandés
Ceci est un guide des boucles en C ++. Ici, nous discutons également différents types de boucles en C ++ avec syntaxe et exemple. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Exemples de fonctions de chaîne C ++
- Types d'opérateurs en C ++
- Différence entre C ++ et Java
- Introduction à Matlab
- Motifs d'étoiles en c ++
- Boucles dans VBScript avec des exemples
- Apprenez les différents types de boucles dans PowerShell