Programmation de processus informatiques cycliques de traitement de données. Programmation de processus de calcul cyclique. Un exemple d'utilisation de l'instruction for

En programmation, il existe souvent des tâches qui nécessitent l'exécution répétée du même groupe d'instructions de programme avec des valeurs différentes de leurs opérandes. De tels processus sont appelés cyclique ou simplement cycles. Un groupe d'instructions répétées de manière cyclique forme ce qu'on appelle corps de boucle, qui peut être représenté par une expression simple ou composée. Nous appellerons l'exécution unique du corps de la boucle itération.

Le corps d'une boucle dans un programme est toujours précédé de en-tête de boucle, contenant la désignation opérateur de boucle et une expression définissant (directement ou indirectement) le nombre d'itérations. Notez que le corps de la boucle est l'opérande de l'opérateur de boucle ; par conséquent, l'en-tête et le corps de la boucle constituent une unité structurelle indivisible du programme. Dans ce qui suit, en utilisant le terme " opérateur de boucle", nous désignerons à la fois l'en-tête et le corps de la boucle.

Pour organiser les cycles dans tous les systèmes de programmation, il existe des opérateurs de boucle, dont l'utilisation dispense le programmeur de la nécessité de programmer les cycles « manuellement ». MathCAD prend en charge deux types de ces opérateurs - cycle avec prédestination Pour (aussi appelé boucle avec compteur) Et boucle avec précondition Alors que . Une description de la structure de ces opérateurs est donnée dans le tableau 5.

5.4.1 Opérateur Pour

Cet opérateur doit être utilisé dans les cas où le nombre d'itérations est prédéterminé, c'est-à-dire connu à l'avance.

En-tête de boucle de cet opérateur (l'opérande de droite) contient une variable appelée paramètre(ou compteur) faire du vélo, Et liste de valeurs ce paramètre. Le nombre d'éléments de la liste détermine également le nombre d'itérations - à chaque itération, le paramètre de boucle reçoit la valeur suivante de la liste spécifiée dans l'en-tête.

Paramètre de boucle a le statut de variable interne au programme et possède toutes ses propriétés (décrites dans la section 5.1.4). En règle générale, le paramètre loop est utilisé à droite des expressions incluses dans le corps de la boucle, bien qu'il ne soit pas formellement interdit de l'utiliser à gauche des expressions (c'est-à-dire à gauche de la définition locale opérateur "f"). Il convient de rappeler que si un paramètre a été modifié dans le corps de la boucle, sa valeur modifiée ne sera valable que jusqu'à la fin de l'itération en cours, car avant le début de l'itération suivante, le paramètre recevra toujours la valeur suivante du liste spécifiée dans l’en-tête de la boucle.

Formellement, il est permis de ne pas utiliser du tout le paramètre de boucle dans les expressions du corps de la boucle - dans ce cas, la liste des valeurs des paramètres ne joue aucun rôle - seule la longueur de cette liste est significative, ce qui détermine le nombre d'itérations (peut-être dénuées de sens).

À la fin de la dernière itération, l’instruction de programme suivant l’instruction de boucle sera exécutée. Dans ce cas, la variable utilisée comme paramètre de la boucle terminée conserve la valeur qu'elle avait dans le dernier effectivement terminé itération[*]. A noter que cette valeur ne coïncide pas toujours avec la dernière valeur de la liste spécifiée dans l'en-tête de la boucle, puisqu'une sortie « anticipée » de la boucle est possible lorsque l'opérateur est déclenché Casser inclus dans le corps de la boucle.

Liste de valeurs Le paramètre de boucle est écrit dans l'en-tête de la boucle après le symbole " Î ", indiquant l'appartenance à un ensemble (ce symbole n'a pas besoin d'être saisi manuellement - il sera automatiquement affiché lors de la saisie de l'opérateur Pour ). MathCAD permet l'utilisation trois formes entrées dans cette liste : transfert direct– les éléments de la liste sont explicitement spécifiés séparés par des virgules, le paramètre reçoit les valeurs de la liste dans l'ordre dans lequel elles apparaissent ; dans le style de variable classée – les éléments de la liste forment la série arithmétique correspondante ; tableau– les éléments de la liste reçoivent séquentiellement les valeurs des éléments du tableau dans l'ordre de leurs indices (d'abord, les colonnes de gauche à droite, puis les lignes de haut en bas).

Les trois programmes présentés dans la figure 21 illustrent différentes utilisations de l'opérateur Pour .

Programme Fait(n) calcule la factorielle d'un nombre n . L'opérateur de boucle de ce programme fait partie d'une expression composée, qui, à son tour, est l'opérande d'un opérateur conditionnel. Sinon. Paramètre de boucle k obtient les valeurs d'une série arithmétique entière.

Programme Ch(V,N,p) traite le vecteur d'entrée V , en le remplaçant par la valeur p les éléments dont les indices sont spécifiés par les éléments du deuxième vecteur d'entrée N . Dans cet exemple, une liste de valeurs de paramètres de boucle je défini par un ensemble d'éléments vectoriels N . Notez que ces deux programmes effectuent un contrôle des données d'entrée et bloquent l'exécution de l'algorithme principal si les arguments réels du programme sont mal spécifiés.

Programme L(M,z) donné dans l'exemple V ), est accompagné de commentaires détaillés et ne nécessite aucune explication. Ce programme illustre la possibilité d'utiliser plusieurs instructions de boucle, dont une est incluse parmi les instructions corps un autre. Usage boucles imbriquées- une technique typique utilisée pour traiter des tableaux multidimensionnels.

Figure 21 – Exemples de programmation de cycles Pour

La figure 22 illustre l'utilisation des opérateurs Casser Et Continuer dans le corps de la boucle. Généralement, ces opérateurs sont eux-mêmes des opérandes expressions conditionnelles Si ou Sinon .

Opérateur Casser ("avorter") interrompt exécution de la boucle et transfère le contrôle à l'opérateur suivant l'opérateur de boucle interrompue. Notez que si l'opérateur Casser interrompu boucle imbriquée, l'exécution de la boucle externe continuera.

Opérateur Continuer ("continuer") agit différemment - il interrompt uniquement l'itération en cours de la boucle et transfère le contrôle à l'en-tête de cette boucle, après quoi la boucle est exécutée continueà partir de l'itération suivante (à moins, bien sûr, que l'itération interrompue soit la dernière).

Opérateur Casser autorisé à utiliser et dehors corps du cycle. Dans ce cas, l'exécution de l'ensemble du sous-programme est interrompue et le résultat de l'évaluation de sa dernière expression réellement exécutée est renvoyé.

Figure 22 – Exemples d'utilisation des opérateurs Casser Et Continuer

Fonction SommeN(V) additionne uniquement les éléments du vecteur qui contiennent des données scalaires de type numérique et ignore les éléments restants. Fonction Inverse (V) forme un vecteur dont les éléments sont les valeurs inverses des éléments correspondants du vecteur d'origine. De plus, si l'élément suivant contient le nombre "0" ou n'est pas un scalaire de type numérique, le cycle est interrompu. Notez que l'opérateur Casser dans le dernier exemple, il n'interrompt pas le programme, mais transfère le contrôle à l'opérateur Retour , immédiatement après l'opérateur Pour .

5.4.3 Opérateur Alors que

Contrairement à l'opérateur Pour , en-tête de déclaration Alors que (en traduction - " Au revoir") ne contient pas d'indications explicites sur le nombre d'itérations - il contient expression logique, dont la valeur est automatiquement calculée avant le début exécution de chaque itération suivante[†]. Tant que cette expression est vraie, la boucle continuera à s'itérer ; dès que l'expression devient fausse après la fin de l'itération suivante, la prochaine itération de la boucle ne sera pas exécutée et l'instruction de programme qui suit l'instruction recevra le contrôle Alors que .

Évidemment, si une expression logique identiquement fausse est placée dans l'en-tête de la boucle, cette boucle ne terminera aucune de ses itérations, et si cette expression est identiquement vraie, la boucle sera infinie (cette dernière situation est appelée boucle programmes). Afin d'éviter de telles situations, les opérandes d'une expression logique doivent inclure une ou plusieurs variables qui changent leurs valeurs dans le corps de la boucle pour que la boucle soit finie (d'autres moyens peuvent être utilisés pour empêcher la boucle - par exemple, forcer l'opérateur à quitter la boucle Casser ).

Exemples d'utilisation de l'opérateur Alors que sont illustrés à la figure 23. Trois options pour résoudre le même problème sont proposées : chacun des programmes F0 , F1 Et F2 renvoie l'index du premier élément du vecteur sourceV dépassant la valeur spécifiéez .

Premier programme (exemple UN ) en ajoute un au compteur k dans le corps de la boucle Alors que jusqu'au prochain k le ème élément du vecteur d'origine ne dépassera pas la valeur spécifiée z . Après cela, la boucle se termine et le programme renvoie la dernière valeur modifiée de la variable k , qui est la solution au problème. Notez que contrairement au cycle Pour , comptoir k ici, il faut le traiter avec des instructions séparées : initialiser (c'est-à-dire lui attribuer une valeur initiale) avant l'opérateur de boucle et modifier sa valeur dans le corps de la boucle.

Il est facile de voir que l'option UN ) du programme présente un inconvénient important : il n'empêche pas le programme de boucler dans le cas où le problème n'a pas de solution, c'est-à-dire lorsque le paramètre z dépasse la valeur du plus grand élément du vecteur V . Dans cet exemple, le bouclage dans une telle situation ne se produira pas vraiment - mais ce n'est pas le mérite de notre programme, mais du système MathCAD, qui contrôlera la sortie de l'index vectoriel V en dehors des valeurs autorisées et générera un message d'erreur.

L'option b ) d'un programme dans lequel le corps de la boucle contient une vérification supplémentaire de la validité de la valeur d'index suivante et interrompt de force la boucle avec l'opérateur Casser dans la situation appropriée avec l'émission d'un message texte.

La solution la plus efficace à ce problème est peut-être l'option V ), qui n'utilise pas du tout l'opérateur Alors que . Dans ce programme, la variable k utilisé uniquement pour maintenir la « pureté du style » - pour exclure le traitement du paramètre de boucle je en dehors de l'opérateur Pour .

Figure 23 – Exemples de programmation de cycles Alors que

Objectif du travail :

Étudiez les opérateurs cycliques pour, while, do - while, apprenez à composer et programmer des algorithmes cycliques.

Brèves informations théoriques

Les opérateurs de boucle sont utilisés lorsqu'il est nécessaire de répéter plusieurs fois certaines actions (opérateurs et opérations), et ces sections d'algorithmes sont appelées boucles.

L'opérateur de boucle for

La forme de base de l'instruction de boucle for est :

pour (expression_1 ; expression_2 ; expression_3)

opérateur;

Où expression_1– valeur initiale du paramètre cycle ;

expression_2– vérifier les conditions de poursuite du cycle ;

expression_3– changement de paramètre de cycle (correction) ;

opérateur– opérateur simple ou composé en langage C.

Le schéma de fonctionnement de l'opérateur est le suivant : une seule fois, d'abord expression_1 est calculée, puis expression_2 est vérifiée, et si elle est « vraie », alors une section cyclique du programme est exécutée, puis le paramètre est corrigé, et ainsi de suite. jusqu'à ce que expression_2 prenne la valeur « false ».

Par exemple: pour (k=1; k<5; k++)

printf("\n %d", k);

Suite à l'exécution de cet opérateur, les nombres de 1 à 4 sont imprimés dans une colonne.

Vous pouvez utiliser une variable de n'importe quel type de base comme paramètre de boucle.

Par exemple:

pour(ch='a'; ch<=’z’; ch++) // Вывод на экран букв

printf(" %c",ch); // Alphabet latin

Il est nécessaire de contrôler soigneusement la structure des boucles for dans le programme afin de ne pas vous retrouver avec une boucle sans fin (dont il n'y a pas de sortie).

Par exemple:

pour(k=10; k>6;k++)

printf("boucle sans fin\n");

Sortie de boucle plus tôt que prévu de la manière suivante :

Par condition supplémentaire ;

En utilisant les opérateurs suivants :

casser;- sortie de la boucle dans laquelle se trouve break, le contrôle est transféré à la première instruction exécutée après la boucle ;

sortie(int Kod);- quitter le programme ;

retour;- sortir de la fonction ;

Utilisation de l'opérateur de saut inconditionnel aller à<метка>;

Tôt achèvement de l'étape cyclique en cours possible en utilisant une condition ou un opérateur supplémentaire continuer, qui interrompt l'exécution de l'étape de boucle en cours, c'est-à-dire ignore les instructions du reste de la boucle et transfère le contrôle à l'instruction principale de la boucle pour ajuster le paramètre et vérifier la condition.

Il est interdit de transférer le contrôle de l'extérieur vers l'intérieur de la boucle.

N'importe quelle expression de boucle for entre parenthèses peut être manquante, mais le symbole ";" ne peut pas être abaissé.

Par exemple:

pour (; je<3; i++)

puts("Bonjour!");

Instructions cycliques while et do-while

Forme de base de l'opérateur cyclique alors que:

Tandis que (état)

opérateur;

Où opérateur

La boucle s'exécute tant que la condition est évaluée à vrai, c'est-à-dire l'expression entre parenthèses renvoie un résultat différent de zéro. Il s'agit d'une boucle avec une précondition - la condition est d'abord vérifiée, puis l'instruction est exécutée. Par conséquent, la boucle while ne sera pas exécutée une seule fois si le résultat initial du calcul de la condition est 0.

Forme de base de l'opérateur faire pendant:

opérateur;

tandis que (condition);

Où opérateur est une instruction simple, composée ou vide.

Opérateur faire–alors que– opérateur de boucle avec postcondition, c'est-à-dire l'instruction est d'abord exécutée, puis la condition est vérifiée. Puisque dans une boucle do-while, la condition est vérifiée à la fin de la boucle, la boucle sera exécutée au moins une fois.

Dans des boucles comme while et do–while, les mêmes méthodes de sortie anticipée de la boucle et d'achèvement anticipé de l'étape en cours de la boucle sont autorisées comme dans l'instruction for, mais dans ce dernier cas, contrairement à la boucle for, le contrôle est transféré pour vérifier l'état. Pour éviter une boucle sans fin à l'intérieur des boucles while et do-while, vous devez prévoir la modification des variables incluses dans la condition.

Par exemple:

pour (i=1;i<=300;i++) // Печать целых чисел, кратных 5

si (i%5!=0) continue ;

printf("%5d",je);

Exemples de boucles infinies :

opérateur;

2) while(number_not_0) // Toujours vrai !

opérateur;

opérateur;

tandis que(numéro_not_0); // Toujours vrai!

Parmi les opérateurs de boucle, il doit y avoir une condition de sortie.

Boucles imbriquées

Dans le cas de boucles imbriquées, une boucle est dans une autre, par exemple :

pour(je=nn;je

pour(j=mn;j

opérateur;

Où opérateur est une instruction simple, composée ou vide. La boucle interne sera exécutée pour chaque valeur du paramètre i qui satisfait à la condition de la boucle externe.

Exemple:

pour(i=1;i<10;i++) // Печать таблицы умножения

pour(j=1;j<4;j++)

printf("\n %d*%d=%2d", je, j, je*j);

printf("\n");

Un exemple d'utilisation de l'instruction for

Calculer. Le programme doit imprimer les résultats intermédiaires et finaux.

Le texte du programme peut ressembler à

#inclure

#inclure

put("Entrez N");

scanf("%d",&N);

pour (s=0, k=1; k<=N; k++) // В заголовке цикла можно выпол-

( // prise et double affectation

printf(" \n k=%d s=%f ", k, s);

printf("\n RÉPONSE : s=%f, Appuyez sur n'importe quelle touche...",s);

Options pour les missions individuelles

Écrire un programme pour déterminer un tableau de valeurs de fonctions à dans une plage arbitraire [ un,b] l'argument change X avec des étapes arbitraires h. Valeurs un, b, h saisi à partir du clavier. Le tableau doit contenir les colonnes suivantes : numéro de séquence, valeur de l'argument X, valeur de fonction, message concernant une fonction croissante ou décroissante, différence de deux valeurs de fonction adjacentes.

Déterminez les valeurs maximales et minimales de la fonction.

1. une=-p ; b=p; h=0,4.

2. a = 0,7 ; b = 1,8 ; h=0,1.

3. a = -0,5 ; b = 2,5 ; h=0,2.

4. a=-0,9 ; b = 2,7 ; h=0,3.

5. une=-2 ; b = 0,8 ; h=0,2.

6. a=-1,9 ; b = 2,7 ; h=0,3.

7. a=-0,4p ; b = 0,4p ; h=0,5.

8. a=-0,3p ; b = 1,3p ; h = p/10.

9. a = -p/2 ; b = p/2 ; h=p/10.

10. a=-3 ; b = 3 ; h=0,5.

« Programmation des processus de calcul cyclique »

Objectif du travail : maîtriser les méthodes de compilation d'algorithmes pour les processus de calcul cycliques et organiser des programmes cycliques de structure complexe.

Partie théorique

4.1.1. Algorithmes cycliques.

Un cycle est une séquence d'actions qui peuvent être effectuées plusieurs fois.

Un algorithme round-robin est un algorithme qui contient une ou plusieurs boucles.

Il existe 3 types de cycles :

Boucle avec condition préalable ;

Boucle avec postcondition ;

Boucle avec un compteur (boucle de comptage).

Si l'exécution d'une boucle est associée à une condition logique, alors des boucles avec une précondition ou une postcondition sont utilisées.

Les contre-boucles sont une classe dans laquelle l'exécution du corps de la boucle doit être répétée un nombre de fois prédéterminé.

Les schémas fonctionnels des algorithmes cycliques ressemblent à ceci :

1. Bouclez avec un compteur.

2. Boucle avec condition préalable. 3. Boucle avec postcondition.

4.1.2 Opérateurs de boucle dans le langage de programmation C++.

En C++, à chaque type de boucle correspond un opérateur :

Boucle comme while (avec condition préalable) ;

Boucle comme do... while (avec postcondition) ;

Boucle comme pour (en comptant).

1.Opérateur de boucle comme while

Formulaire d'inscription:

instruction while (condition);

où : (condition) – expression logique ;

opérateur – l’opérateur ou le corps de la boucle exécutée dans une boucle.

Si le corps de la boucle est une instruction composée, alors il doit être placé entre crochets d'opérateur (...) :

tandis que (état)

groupe d'opérateurs

Le schéma de fonctionnement d'une telle boucle : tant que la condition est vraie, le corps de la boucle est exécuté et la condition est à nouveau vérifiée, etc. Lorsque la condition devient fausse, la boucle se termine.

2. Opérateur de boucle comme do... while

Formulaire d'inscription:

opérateur;

tandis que (condition);

Le schéma de fonctionnement d'une telle boucle : d'abord l'opérateur est exécuté, puis la condition est vérifiée, si la condition est vraie, l'opérateur est exécuté et la condition est à nouveau vérifiée, etc. Lorsque la condition devient fausse, la boucle se termine.

Si le corps de la boucle est une instruction composée, alors, comme pour une boucle avec une précondition, elle doit être placée entre crochets d'opérateur (...) :

groupe d'opérateurs

tandis que (condition);

3. Opérateur de boucle comme for

Formulaire d'inscription:

opérateur;

A est une expression initiale qui spécifie les valeurs initiales du paramètre de boucle et, si nécessaire, les valeurs initiales des autres paramètres. Par exemple:

je=0, x=0,5, p=1, s=0

B est une expression conditionnelle qui vérifie la condition de poursuite de la boucle. Par exemple:

C est une expression d'incrément qui spécifie l'incrément du paramètre de boucle et, si nécessaire, d'autres paramètres, ils sont ensuite écrits dans une liste. Par exemple : x+=0,1, i++

4.1.3 Un exemple de compilation d'un algorithme et d'un programme en C++ pour un processus de calcul cyclique.

Calculer la valeur d'une expression :

b– valeur initiale, sa valeur est saisie au clavier et ne change pas ;

un– changements de plage par pas de 1 ;

oui– résultat, ses valeurs s’affichent à l’écran.

D'après la spécification, la variable a est un nombre entier, elle peut donc être utilisée comme compteur dans une boucle de comptage.

Le schéma fonctionnel de l'algorithme de résolution de ce problème à l'aide d'un cycle de comptage est le suivant :

#inclure

#inclure

#inclure

printf("Entrez b: ");

scanf("%f",&b);

printf("un y\n");

pour (a=0;a<=10;a++)

printf("%3d",a);

printf("%8.2f\n",y);

y=(ab)/sqrt(a);

printf("%8.2f\n",y);

Le schéma fonctionnel de l'algorithme de résolution de ce problème à l'aide d'une boucle avec une précondition est le suivant :

Le texte du programme C++ correspondant à cet algorithme est le suivant :

#inclure

#inclure

#inclure

printf("Entrez b: ");

scanf("%f",&b);

printf("un y\n");

printf("%3d",a);

printf("%8.2f\n",y);

y=(ab)/sqrt(a);

printf("%8.2f\n",y);

else printf(" y n'existe pas\n");

Le schéma fonctionnel de l'algorithme de résolution de ce problème à l'aide d'une boucle avec une postcondition est le suivant :

Le texte du programme C++ correspondant à cet algorithme est le suivant :

#inclure

#inclure

#inclure

printf("Entrez b: ");

scanf("%f",&b);

printf("un y\n");

printf("%3d",a);

printf("%8.2f\n",y);

y=(ab)/sqrt(a);

printf("%8.2f\n",y);

else printf(" y n'existe pas\n");

pendant que (un<=10);

Partie pratique

4.2.1 Exigences pour réaliser les travaux :

Effectuez la tâche du travail de laboratoire n°3 pour une plage de valeurs de l'une des variables. La variable en cours de modification, sa plage de changement et son pas sont indiqués dans le tableau 4. Créez des schémas fonctionnels d'algorithmes et de programmes pour les deux types de cycles spécifiés dans la tâche individuelle (tableau 4).

Formalisez la sortie des résultats de manière à ce que les valeurs du paramètre variable soient clairement mises en évidence et pour chaque valeur spécifique, les valeurs du résultat (trois variables de la colonne 2 du tableau 3) soient affichées sous la forme d'un tableau.

L'ordre des travaux.

1. Effectuer une analyse de la tâche, formuler un énoncé du problème.

2. Créez des schémas fonctionnels d'algorithmes.

3. Créez un programme en C++. Fournir la saisie des données initiales à partir du clavier et la sortie des résultats à l'écran.

4. Vérifiez la fonctionnalité du programme sur diverses données initiales.

5. Analysez les résultats obtenus.

Options pour les missions individuelles.

Les options pour les devoirs individuels sont sélectionnées dans le tableau 4 en fonction du numéro d'élève dans la liste de groupe dans le journal de l'enseignant.

Tableau 4. Options pour les tâches individuelles

Non.	Variable mutable	Types de cycles
	10 ≤ une ≤ 10,Δ une=1
	-4 ≤ d ≤ 4, Δ d = 0,5
	-6 ≤ x ≤ 3, Δ x = 0,5
	0 ≤ b ≤ 3 0, Δ b = 1,5	1. Avec condition préalable, 2. Dénombrable
	-15 ≤ j ≤ 1 0, Δ j = 0,5	1. Avec condition préalable, 2. Avec postcondition
	5 ≤ e ≤ 35,Δ e = 2	1. Comptable, 2. Avec postcondition
	-5 ≤ m ≤ 15,Δ m = 1	1. Avec condition préalable, 2. Dénombrable
	1 ≤ c ≤ 70,Δ c = 3	1. Avec condition préalable, 2. Avec postcondition
	1,5 ≤ c ≤ 15,Δ c = 0,5	1. Comptable, 2. Avec postcondition
	-8 ≤ b ≤ 28,Δ b = 2	1. Avec condition préalable, 2. Dénombrable
	-4,5 ≤ x ≤ 11,5,Δ x = 0,5	1. Avec condition préalable, 2. Avec postcondition
	-7 ≤ k ≤ 2,Δ k = 0,3	1. Comptable, 2. Avec postcondition
	-1 ≤ m ≤ 21,Δ m = 1	1. Avec condition préalable, 2. Dénombrable
	-2 ≤ e ≤ 34,Δ e = 2	1. Avec condition préalable, 2. Avec postcondition
	-11 ≤ c ≤ 23,Δ c = 2	1. Comptable, 2. Avec postcondition
	-13 ≤ p ≤ 50,Δ p = 3	1. Avec condition préalable, 2. Dénombrable
	3,3 ≤ b ≤ 9,3,Δ b = 0,3	1. Avec condition préalable, 2. Avec postcondition
	3,5 ≤ y ≤ 12,3,Δ y = 0,4	1. Comptable, 2. Avec postcondition
	-7,5 ≤ a ≤ 5,7,Δ une = 0,6	1. Avec condition préalable, 2. Dénombrable
	-1,5 ≤ h ≤ 1,2,Δ h = 0,1	1. Avec condition préalable, 2. Avec postcondition
	0 ≤ h ≤ 10,Δ h=0,5	1. Comptable, 2. Avec postcondition
	-15 ≤ b ≤ 15, Δ b =2	1. Avec condition préalable, 2. Dénombrable
	-7 ≤ l ≤ 3, Δ l = 0,5	1. Avec condition préalable, 2. Avec postcondition
	-5,5 ≤ b ≤ 6,5, Δ b = 0,5	1. Comptable, 2. Avec postcondition
	1 ≤ k ≤ 9, Δ k = 0,4	1. Avec condition préalable, 2. Dénombrable
	0 ≤ b ≤ 6,9,Δ b = 0,3	1. Avec condition préalable, 2. Avec postcondition
	-3 ≤ v ≤ 9,Δ v = 0,6	1. Comptable, 2. Avec postcondition
	-2 ≤ p ≤ 2,6,Δ p = 0,2	1. Avec condition préalable, 2. Dénombrable

4.3 Questions de test et tâches pratiques :

1. Comment fonctionne l'instruction while ?

2. Comment fonctionne l'instruction do ... while ?

3. Comment fonctionne l'instruction for ?

4. Soulignez les énoncés du programme qui forment un cycle.

5. Quelle est la différence entre les instructions while et do ... while ?

6. Remplacez un opérateur de boucle dans le programme par un autre.

En programmation, nous rencontrons souvent des problèmes impliquant des processus qui se répètent. Par conséquent, nous devons connaître et être capables d’utiliser un concept tel que « processus de calcul cyclique».

Il sera facile pour un programmeur novice de les comprendre à l'aide d'un exemple généralisé. De plus, il est important de comprendre que dans tous les langages de programmation, il existe des moyens d'implémenter des boucles.

Qu’est-ce qu’une boucle en programmation ?

Un cycle - en programmation, est la répétition répétée des mêmes actions ou calculs, mais selon les mêmes dépendances avec des valeurs différentes des variables.

Nous rencontrons le concept de cycle non seulement en programmation. Il existe des cycles dans de nombreux domaines de notre vie.

Par exemple, le cycle de l’eau dans la nature est un cycle naturel dans nos vies.

Examinons maintenant les règles générales et les concepts utilisés dans les cycles de calcul.

Étapes du processus cyclique

De manière générale, le cycle doit être mis en œuvre en 4 étapes :

• Étape 1 – préparation du cycle (initialisation).
  Définition de la valeur initiale du paramètre et de la variable de boucle.
  Paramètre de boucle– cette valeur qui compte le nombre d'étapes du cycle (le nombre de répétitions du cycle).
  Variable de boucle est une quantité qui change de valeur à chaque étape du cycle.
  Initialisation– il s’agit de définir les valeurs initiales du paramètre et de la variable de boucle.
• Étape 2 – corps du cycle.
  Il s'agit d'une répétition répétée d'une action dans un cycle ou de calculs basés sur les mêmes dépendances mathématiques avec des valeurs de variables différentes.
• Étape 3 – modification (changement) du cycle.
• Étape 4 – gestion du cycle.
  Il s'agit d'un contrôle de condition de continuation ou de début de boucle.

Il y a 3 opérateurs de boucle dans Pascal qui peuvent implémenter n'importe quel algorithmiquement – ​​structure cyclique :

1. Instruction de boucle avec paramètre
2. Opérateur de boucle avec condition préalable
3. Opérateur de boucle avec postcondition

Nous les examinerons en détail dans l’article suivant.

1. Méthodes de construction de processus de calcul cycliques dans les programmes.

2. Entré dans l'ordinateurNnombres réels. Écrivez un programme qui affiche la moyenne arithmétique de cet ensemble.

Introduction

Les programmes cycliques sont utilisés dans presque tous les logiciels. Dans ce cas, les cycles peuvent être explicites ou implicites. En particulier, la boucle implicite est présente dans les gestionnaires d'interruption, qui s'exécutent effectivement dans une boucle infinie dont le corps est déclenché par l'interruption. Les sous-programmes - fonctions de fenêtre des applications Windows - sont également cycliques. Ci-dessous, nous considérons les programmes avec une boucle dont le corps contient des modules fonctionnels.

Processus cyclique est un processus informatique dans lequel des calculs sont effectués à plusieurs reprises en utilisant les mêmes formules pour différentes valeurs de l'argument.

Programmes, mettant en œuvre un processus cyclique sont appelés programmes cycliques.

L'organisation du cycle peut être divisée en les étapes suivantes :

préparation (initialisation) du cycle (AND) ;

effectuer des calculs de boucle (corps de boucle) (T) ;

modification des paramètres (M) ;

vérifier la condition de fin de cycle (U).

L'ordre de ces étapes, telles que T et M, peut varier. Selon le lieu du contrôle de l'état de fin de cycle, on distingue les cycles à fin inférieure et supérieure. Pour une boucle se terminant par le bas, le corps de la boucle est exécuté au moins une fois car les calculs sont effectués en premier, puis la condition de sortie de la boucle est vérifiée.

Dans le cas d'une boucle de fin supérieure, le corps de la boucle peut ne pas être exécuté une seule fois si la condition de sortie est immédiatement remplie.

Un cycle est dit déterministe si le nombre de répétitions du corps de la boucle est connu ou déterminé à l'avance. Un cycle est dit itératif si le nombre de répétitions du corps de boucle est inconnu à l'avance, mais dépend des valeurs des paramètres (certaines variables) impliqués dans les calculs.

Corps de boucle- Il s'agit d'une section répétée du programme à plusieurs reprises.

Paramètre de boucle est une variable qui prend de nouvelles valeurs à chaque fois que la boucle est répétée (les boucles peuvent être simples ou complexes).

Vue générale de la boucle n fois

En général, une boucle n fois s’écrit ainsi :

nc nombre de répétitions fois

Les mots de service nts (début du cycle) et kts (fin du cycle) sont écrits strictement l'un en dessous de l'autre et reliés par une ligne verticale. À droite de cette ligne, une séquence répétable de commandes (corps de la boucle) est écrite.

Le nombre de répétitions est un nombre entier arbitraire.

Lors de l'exécution de l'algorithme, la séquence de commandes dans le corps de la boucle est répétée le nombre de fois spécifié. Les règles du langage algorithmique permettent de spécifier n'importe quel nombre entier de répétitions. Il peut être nul, voire négatif. Ces cas ne sont pas considérés comme erronés, le corps de la boucle ne sera tout simplement pas exécuté une seule fois et l'ordinateur procédera immédiatement à l'exécution des commandes écrites après cc.

Vue générale du cycle jusqu'à présent

De manière générale, le cycle s'écrit actuellement comme suit :

pas encore de condition

| corps de boucle (séquence de commandes)

Lors de l'exécution d'un cycle, l'ordinateur répète les actions suivantes :

a) vérifie la condition écrite après le mot de fonction while ;

b) si la condition n'est pas remplie, alors l'exécution de la boucle se termine et l'ordinateur commence à exécuter les commandes écrites après cc. Si la condition est remplie, alors l'ordinateur exécute le corps de la boucle, vérifie à nouveau la condition, etc.

Vue générale du cycle pour

nc pour i de i1 à i2

| corps de boucle (séquence de commandes)

Ici, i est le nom d'une valeur de type entier, i1, i2 sont des entiers arbitraires ou des expressions avec des valeurs entières. Le corps de la boucle est exécuté séquentiellement pour i = i1, i = i1 + 1, i1 + 2,…i = i2.

Les règles du langage algorithmique permettent de spécifier n'importe quel entier i1, i2. en particulier, i2 peut être inférieur à i1. ce cas n'est pas considéré comme une erreur - simplement le corps de la boucle ne sera pas exécuté une seule fois et l'ordinateur procédera immédiatement à l'exécution des commandes écrites après cc.

Boucle n fois et boucle pendant

Les boucles n fois et jusqu'à présent sont formatées presque de la même manière dans le langage algorithmique. Cela n’est pas surprenant, car ces deux commandes définissent une boucle – une séquence répétitive de commandes. Les mots de service nts et kts indiquent qu'une boucle est en cours d'exécution et l'en-tête de la boucle spécifie le mécanisme spécifique de son exécution.

Cependant, ces deux cycles présentent une différence significative. Lorsque l’ordinateur commence à exécuter une boucle n fois, il sait combien de fois il devra répéter le corps de la boucle. Lors de l'exécution d'une boucle, ce n'est pas encore le cas : l'ordinateur vérifie à chaque fois l'état de la boucle et ne peut pas déterminer à l'avance quand l'exécution se terminera. Pour l'instant, vous ne pouvez connaître le nombre de répétitions d'un cycle qu'une fois le cycle terminé.

Cela indique clairement dans quels cas quelle boucle doit être utilisée. Si le nombre de répétitions est connu au moment où la boucle démarre, il est pratique d’utiliser la boucle n fois. Si le nombre de répétitions ne peut être déterminé à l'avance, un cycle est nécessaire.

Par exemple, un programme de contrôle automatique a la structure illustrée à la Fig. 1. Modules inclus dans le cycle(ainsi que les modules de gestion des interruptions), avec une entrée et une sortie chacun, ont généralement la caractéristique que les modules contiennent des variables statiques auxquelles une valeur est attribuée dans le cycle en cours, et l'analyse de ces variables est effectuée dans le cycle suivant . Ainsi, les variables mentionnées caractérisent l'état du module à la fin du cycle de programme en cours ou au début du prochain cycle de programme. Dans ce qui suit, nous ne considérerons que ces modules de programmes cycliques et les désignerons brièvement par MCP.

Fig. 1. Structure typique d'un programme de contrôle avec une boucle infinie.

Les MCP ont une structure variée dont la complexité doit être évaluée selon des critères particuliers. V.V. Lipaev a proposé un critère pratique et objectif pour la complexité des modules logiciels, à savoir : le nombre et la longueur totale des chemins dans le graphe de contrôle du module. Seules les instructions conditionnelles et de sélection sont prises en compte. Cependant, ce critère n'est clairement pas suffisant pour un MCP avec mémoire statique, car lors de l'analyse d'un MCP, il est nécessaire de mémoriser les valeurs de toutes les variables statiques définies lors du cycle précédent. De plus, il n'existe aucune recommandation pour la standardisation des algorithmes et des programmes, à l'exception de la programmation structurée bien connue dans les langages de programmation couramment utilisés tels que C et Pascal. Cet article propose de combler ces lacunes par rapport au MCP.

2. Fragments de modules de programme cycliques

Un fragment à deux terminaux, ou simplement un fragment, sera considéré comme une section d'un programme avec une entrée et une sortie (y compris les opérateurs de boucle) dans l'hypothèse où les MCP considérés sont structurés. Le fragment le plus simple comprend une seule instruction. Une séquence de fragments est aussi un fragment. Le MCP, quant à lui, est un fragment et consiste en une séquence de fragments.

La méthode des fragments indépendants est proposée pour synthétiser la structure des modules qui implémentent des tables de décision. Dans ce cas, un fragment pouvant être inséré n'importe où dans la séquence de fragments de module est considéré comme indépendant. L'indépendance de l'emplacement d'un tel fragment est due au fait que les données analysées ne sont pas générées dans la séquence de fragments spécifiée et que les données générées dans le fragment indépendant ne sont pas analysées dans cette séquence de fragments. Par conséquent, des fragments indépendants peuvent être exécutés en parallèle (pseudo-parallèle). En figue. La figure 2 montre les options de mise en œuvre possibles pour un module avec deux fragments indépendants. Dans les options « a » et « b », les fragments sont réorganisés sans dénaturer l'essence du programme ; dans l'option «c», les fragments sont implémentés en parallèle.

Fig.2. Options d'implémentation d'un module avec des fragments indépendants :

a) et b) - mise en œuvre séquentielle,

c) - mise en œuvre parallèle : un double trait horizontal indique la parallélisation du programme, un trait horizontal épais indique l'achèvement de processus parallèles.

Un fragment dépendant est un fragment dont l'emplacement dépend de l'emplacement d'un ou plusieurs autres fragments dans le module. Nous distinguerons les fragments dépendants du dessus et du dessous. Le fragment dépendant du haut doit toujours être situé en dessous d'un fragment dans lequel sont formées les variables utilisées dans ce fragment (dépendant). Un fragment dépendant du bas doit toujours être placé au-dessus d'un fragment qui utilise des variables générées dans ce fragment. Deux fragments dépendants, dont l'un dépend par le haut du second, et le second par le bas dépendant du premier, seront appelés fragments mutuellement dépendants. Ils ne peuvent pas être échangés et ne peuvent pas être mis en œuvre en parallèle. En figue. La figure 3 montre un exemple de module avec des fragments mutuellement dépendants. Entre des fragments mutuellement dépendants, il peut y en avoir d'autres, dépendants ou indépendants d'eux. Figure 3. Module avec fragments dépendants.

Nous appellerons un fragment dépendant dont l'emplacement dans le module est strictement défini comme fixe. Par exemple, dans le module de reconnaissance d'un caractère saisi au clavier, le premier doit être le fragment dépendant du bas du caractère effectivement saisi. Les opérateurs « début » et « fin » d'un module sont des fragments fixes.

Les fragments absolument indépendants n'existent pas, ne serait-ce que parce que dans tout module il y a les fragments fixes mentionnés du début et de la fin. Par conséquent, un fragment indépendant a en général une zone de localisation possible limitée par deux fragments mutuellement dépendants. C'est-à-dire qu'une définition plus stricte d'un fragment indépendant est la suivante : indépendant par rapport à deux fragments fixes, nous appellerons un fragment qui peut être placé n'importe où dans la séquence de fragments délimitée au-dessus et en dessous par les fragments fixes spécifiés.