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 la commande 10 fois writeln('HELLO');
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 est nécessaire que l'utilisateur puisse choisir combien de fois afficher les informations à l'écran ?
Pour faire face à cette tâche, nous pouvons utiliser une construction spéciale appelée LOOP
Une boucle est une construction algorithmique dans laquelle une certaine séquence de commandes est répétée plusieurs fois.
Dans le langage de programmation Pascal, il existe deux types de boucles : une boucle avec une variable (for) et une boucle avec une condition (while)
Commençons notre connaissance des cycles du premier type.
BOUCLE AVEC UNE VARIABLE OU AVEC UN NOMBRE DE PAS CONNU (POUR)
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 en russe ressemble à REPEAT (nombre de fois) - c'est-à-dire que nous pouvons spécifier le nombre exact de répétitions.
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.
Dans le langage de programmation Pascal, il n'y a pas une telle construction, mais il y a une construction for.
La forme générale de l'instruction de boucle for est la suivante :
pour *valeur de début* à *valeur de fin* faire
commencer
/*une instruction ou un bloc d'instructions - corps de la boucle*/;
fin ;
Cette construction nécessite que nous
1. allouer explicitement une cellule mémoire, qui sera un compteur, et fixer sa valeur initiale
2. Spécifiez comment la valeur de cette cellule va changer.
3. une condition a été écrite sous laquelle le corps de la boucle sera exécuté
Dans la partie pratique, nous essaierons d'afficher le mot Hello 10 fois. Dans les tâches suivantes, nous analyserons cette construction plus en détail.
|
Une boucle for est un moyen de parcourir des actions répétées. Voyons de plus près comment cela fonctionne.
En règle générale, les parties d'une boucle for effectuent les étapes suivantes :
1. Définir la valeur initiale.
2. Définir le pas avec lequel la variable de boucle changera
3. Définition de la valeur finale.
3. Effectuer des actions en boucle.
4. Mettez à jour la ou les valeurs utilisées dans le test.
puis les étapes 2 à 4 sont répétées jusqu'à ce que la condition soit remplie. Dès que la condition devient fausse, la boucle se termine et l'instruction suivant l'instruction de la boucle for est exécutée.
Revenons à la forme générale de l'instruction de boucle et analysons plus en détail toutes les parties
for *set initial value to variable* to/downto *end value* do begin
/*une instruction ou un bloc d'instructions - corps de la boucle*/;
fin ;
Définition d'une variable à une valeur initiale
est responsable de la définition de la valeur initiale de la variable de cycle (compteur), n'est PAS mis en évidence avec des parenthèses ou autre chose
Par exemple :
je := 0; //la variable de cycle i est affectée de la valeur initiale égale à zéro. Avec un tel record,
//la variable i doit être déclarée avant la boucle
à/jusqu'à
C'est l'étape à laquelle la variable utilisée dans la boucle changera. Si nous écrivons à, alors à chaque itération la valeur de la variable augmentera de 1, si downto - diminuera de 1
Valeur finale
est la dernière valeur à laquelle le corps de la boucle sera encore exécuté. Par exemple, si nous définissons la dernière valeur sur 100, alors à 100, notre boucle sera toujours exécutée, et à 101, elle ne le sera pas.
Entraînons-nous à écrire le titre de la boucle for
|
La tête d'une boucle for en Pascal se compose de plusieurs parties :
1) le mot pour
2) quelle variable et quelle valeur attribuons-nous. Dans ce programme, c'est b := 1, c'est-à-dire nous attribuons la valeur 1 à b.
3) le mot to ou downto, qui indique le pas avec lequel la boucle est exécutée. Si nous écrivons à, alors la variable augmentera de 1 à chaque itération, si downto, alors diminuera de 1.
4) valeur finale de la variable
5) mot faire
6) le mot begin (il peut être omis s'il n'y a qu'une seule ligne dans le corps de la boucle, sinon il doit être écrit. Si vous n'écrivez pas begin, alors seule la première ligne sera être exécuté à partir du corps entier de la boucle). N'oublions pas après le corps de la boucle, si nous avons écrit le mot begin, écrivez le mot end; !
|
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 :
var i, n :entier; // je – variable de boucle, n - le nombre maximum pour lequel nous calculons le carré
commencer
lire(n); // saisir n depuis le clavier
for i := 1 to n do // loop: for all i from 1 to n - variable i prendra séquentiellement des valeurs de 1 à n
writeln('Kvadrat chisla', je, 'corbeau', je * je); // Afficher le carré d'un nombre dans un format spécifique et passer à une nouvelle ligne
fin.
Lors de l'entrée dans la boucle, l'instruction i := 1 est exécutée, puis la variable i est incrémentée de un (to) à chaque pas. 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.
|