Comment utiliser lors de la boucle en C ++

La boucle while est l'un des types de boucle les plus utilisés dans le langage de programmation C ++ en raison de sa large gamme d'applications. La boucle while peut répéter un certain code plusieurs fois jusqu'à ce qu'une condition de rupture soit remplie. Cet article couvre la syntaxe et les exemples d'utilisation d'une boucle while en C++.

Table des matières:

• Ce qui est en boucle en c++
• Syntaxe de While Loop
• Comment utiliser lors de la boucle en c++
• C ++ imbriqué pendant la boucle
• C ++ Infinite While Loop
• Imprimer des nombres uniformes et étranges avec des boucles en C++
• Conclusion

Ce qui est en boucle en c++

Une boucle de temps est une structure de contrôle qui continuera à fonctionner tant que la condition l'évaluera à vrai, et elle s'arrêtera une fois que la condition deviendra fausse. Il est utile dans les cas où vous souhaitez répéter une certaine tâche jusqu'à ce qu'une condition spécifique soit remplie.

Par exemple, Vous pouvez utiliser une boucle de temps pour imprimer des numéros de 1 à 10 ou calculer le numéro d'un numéro donné.

Syntaxe de While Loop

La syntaxe de base d'une boucle de base en C ++ est la suivante:

while (condition)
// code à exécuter

Le code dans les accolades bouclés sera exécuté à plusieurs reprises tant que la condition est vraie. La condition sera vérifiée chaque fois que la boucle fonctionne.

Comment utiliser lors de la boucle en c++

L'un des exemples les plus courants de While Loops comptent d'un point de départ à un point final. Par exemple, Le code suivant comptera de 1 à 10:

#inclure
Utilisation de Namespace Std;
int main()
int i = 1; // Initialiser la variable de compteur à 1
// boucle tandis que la variable de compteur est inférieure ou égale à 10
alors que je <= 10)
couter << i << endl; // output the current value of the counter variable
i ++; // incrément la variable de comptoir

retour 0;

Ce code montre comment utiliser une boucle while en c++. Le programme initialise une variable de compteur je à 1 puis exécute une boucle de temps qui continuera à fonctionner jusqu'à ce que je devient supérieur à 10.

À l'intérieur de la boucle while, la valeur actuelle de la variable de compteur est imprimée à la console à l'aide du couter déclaration, suivie d'une pause en ligne en utilisant fin. La variable de comptoir est ensuite incrémentée de 1 en utilisant le je++ déclaration.

La boucle continue de s'exécuter jusqu'à la variable de compteur je atteint une valeur de 11, à quel point la boucle while est sortie et le programme se termine avec une valeur de retour de 0.

C ++ imbriqué pendant la boucle

Les boucles while peuvent également être imbriqué, ce qui signifie que vous pouvez avoir une boucle de temps à l'intérieur d'un autre pendant une boucle. Ceci est utile dans les cas où vous devez effectuer une tâche à plusieurs reprises jusqu'à ce qu'une condition spécifique soit remplie, et dans cette tâche, vous devez effectuer une autre tâche à plusieurs reprises jusqu'à ce qu'une condition différente soit remplie.

Dans une boucle imbriquée, la boucle extérieure est exécutée une fois, puis la boucle intérieure s'exécutera chaque fois que la boucle extérieure fonctionne. La boucle intérieure est exécutée pleinement une fois pour chaque itération de la boucle extérieure.

Exemple

Voici l'exemple de code de l'utilisation de la boucle imbriquée en C ++:

#inclure
Utilisation de Namespace Std;
int main()
int i = 1; // Initialiser la variable de compteur à 1
// boucle tandis que la variable de compteur est inférieure ou égale à 3
alors que je <= 3)
int j = 1; // Initialise la variable de compteur interne à 1
// boucle tandis que la variable de compteur interne est inférieure ou égale à 3
tandis que (j <= 3)
couter << i << " " << j << "\n"; // output the current values of the counter variables
j ++; // Incrément Inner Counter Variable

i ++; // Incrément la variable de compteur extérieur

retour 0;

Dans ce code, la boucle extérieure fonctionne aussi longtemps que le je devient égal à 3, lorsque la valeur de je devient supérieur à 3, la boucle s'arrêtera. À chaque itération de la boucle extérieure, la variable contre-intérieure J est initialisé à 1 et exécute la boucle intérieure. Cette boucle intérieure fonctionnera jusqu'à la valeur de J devient plus grand que 3.

À l'intérieur de la boucle intérieure, nous étendons les valeurs de je et J. Après cela, nous avons incréments le J. Cela continue jusqu'à ce que la boucle intérieure ait été exécutée trois fois. Chaque fois que la boucle extérieure est incrémentée, la boucle intérieure sera également exécutée à nouveau.

Ce processus se répète jusqu'à ce que la boucle extérieure ait été exécutée trois fois et les deux boucles ont terminé. La sortie de ce code est un tableau de valeurs allant de 1 1 à 3 3, comme indiqué dans l'image ci-dessous.

C ++ Infinite While Loop

En C ++, l'infini tandis que les boucles sont également possibles. Une boucle infinie tandis que fonctionne en continu car aucune condition définie ne peut être fausse. Il n'y a qu'une seule vraie condition, Cela permet à la boucle While de fonctionner en continu pour un nombre infini de fois.

Par exemple, La boucle ci-dessous s'exécutera pour toujours et pour arrêter cette boucle, nous devons définir une déclaration de pause à la fin de cette boucle.

while (true)
// code à exécuter

Une boucle infinie peut être utile dans certains cas, comme dans les systèmes intégrés ou en attendant l'entrée de l'utilisateur.

Exemple

Vous trouverez ci-dessous l'exemple de programme C ++ qui exécute une boucle infinie dans le code C ++:

#inclure
Utilisation de Namespace Std;
int main ()
int count = 0;
while (true)
couter<<"Infinitive While Loop\n";
Count ++;
if (count> = 10)
casser;


retour 0;

Le code donné crée une boucle infinie qui sortira en continu la chaîne «Infinitive While en boucle» sur la console. En effet.

Pour arrêter une boucle infinie, nous pouvons utiliser l'instruction BREAK pour quitter la boucle lorsqu'une certaine condition est remplie. Dans le programme ci-dessus, nous avons réglé le nombre maximum d'itérations sur 10, qui est contrôlé par le compter variable et l'instruction de pause.

Le code ci-dessus s'exécutera pour des temps infinis, mais l'utilisation d'une déclaration de pause l'arrêtera après 10 itérations.

Imprimer des nombres uniques et étranges avec une boucle

Un autre exemple de tandis que les boucles impriment les nombres uniques et étranges. Par exemple, Le code donné suivant utilise une boucle de temps en C ++ pour produire les nombres pair de 2 à 10.

#inclure
Utilisation de Namespace Std;
int main()
int i = 2; // Initialiser la variable de compteur à 2
// boucle tandis que la variable de compteur est inférieure ou égale à 10
alors que je <= 10)
couter << i << endl; // output the current value of the counter variable
i + = 2; // incrément la variable de compteur par 2

retour 0;

Ce code C ++ initialise une variable de compteur je à 2 et utilise une boucle je tant qu'il est inférieur ou égal à 10. À chaque itération de la boucle, elle augmente je par 2. Chaque fois que la boucle exécute la sortie sera imprimée sur le terminal. Une fois la boucle terminée, le programme renvoie 0 pour indiquer une exécution réussie.

De même, nous pouvons également imprimer impair Nombres de 1 à 9:

#inclure
Utilisation de Namespace Std;
int main()
int i = 1; // Initialiser la variable de compteur à 1
// boucle tandis que la variable de compteur est inférieure ou égale à 9
alors que je <= 9)
couter << i << endl; // output the current value of the counter variable
i + = 2; // incrément la variable de compteur par 2

retour 0;

Dans ce code, la condition de boucle s'exécutera jusqu'à la variable de comptoir je est inférieur ou égal à 9. Le couter Instruction à l'intérieur de la boucle sortira la valeur actuelle de je, Et puis le je la variable est incrémentée de 2 en utilisant le i + = 2 déclaration. Cela garantit que seuls les nombres impairs sont imprimés par la boucle.

À la fin du programme, une instruction de retour est utilisée pour indiquer que la fonction principale () est terminée.

Conclusion

Une boucle de temps est une structure de contrôle qui gère un programme aussi longtemps que la condition définie est vraie. Ici, nous avons couvert la syntaxe de base et les exemples d'utilisation++. Nous décrivons également comment utiliser une boucle de temps dans une forme imbriquée et comment on peut fonctionner tout en boucle un nombre infini de fois. Pour plus de détails sur C ++ pendant la boucle, lisez l'article.