(C++) Boucles. Boucle avec paramètre (for)


Boucles de programmation
Imaginez une situation où nous devons afficher le même mot à l'écran, disons le mot "BONJOUR", 10 fois. Que devons-nous faire ?
Vous pouvez prendre et écrire 10 fois cout << "BONJOUR";

Mais que se passe-t-il si vous n'avez pas besoin de 10 fois, mais de 20, 30, 40 fois ?, et si 200 fois ? Dans ce cas, la copie prendra beaucoup de temps. Et s'il faut que l'utilisateur choisisse combien de fois afficher les informations à l'écran ? 

Pour faire face à cette tâche, nous utiliserons une construction spéciale appelée boucle.
 
Une boucleest une construction algorithmique dans laquelle une certaine séquence de commandes est répétée plusieurs fois.< /div>
Dans le langage de programmation C++, il existe deux types de boucles : une boucle variable (for) et une boucle conditionnelle (while et do...while)

Commençons notre connaissance des cycles du premier type.
 
Boucle avec variable (for)

Il arrive souvent que nous connaissions le nombre de répétitions de certaines actions, ou que nous puissions calculer le nombre de répétitions à l'aide des données que nous connaissons. Certains langages de programmation ont une commande qui ressemble en russe à repeat(number of times), indiquant le nombre exact de répétitions entre parenthèses. 

Il est intéressant de voir comment ce cycle fonctionne au niveau de la machine :
1. une certaine cellule de mémoire est allouée en mémoire et le nombre de répétitions y est écrit ;
2. lorsque le programme exécute une fois le corps de la boucle, le contenu de cette cellule (compteur) est décrémenté de un ;
3. l'exécution de la boucle se termine lorsque cette cellule vaut zéro.

Il n'y a pas de construction de ce type dans le langage de programmation C++, mais il existe une construction for.  

La forme générale de l'instruction de boucle for est la suivante : pour (/*expression1*/; /*expression2*/; /*expression3*/ ) { /*une instruction ou un bloc d'instructions - corps de la boucle*/; } Cette conception nécessite que nous :
1. alloué explicitement une cellule mémoire qui sera un compteur et définir sa valeur initiale ;
2. une condition a été écrite sous laquelle le corps de la boucle sera exécuté ;
3. Spécifiez comment la valeur de cette cellule va changer.

Dans la partie pratique, nous essaierons d'afficher le mot "Bonjour"  10 fois. Dans les tâches suivantes, nous analyserons cette construction plus en détail.

Boucle
for
Une boucle for est un moyen de parcourir des actions répétées. Voyons de plus près comment cela fonctionne.

L'exécution de la boucle for comprend les étapes suivantes : 
1. définir la valeur initiale de la variable de boucle (compteur) ;
2. vérification des conditions de poursuite de la boucle ;
3. exécution d'une étape (corps de la boucle) ; 
4. changer la valeur de la variable de boucle.
De plus, les étapes 2 à 4 sont répétées jusqu'à ce que la condition à la 2ème étape devienne fausse. Dès que la condition devient fausse, la boucle se termine et l'instruction suivant l'instruction de boucle for.
est exécutée.

Revenons à la forme générale de l'instruction de boucle et analysons toutes les parties plus en détail.
pour (/*expression1*/; /*expression2*/; /*expression3*/ ) {       /*une instruction ou un bloc d'instructions - corps de la boucle*/; }

Expression 1 responsable de la définition de la valeur initiale de la variable de boucle (compteur), se termine par un point-virgule

Par exemple,

1)i=0 ;  ;   // Affecte la valeur initiale égale à zéro à la variable de boucle i.
                 // Avec cette notation, la variable i doit être déclarée avant la boucle.

2) int i=0 ; //  ; La variable i peut être déclarée directement dans l'entête de la boucle, mais
                     // dans ce cas, après l'effacement de la boucle de la mémoire

3)  ;  ;   // Aucune initialisation et déclaration de la variable cycle,
          //  dans ce cas, il peut être défini avant la boucle.


Expression 2 est la condition de continuation de boucle pour qui est testée comme vraie.

i<=10  // La boucle s'exécutera tant que la variable i est inférieure ou égale à 10. La condition peut être n'importe quoi.
 

Expression 3 modifie la valeur de la variable compteur. Sans cette valeur, la boucle sera considérée comme infinie.

i++  // La variable augmentera de 1 à chaque étape.
 

S'il y a une instruction dans le corps de la boucle

S'il n'y a qu'une seule instruction dans le corps de la boucle, les parenthèses peuvent être omises.

Cycle pour -fonctionnalités

Il peut y avoir plusieurs déclarations séparées par des virgules dans chaque partie d'en-tête.
 
Exemple
pour ( je = 0, x = 1.; je < 10; je += 2, x *= 0.1 ) { ... } Dans ce cas, nous utilisons deux variables qui changeront après l'exécution du corps de la boucle - ce sont les variables i et x. La variable i change par étapes 2 : i += 2 est un raccourci pour i = i + 2. La variable x augmente de 0,1 fois à chaque pas x = x * 0,1, x *= 0,1 pour faire court.

Répéter N fois

Tous les programmes avec une boucle for que nous avons écrits jusqu'à présent ne peuvent pas être qualifiés d'universels. Parce que nous fixons nous-mêmes le nombre de répétitions du corps de la boucle. Mais que se passe-t-il si le nombre de répétitions dépend d'une autre valeur ? Par exemple, l'utilisateur souhaite lui-même définir le nombre de répétitions du cycle.
Que faire dans ce cas ? Tout est très simple. Au lieu de valeurs numériques de début et de fin, nous pouvons utiliser n'importe quelle variable pouvant être calculée ou définie par l'utilisateur.

Par exemple, nous devons afficher les carrés des nombres de 1 à N, où la valeur de la variable N est saisie au clavier par l'utilisateur.
Le programme ressemblera à ceci :
  #include <iostream> en utilisant l'espace de noms std ; principal() { int je,N ; // je – variable de boucle, N - le nombre maximum pour lequel nous calculons le carré cin>> N; for ( i = 1; i <= N; i ++) // boucle : pour tout i de 1 à N. La variable i prendra séquentiellement des valeurs de 1 à N { cout << "Numéro carré"<<i<<" est" <<i*i<<"\n" ; // Afficher le carré d'un nombre dans un format spécifique et passer à une nouvelle ligne } } A l'entrée de la boucle, l'instruction i = 1 est exécutée, puis la variable i est incrémentée de un à chaque pas (i ++ ). La boucle est exécutée tant que la condition i <= N est vraie. Dans le corps de la boucle, la seule instruction de sortie imprime le nombre lui-même et son carré à l'écran selon le format spécifié.
Pour le carré ou d'autres exposants faibles, il est préférable d'utiliser la multiplication.

Exécutez le programme et voyez le résultat de son travail avec différentes valeurs de la variable N.