Comment s’appelle l’opérateur de sortie de message ? Opérateur d'E/S en Pascal. Une description de certains types de données standard ainsi que des opérations et fonctions intégrées qui s'y appliquent. Opérateurs de sortie

L'interaction du programme avec l'environnement externe (utilisateur, autres programmes, données stockées) est absolument nécessaire. Responsable d'une telle interface dans les langages de programmation Instructions d'E/S information. Ces instructions vous permettent de saisir des données dans le programme pendant que le programme est en cours d'exécution (et non au stade de son écriture) et de sortir les données calculées sous une forme compréhensible pour les humains.

Ces commandes vous permettent de saisir des données dans des variables uniques ou dans plusieurs variables à la fois pendant l'exécution du programme à partir du clavier. Les éléments de la liste de saisie peuvent être des noms de variables, qui doivent être remplis avec des valeurs saisies au clavier.

L'exécution des instructions d'entrée se déroule comme suit : le programme est suspendu, un curseur s'affiche à l'écran et l'ordinateur attend de l'utilisateur qu'il fournisse un ensemble de données pour les variables dont les noms sont indiqués dans la liste d'entrée. L'utilisateur saisit les signes nécessaires à l'aide du clavier dans l'ordre dans lequel ils sont requis par la liste de saisie et appuie sur Entrée. Après cela, les données saisies vont dans les variables correspondantes et l'exécution du programme continue. Les données d'entrée sont séparées par des espaces.

Lors de la saisie des données sources, une transformation se produit de la forme externe de représentation à la forme interne, déterminée par le type de variables. Les variables qui composent la liste d'entrée peuvent être de type entier, réel ou caractère. La lecture des données source booléennes n'est pas autorisée.

La différence entre le fonctionnement des opérateurs Read et Readln en Pascal est la suivante : après l'exécution de Read, la valeur des données suivantes est lue à partir de la même ligne, et après l'exécution de Readln, à partir d'une nouvelle ligne.

Ces opérateurs vous permettent d'afficher les données de la liste de sortie sur l'écran du moniteur. Les éléments de la liste de sortie peuvent être des noms de variables, des expressions et des constantes. Avant d'afficher les valeurs des expressions, l'ordinateur les évalue d'abord. Les éléments de la liste, comme dans les instructions d'entrée, sont séparés par des virgules.

La différence entre les deux opérateurs de sortie en Pascal est la suivante : après l'exécution de l'opérateur Writeln (à partir de la ligne Write), une transition vers une nouvelle ligne se produit, et après l'exécution de l'instruction Write, la transition vers une nouvelle ligne ne se produit pas et l'impression lors des commandes de sortie Write ou Writeln suivantes, elles se produiront sur la même ligne. Lorsque vous appelez l'opérateur Writeln sans paramètres, il passe simplement à une nouvelle ligne.

En BASIC, chaque nouvelle instruction PRINT imprime les valeurs sur une nouvelle ligne.

Les variables qui composent la liste de sortie peuvent être de type entier, réel, caractère ou booléen. En plus des noms de variables, des expressions et des chaînes peuvent être utilisées comme éléments de la liste de sortie.

Chaque valeur est affichée sur une ligne de l'écran en fonction de la largeur du champ de sortie, déterminée par l'implémentation spécifique du langage.

La forme de représentation des valeurs dans le champ de sortie correspond au type de variables et d'expressions : les valeurs de type entier sont sorties sous forme de nombres décimaux entiers, de type réel - sous forme de nombres décimaux réels avec ordre décimal, de type de caractère et chaîne - sous forme de caractères, de type logique - sous forme de constantes logiques VRAI et FAUX.

Considérez la procédure de lecture des informations d'un fichier en Pascal.

Vous devez d'abord déclarer une variable de fichier. Les variables de fichier ont des utilisations spécifiques. Vous ne pouvez effectuer aucune opération sur eux (attribuer une valeur, comparer, etc.). Ils ne peuvent être utilisés que pour effectuer des opérations sur des fichiers (lecture, écriture, etc.).

Avant que des E/S puissent se produire, une variable de fichier doit être associée à un fichier externe spécifique à l'aide de la procédure Assign.

Attribuer(<Имя файловой переменной>,<Имя файла>);

Le nom du fichier sera spécifié soit sous forme de constante de chaîne, soit via une variable de chaîne. Le nom du fichier doit correspondre aux règles du système d'exploitation actuellement en cours d'exécution. Si la ligne de nom est vide, alors la variable de fichier est associée à un périphérique d'entrée/sortie standard (généralement la console).

Après cela, le fichier doit être ouvert par l'une des procédures suivantes :

Réinitialiser(<Имя файловой переменной>);

Un fichier existant est ouvert en lecture et le pointeur de composant actuel du fichier est placé au début du fichier. Si le fichier physique correspondant à la variable de fichier n'existe pas, une condition d'erreur d'E/S se produit.

Récrire(<Имя файловой переменной>);

Un nouveau fichier vide est ouvert en écriture et reçoit le nom spécifié par la procédure Assign. Si un fichier du même nom existe déjà, il est détruit. Après avoir travaillé avec un fichier, celui-ci doit généralement être fermé à l'aide de la procédure Fermer.

Fermer(<Имя файловой переменной>);

Cette condition doit être remplie pour le fichier dans lequel l'enregistrement a été effectué.

En considérant un exemple d'opérateur d'affectation, nous avons été confrontés à la nécessité de connaître le résultat de l'exécution du programme. Nous avons compris comment stocker l'information (dans des variables), comment la traiter (à l'aide d'expressions), mais deux processus d'information fondamentaux sont restés en dehors de notre attention : recevoir des informations et les transmettre au monde extérieur à l'ordinateur. Jusqu'à présent, nos programmes ne peuvent utiliser que les informations situées directement dans le texte du programme. Il n'a pas non plus été possible de connaître les valeurs actuelles des variables. Programmer dans de telles conditions n’a plus de sens.

L'interaction des dispositifs de traitement et de stockage de l'information avec les supports externes (au moins avec l'utilisateur) est absolument nécessaire. En Pascal, les opérateurs d'entrée/sortie d'informations sont responsables d'une telle interface. Ces instructions permettent de saisir des arguments et des paramètres de calcul lors de l'exécution du programme (et non au stade de son écriture), et de sortir les données calculées sous une forme compréhensible pour l'homme.

Déclarations d'entrée (formats de déclaration) :

Lire(<Список ввода>); Lire (<Список ввода>);

Dans ce format, ces commandes permettent de saisir des données dans des variables lors de l'exécution du programme à partir du clavier. Les éléments de la liste de saisie peuvent être des noms de variables, qui doivent être remplis avec des valeurs saisies au clavier. L'exécution des instructions d'entrée se déroule comme suit : le programme est suspendu, un curseur s'affiche à l'écran et l'ordinateur attend de l'utilisateur qu'il fournisse un ensemble de données pour les variables dont les noms sont indiqués dans la liste d'entrée. L'utilisateur saisit les valeurs requises à partir du clavier dans l'ordre dans lequel elles sont requises par la liste de saisie et appuie sur Entrée. Après cela, les données saisies vont dans les variables correspondantes et l'exécution du programme continue.

Remarque : Les données saisies sont séparées par des espaces.

La différence entre le fonctionnement des procédures Read et Readln (à partir de la ligne Read) est la suivante : après l'exécution de Read, la valeur des données suivantes est lue à partir de la même ligne, et après l'exécution de Readln - à partir d'une nouvelle ligne.

Il existe également deux commandes pour afficher des informations en Pascal :

Écrire(<Список вывода>); Écrire (<Список вывода>);

Ce format d'utilisation de Write et Writeln vous permet d'afficher les données de la liste de sortie sur l'écran du moniteur. Les éléments de la liste de sortie peuvent être des noms de variables, des expressions et des constantes. Avant d'afficher les valeurs des expressions à l'écran, l'ordinateur va d'abord les calculer. Les éléments de la liste, comme dans les instructions d'entrée, sont séparés par des virgules. La différence entre les deux opérateurs de sortie est la suivante : après l'exécution de l'opérateur Writeln (à partir de la ligne Write), une transition vers une nouvelle ligne se produit, et après l'exécution de l'instruction Write, la transition vers une nouvelle ligne ne se produit pas et l'impression sur les suivantes Les commandes de sortie Write ou Writeln se produiront sur la même ligne. Lorsque vous appelez l’opérateur Writeln sans paramètres, il passe simplement à une nouvelle ligne.

Voici un exemple d'utilisation des opérateurs d'entrée et de sortie :

Interface du programme ;

Write("Entrez le rayon du cercle"); (Imprimer à l'écran pour demander une saisie)

Lire(R); (En saisissant la valeur dans

variable R depuis le clavier)

S:=4*ARCTAN(1)*SQR(R); (Calcul de l'aire d'un cercle (pR2))

Writeln("L'aire d'un cercle de rayon ",R" est ",S)

Ce programme demande à l'utilisateur le rayon d'un cercle, offre la possibilité de saisir sa valeur, calcule et affiche l'aire d'un cercle avec ce rayon. Ainsi, il devient possible, sans apporter de modifications au texte du programme, de saisir différentes valeurs de rayon et d'obtenir les valeurs de zone de cercle correspondantes. Pour ce faire, exécutez simplement le programme plusieurs fois. Ce programme démontre également la règle suivante : la sortie des résultats doit être commentée afin que la signification des nombres imprimés soit claire. En effet, on pourrait se limiter à Writeln(S), mais la signification du nombre produit par le programme dans ce cas ne serait claire que pour celui qui a écrit le programme.

Afin de visualiser le résultat de ce programme, il doit d'abord être compilé. Vous pouvez le faire en Pascal en appuyant sur la combinaison de touches Ctrl+F9. Le programme sera vérifié pour les erreurs (s'il y en a, vous recevrez un message en haut de l'écran et le curseur se déplacera vers l'emplacement de l'erreur). Si aucune erreur n'est trouvée, le résultat sera affiché et vous pourrez le visualiser en appuyant sur la combinaison de touches Alt+F5.

Taper un programme en Pascal est similaire à taper un fichier texte ordinaire, seul l'environnement TurboPascal est utilisé pour cela. Vous pouvez le lancer depuis votre bureau.

Exemple. Déterminer le volume et l'aire de la surface latérale d'un cylindre avec un rayon de base R et une hauteur H donnés.

Cylindre de programme ;

R, (rayon de base du cylindre)

H, (hauteur du cylindre)

V, (volume du cylindre)

S : Réel ; (surface latérale du cylindre)

Write("Entrez la hauteur du cylindre : "); LireLn(H);

Write("Entrez le rayon de base : "); LireLn(R);

V : = Pi * R * R * H ;

S := 2 * Pi * R * H ; ÉcrireLn ;

WriteLn("Volume du cylindre = ", V : 5 : 2); (Ici 5 est le nombre total de positions occupées par la variable V lors de la sortie, et 2 est le nombre de positions dans la partie fractionnaire de la valeur V)

WriteLn("Surface latérale = ",);

Mission de laboratoire.

1. Calculez la circonférence, l'aire d'un cercle et le volume d'une balle de même rayon donné.

2. Calculez la valeur de la fonction y = 3x 2 + 4(sin(x)- x 3)

Si vous vous souvenez, en considérant un exemple d'opérateur d'affectation, nous avons été confrontés à la nécessité de connaître le résultat de l'exécution du programme. Nous avons compris comment stocker l'information (dans des variables), comment la traiter (à l'aide d'expressions), mais deux processus d'information fondamentaux sont restés en dehors de notre attention : recevoir des informations et les transmettre au monde extérieur à l'ordinateur. Jusqu'à présent, nos programmes ne peuvent utiliser que les informations situées directement dans le texte du programme. Il n'a pas non plus été possible de connaître les valeurs actuelles des variables. Programmer dans de telles conditions n’a plus de sens.

L'interaction des dispositifs de traitement et de stockage de l'information avec l'environnement extérieur (au moins avec l'utilisateur) est absolument nécessaire. En Pascal, les opérateurs d'entrée/sortie d'informations sont responsables d'une telle interface. Ces instructions permettent de saisir des arguments et des paramètres de calcul lors de l'exécution du programme (et non au stade de son écriture), et de sortir les données calculées sous une forme compréhensible pour l'homme.

Tout d'abord les instructions d'entrée (formats d'instructions) :

Lire(<Список ввода>);

Lire (<Список ввода>);

L'exécution des instructions d'entrée se déroule comme suit : le programme est suspendu, un curseur s'affiche à l'écran et l'ordinateur attend de l'utilisateur qu'il fournisse un ensemble de données pour les variables dont les noms sont indiqués dans la liste d'entrée. L'utilisateur saisit les valeurs requises à partir du clavier dans l'ordre dans lequel elles sont requises par la liste de saisie et appuie sur Entrée. Après cela, les données saisies vont dans les variables correspondantes et l'exécution du programme continue.

Remarque : Les données saisies sont séparées par des espaces.

Il existe également deux commandes pour afficher des informations en Pascal :

Écrire(<Список вывода>);

Écrire (<Список вывода>);

La différence entre les deux opérateurs de sortie est la suivante : après l'exécution de l'opérateur Writeln (à partir de la ligne Write), une transition vers une nouvelle ligne se produit, et après l'exécution de l'instruction Write, la transition vers une nouvelle ligne ne se produit pas et l'impression sur les suivantes Les commandes de sortie Write ou Writeln se produiront sur la même ligne. Lorsque vous appelez l’opérateur Writeln sans paramètres, il passe simplement à une nouvelle ligne.

Voici un exemple d'utilisation des opérateurs d'entrée et de sortie :

Interface du programme ;

Write("Entrez le rayon du cercle"); (Imprimer à l'écran pour demander une saisie)

Lire(R); (Saisie d'une valeur dans la variable R à partir du clavier)

S:=4*ARCTAN(1)*SQR(R); (Calcul de l'aire d'un cercle (pR2))

Writeln("L'aire d'un cercle de rayon ",R" est ",S)

OPÉRATEURS D'ENTRÉE ET DE SORTIE

Considérons l'organisation de l'entrée et de la sortie des données d'un terminal. Un terminal est un appareil avec lequel l'utilisateur interagit, généralement un écran (affichage) et un clavier. Pour entrer et sortir des données, des procédures d'entrée et de sortie standard, Read et Write, sont utilisées, fonctionnant avec des fichiers séquentiels standard INPUT et OUTPUT.

Ces fichiers sont divisés en lignes de longueur variable, séparées les unes des autres par une marque de fin de ligne. La fin de la ligne est spécifiée en appuyant sur la touche ENTER.

Pour saisir les données source, des opérateurs de procédure de saisie sont utilisés :

Lire (A1,A2,...AK);

LireLn(A1,A2,...AK);

Le premier d'entre eux implémente la lecture des valeurs K des données source et l'attribution de ces valeurs aux variables A1, A2, ..., AK. Le deuxième opérateur implémente la lecture des valeurs K des données source, en sautant les valeurs restantes jusqu'au début de la ligne suivante et en attribuant les valeurs lues aux variables A1, A2, ..., AK. Le troisième opérateur implémente le saut d'une ligne de données source.

Lors de la saisie des données sources, une transformation se produit de la forme externe de représentation à la forme interne, déterminée par le type de variables. Les variables qui composent la liste d'entrée peuvent être de type entier, réel ou caractère. La lecture de données source booléennes en PASCAL n'est pas autorisée.

Les instructions d'entrée lors de la lecture de valeurs de variables de type entier et réel ignorent les espaces précédant le nombre. Dans le même temps, ces opérateurs ne sautent pas les espaces précédant les valeurs des variables de caractères, puisque les espaces sont des caractères égaux dans les chaînes. Un exemple d'écriture d'instructions d'entrée :

var rV, rS : Réel ;

iW, iJ : entier ;

................

Lire (rV, rS, iW, iJ) ;

Les valeurs des données sources peuvent être séparées les unes des autres par des espaces et en appuyant sur les touches Tab et Entrée.

Pour afficher les résultats du programme à l'écran, les opérateurs suivants sont utilisés :

Écrire(A1,A2,...AK);

ÉcrireLn(A1,A2,...AK);

Le premier de ces opérateurs implémente la sortie des valeurs des variables A1, A2,...,AK sur une ligne de l'écran. Le deuxième opérateur implémente la sortie des valeurs des variables A1, A2, ..., AK et le passage au début de la ligne suivante. Le troisième opérateur implémente le saut de ligne et le passage au début de la ligne suivante.

Chaque valeur est affichée sur une ligne de l'écran en fonction de la largeur du champ de sortie, déterminée par l'implémentation spécifique du langage.

La forme de représentation des valeurs dans le champ de sortie correspond au type de variables et d'expressions : les valeurs de type entier sont sorties sous forme d'entiers décimaux, de type réel - sous forme de nombres décimaux réels avec ordre décimal, du caractère type et chaîne - en tant que caractères, de type logique - en tant que constantes logiques VRAI et FAUX.

L'opérateur de sortie vous permet de définir la largeur du champ de sortie pour chaque élément de la liste de sortie. Dans ce cas, l'élément de liste de sortie a la forme A:K, où A est une expression ou une chaîne, K est une expression ou une constante entière. Si la valeur de sortie occupe moins de positions dans le champ de sortie que K, alors des espaces sont placés avant cette valeur. Si la valeur affichée ne rentre pas dans la largeur du champ K, alors le nombre de positions requis sera alloué pour cette valeur. Pour les valeurs de type réel, un élément de la liste de sortie peut avoir la forme A:K:M, où A est une variable ou une expression de type réel, K est la largeur du champ de sortie, M est le nombre de chiffres de la partie fractionnaire de la valeur de sortie. K et M sont des expressions ou des constantes de type entier. Dans ce cas, les valeurs réelles sont affichées sous forme décimale à virgule fixe. Un exemple d'écriture d'instructions de sortie :

. . . . . . . . . . . .

var rA, rB : Réel ; iP,iQ : entier ;

bR, bS : booléen ; chT, chV, chU, chW : Char ;

. . . . . . . . . . . .

ÉcrireLn(rA, rB:10:2);

ÉcrireLn(iP, iQ:8);

ÉcrireLn(bR, bS:8);

WriteLn(chT, chV, chU, chW);

Mots clés. Opérateur de saut inconditionnel.

Chaque maison dans la rue a son propre numéro, toutes les personnes ont leur propre nom, même les cellules de la mémoire de l'ordinateur ont chacune leur propre adresse. Tout cela est pris pour pouvoir indiquer sans ambiguïté l'objet en cours de définition. De même, les étiquettes sont utilisées pour indiquer les instructions dans les programmes.

Une étiquette dans le standard du langage Pascal est un entier non négatif. Toutes les étiquettes utilisées dans le programme doivent être répertoriées dans la section de description de l'étiquette, en commençant par le mot de service Étiquette, par exemple :

Un seul opérateur peut être marqué d’une seule étiquette. L'étiquette est séparée de l'instruction marquée par deux points.

6 : Écrire (14/2) ;

Dans tous les programmes donnés précédemment, les énoncés étaient exécutés les uns après les autres dans l'ordre dans lequel ils étaient écrits dans le texte. Cette structure algorithmique est appelée succession directe. Cependant, dans le langage Pascal, il existe initialement un opérateur qui perturbe l'exécution linéaire du programme, transférant le contrôle à un point arbitraire. Cette instruction est appelée saut inconditionnel et a le format suivant :

Aller à<метка>;

L'opérateur vers lequel se produit la transition doit être marqué de cette étiquette.

L'opérateur de saut inconditionnel doit être utilisé avec une extrême prudence pour éviter d'obtenir des résultats erronés ou de boucler complètement le programme. En général, l'utilisation de cette commande par les programmeurs est considérée comme une mauvaise forme. Comme vous le verrez, il est toujours possible de s’en passer.

ÉLÉMENTS DE PROGRAMMATION STRUCTURÉE

Un programme structuré (ou sous-programme) est un programme composé d'un ensemble fixe de constructions de base. Considérons les définitions et méthodes de base pour former ces constructions dans des schémas algorithmiques.

A partir des opérations, des bifurcations et des fusions, des structures de base se construisent : suivi, branchement, cycle. En utilisant uniquement ces trois constructions, vous pouvez implémenter un algorithme pour résoudre n'importe quel problème.

Une construction qui représente l'exécution séquentielle de deux ou plusieurs opérations est appelée suivante.

Une construction composée d’un fork, de deux opérations et d’une fusion est appelée un fork. Il se peut qu'une des opérations soit manquante.

Une conception comportant des lignes de contrôle menant à des opérations ou des branches précédentes est appelée une boucle.

Les constructions suivantes, de branchement et de boucle, peuvent être considérées comme des opérations car elles ont une seule entrée et une seule sortie. Une séquence arbitraire d’opérations peut être représentée comme une seule opération.

L'opération peut être implémentée par n'importe quel opérateur du langage PASCAL (simple ou composé), ou un groupe d'opérateurs, à l'exception de l'opérateur de transition GOTO.

En langage PASCAL le nombre de structures de base a été porté à six, à savoir :

Suivant;

Ramification ;

Boucle avec condition préalable ;

Boucle avec postcondition ;

Boucle avec paramètre ;

Opérateur conditionnel

L'une des principales structures algorithmiques est le branchement (alternatif).

Si la condition est remplie, alors l’instruction « 1 » sera exécutée ; sinon, alors l’instruction « 2 » sera exécutée. Même s’il y a deux actions dans le circuit, une seule sera exécutée car la condition est fausse ou vraie. Il n'y a pas de troisième. Ce schéma vous permet de résoudre des problèmes dans lesquels, selon les circonstances, vous devez effectuer l'une ou l'autre action. Il ne fait aucun doute que le nombre de problèmes de ce type est énorme. De plus, il est très difficile de proposer une tâche vraiment significative dont l'algorithme d'exécution contiendrait une simple séquence directe de commandes. Même un exemple primitif tiré d'un cours de mathématiques, comme vous le verrez, ne peut être résolu sans utiliser de branchement. Il faut donc calculer la valeur de l’expression y=1/x. Vous savez qu'une fonction donnée n'a pas toujours de valeur, c'est-à-dire que toutes les valeurs d'argument n'ont pas de valeur de résultat. Notre tâche est de composer l'algorithme de manière à ce que l'exécuteur ne se retrouve jamais dans une impasse, même s'il reçoit zéro comme argument. Il n’est pas difficile de formuler cela en langage naturel :

1. Obtenez la valeur de x.

2. Si x=0, signalez que l'expression n'a aucune valeur, sinon calculez y comme 1/x.

La structure algorithmique ci-dessus est utilisée de cette manière. Cela peut être exprimé avec des mots simples :

Si<усл.>(Si la condition est remplie)

Que<действие 1>(puis effectuez l'action numéro 1)

sinon<действие 2>(sinon - effectuer l'action n°2)

Comment écrire cela en Pascal ? Oui, exactement la même chose, uniquement en anglais.

Format de l'opérateur conditionnel en Pascal :

Si<условие>

Alors<оператор 1>

Autre<оператор 2>;

Veuillez noter qu'il n'y a qu'une seule instruction dans les parties Then et Else. Mais que faire pour résoudre un problème dans lequel, pour satisfaire ou non une condition, il faut effectuer non pas une, mais plusieurs actions ? C'est là que l'opérateur du complexe que vous connaissez déjà vient à la rescousse. Vous pouvez placer n’importe quel nombre d’opérateurs entre parenthèses.

Une variante de l'opérateur conditionnel dans ce cas :

Si<условие>

Alors commencez<группа операторов 1>fin

Sinon, commencez< группа операторов 2>fin;

Le point-virgule n'est pas placé avant le mot de fonction Else, mais les instructions des groupes sont naturellement séparées les unes des autres par ce point-virgule.

Parlons maintenant des conditions. Dans les programmes Pascal, les conditions sont des expressions dont la valeur est une valeur booléenne. Il peut s'agir soit d'une simple variable du type spécifié, soit d'une séquence complexe d'instructions reliées par des opérations logiques.

Dans des conditions simples, des opérateurs de comparaison peuvent être utilisés : >(supérieur à),<(меньше), =(равно), <>(pas égal), >= (supérieur ou égal),<=(меньше или равно).

Exemples de conditions simples : A=5 (La valeur de la variable A est 5)

(C+D3)>=(D1*(45-2)) (La valeur de l'expression du côté gauche est supérieure ou égale à la valeur de l'expression du côté droit)

S<>"ABC" (La valeur de la variable S n'est pas égale à la constante chaîne "ABC")

Donnons un exemple de résolution d'un autre problème : « Choisissez le plus grand de deux nombres ».

À première vue, la solution est évidente, mais elle n’est pas aussi anodine qu’il y paraît.

Exemple de programme ;

Var A,B,C : Réel ; (A,B - pour stocker les arguments, C - résultat)

Writeln("Entrez deux nombres");

Lire(A,B); (Entrez les arguments à partir du clavier)

Si A>B Alors C:=A Sinon C:=B; (Si A>B, alors le résultat est A, sinon le résultat est B)

Écrire(C); (On affiche le résultat à l'écran)

Autre exemple classique : « Résoudre une équation quadratique en utilisant des coefficients donnés. » Cette tâche est plus compliquée, donc avant d'écrire le programme, créons un algorithme, en l'écrivant sous la forme d'un schéma fonctionnel. On entre d'abord les coefficients, puis on calcule le discriminant. Deux possibilités se présentent alors : soit il n'y a pas de racines réelles dans le cas d'un discriminant négatif, soit ces racines peuvent quand même être calculées et affichées dans le cas d'un discriminant non négatif (le cas où le discriminant est égal à zéro est inclus ici). , il y a deux racines, seulement ce sont les mêmes J).

Lorsque vous écrivez un algorithme dans un langage de programmation, vous devez tenir compte du fait que dans la branche « non » il n'y a pas une action, mais trois, vous devez donc utiliser un opérateur composé. N'oubliez pas d'écrire les expressions arithmétiques selon les règles du langage Pascal. Sinon, ce programme n'est pas plus compliqué que le précédent.

Var A, B, C, D, X1, X2 : Réel ;

Writeln("Entrez les coefficients de l'équation quadratique");

Si D<0 Then Writeln ("Корней нет! ")

X1:=(-B+SQRT(D))/2/A;

X2:=(-B-SQRT(D))/2/A;

Il est intéressant de noter qu'un opérateur conditionnel peut agir comme un opérateur exécuté lorsqu'une condition est remplie ou non. Dans ce cas, on parle d’instructions conditionnelles imbriquées. Lors de la résolution de problèmes de ce type, je recommande fortement de dresser un organigramme de l'algorithme dans un cahier. Alors seulement, lors de la composition du programme, tout ce que vous avez à faire est d'écrire soigneusement toute la partie Alors d'abord, puis de passer à la partie Else. Généralement, lors de l'écriture d'instructions conditionnelles en Pascal (en particulier avec plusieurs branches), les commandes sont écrites en retrait vers la droite et vers le bas. Cela augmente la visibilité et, croyez-moi, réduit le temps perdu en débogage.

Pour illustrer, résolvons un autre problème : « résoudre une équation de la forme A*x^2 + B*x + C = 0 ». Ne la confondez pas avec une équation quadratique, pour laquelle on savait que le coefficient A n'est pas égal à zéro. Ici, les coefficients peuvent être n'importe quels nombres. Sur la base d'un raisonnement mathématique élémentaire, nous obtenons l'algorithme suivant :

Var A, B, C, D, X, X1, X2 : Réel ;

Writeln("Entrez les coefficients de l'équation (A, B, C)");

Si C=0 Alors Writeln("X est n'importe quel nombre")

Sinon Writeln("Pas de racines !")

Sinon, commencez X:=-C/B; Writeln("X=",X:8:3) Fin

Si D<0 Then Writeln ("Корней нет! ")

X1:=(-B+SQRT(D))/2/A;

X2:=(-B-SQRT(D))/2/A;

Écrire("X1=", X1:8:3, " X2=",X2:8:3)

Faire du vélo. Types de cycles.

Un cycle est la répétition répétée du même type d’action. Le corps du cycle sera constitué de ces mêmes actions qui doivent être répétées plusieurs fois.

Comme vous l'avez compris, vous pouvez répéter les mêmes actions en utilisant l'opérateur de saut inconditionnel. Si vous écrivez ces actions dans le programme les unes après les autres, et à la fin, placez un opérateur de saut au début de ce bloc. Cependant, de cette façon, vous ne pouvez obtenir qu'un programme qui s'exécute indéfiniment (boucles). Ceci peut être évité en utilisant un opérateur conditionnel avec l'opérateur de transition, rendant l'exécution de la transition dépendante de la réalisation d'une certaine condition. Ainsi, nous obtiendrons la structure d'un saut conditionnel et la possibilité d'organiser une boucle finale. D’une manière générale, nous pouvons ainsi résoudre presque tous les problèmes nécessitant la mise en œuvre d’un algorithme cyclique. Bien sûr, avec une seule hache, vous pouvez construire une maison. Posons-nous les questions suivantes : "Cette maison sera-t-elle belle ? Combien de temps et d'efforts pouvez-vous économiser en utilisant toutes sortes d'outils spéciaux ?" Pour quoi? - Pour la commodité, la brièveté, la facilité de lecture du programme et, oserais-je le dire, la beauté. Il existe donc trois types de boucles qui ont leurs propres opérateurs Pascal pour les écrire. Ces types ont leurs propres noms conventionnels : « Tandis que », « Avant », « Avec paramètre ». Ils sont quelque peu différents les uns des autres et sont utilisés chacun pour leur propre classe de tâches.

Cycle "au revoir"

Un groupe d'opérateurs appelé « corps de boucle », à en juger par ce diagramme, sera exécuté tant que la condition de boucle est vraie. La boucle se termine lorsque la condition n'est plus vraie.

Si la condition est initialement fausse, le corps de la boucle ne sera pas exécuté une seule fois. Si la condition est initialement vraie et qu'il n'y a aucune action dans le corps de la boucle qui affecte la vérité de cette condition, alors le corps de la boucle sera exécuté un nombre infini de fois. Cette situation est appelée « bouclage ». Un programme en boucle peut être interrompu soit par une instruction (en appuyant sur Ctrl+C), soit par un arrêt d'urgence du programme lui-même, en cas de dépassement de variable, de division par zéro, etc., il convient donc d'utiliser la structure en boucle avec prudence, sachant bien que les exécutions répétées devraient parfois finir.

En Pascal, la structure de la boucle While s'écrit comme suit :

Alors que<условие>Faire<оператор>;

Vraiment, succinctement ? En russe, cela peut se lire comme suit : « Tant que la condition est vraie, exécutez la déclaration ». Ici, tout comme dans le format d'instruction conditionnelle, une seule instruction est censée être exécutée. Si plusieurs actions doivent être effectuées, un opérateur composé peut être utilisé. Le format de l'opérateur prend alors la forme suivante :

Alors que<условие>Faire

<оператор #1>;

<оператор #2>;

<оператор #3>;

Cycle "AVANT"

Ce type de boucle diffère du précédent principalement en ce que la vérification de la condition de répétition du corps de la boucle n'a pas lieu avant, mais après. Par conséquent, le cycle « Avant » est appelé un cycle « avec postcondition » et « Pendant » est appelé un cycle « avec précondition ».

Notez également qu'une nouvelle itération (réexécution du corps de la boucle) ne se produit pas lorsque la condition est vraie, mais précisément lorsqu'elle est fausse. C'est pourquoi la boucle tire son nom (exécuter le corps de la boucle jusqu'à ce que la condition correspondante soit remplie).

10. Opérateurs d'entrée et de sortie

Considérons l'organisation de l'entrée et de la sortie des données d'un terminal.

des essaims. Le périphérique terminal est l'appareil qui fonctionne avec

utilisateur, généralement un écran (affichage) et un clavier.

Des procédures de saisie standard sont utilisées pour la saisie et la sortie des données.

et sortie de lecture et d'écriture fonctionnant sur des fichiers séquentiels standard

ENTRÉE et SORTIE.

Ces fichiers sont divisés en lignes de longueur variable, séparées par chacune

les uns des autres par un signe de fin de ligne. La fin de la ligne est précisée en appuyant sur la touche

Pour saisir les données source, des opérateurs de procédure de saisie sont utilisés :

Lire (A1,A2,...AK);

LireLn(A1,A2,...AK);

Le premier d'entre eux implémente la lecture des valeurs K des données source et l'application

attribuer ces valeurs aux variables A1, A2,..., AK. Deuxième opérateur

implémente la lecture des valeurs K des données source, en ignorant les valeurs restantes

jusqu'au début de la ligne suivante, en attribuant les valeurs lues au

variables A1, A2, ..., AK. Le troisième opérateur implémente le saut de ligne en utilisant

données en cours d'exécution.

Lors de la saisie des données sources, une transformation se produit à partir du

forme de représentation en une forme interne, déterminée par le type de variables. Pe-

Les variables formant la liste d'entrée peuvent appartenir soit à un nombre entier,

soit des types réels, soit des types de caractères. Lire l'original

Le type de données booléen n'est pas autorisé en PASCAL.

Déclarations d'entrée lors de la lecture des valeurs des variables entières et variables

le type réel ignore les espaces précédant le nombre.

Dans le même temps, ces opérateurs ne sautent pas les espaces précédant la valeur.

tion des variables de caractères, puisque les espaces sont égaux

caractères de chaîne. Un exemple d'écriture d'instructions d'entrée :

var rV, rS : Réel ;

iW, iJ : entier ;

................

Lire (rV, rS, iW, iJ) ;

Les valeurs des données sources peuvent être séparées par des espaces

et en appuyant sur les touches Tab et Entrée.

Pour afficher les résultats du programme à l'écran, utilisez

les opérateurs:

Écrire(A1,A2,...AK);

ÉcrireLn(A1,A2,...AK);

Le premier de ces opérateurs implémente la sortie des valeurs des variables A1,

Ligne A2,...,AK de l'écran. Le deuxième opérateur implémente la sortie

valeurs des variables A1, A2,..., AK et passage au début du suivant

lignes. Le troisième opérateur implémente le saut de ligne et le retour au début

ligne suivante.

Les variables qui composent la liste de sortie peuvent faire référence à un entier,

types réels, caractères ou booléens. En tant qu'élément

Dans la liste de sortie, en plus des noms de variables, des expressions peuvent être utilisées

et des lignes.

Chaque valeur est affichée sur une ligne de l'écran conformément à

en fonction de la largeur du champ de sortie spécifique à l'implémentation

La forme de présentation des valeurs dans le champ de sortie correspond au type

expressions et expressions : les valeurs de type entier sont affichées sous forme de dizaines entières

nombres réels - comme de vrais nombres décimaux

nombres avec ordre décimal, type de caractère et chaînes - sous forme de symboles

bœufs, type logique - sous forme de constantes logiques VRAI et FAUX.

L'opérateur de sortie vous permet de définir la largeur du champ de sortie pour chaque

élément de liste de sortie. Dans ce cas

l'élément de liste de sortie a la forme A:K, où

A - expression ou chaîne, K - expression ou constante entière.

Si la valeur de sortie occupe moins de positions dans le champ de sortie que K,

alors cette valeur est précédée d'espaces. Si la valeur de sortie est

ne rentre pas dans la largeur du champ K, alors pour cette valeur il y aura une ouverture

le nombre de postes requis est indiqué. Pour de vraies valeurs

un élément de liste de sortie peut avoir la forme A:K:M, où A est une variable ou une expression

définition du type réel, K - largeur du champ de sortie, M - nombre de chiffres

partie fractionnaire de la valeur de sortie. K et M sont des expressions ou des constantes

type entier. Dans ce cas, les valeurs réelles sont affichées sous la forme

nombre décimal à virgule fixe.

Un exemple d'écriture d'instructions de sortie :

. . . . . . . . . . . .

var rA, rB : Réel ; iP, iQ : Entier ;

bR, bS : booléen ; chT, chV, chU, chW : Char ;

. . . . . . . . . . . .

ÉcrireLn(rA, rB:10:2);

ÉcrireLn(iP, iQ:8);

ÉcrireLn(bR, bS:8);

Lors de la saisie des informations initiales et de la sortie des résultats, tout programme interagit avec des périphériques externes. Un cas particulier d'échange de données avec des appareils externes est l'échange avec la console. La console est une combinaison d'un clavier et d'un écran de contrôle.

Examinons les manières d'organiser l'entrée et la sortie des informations fournies par le langage de programmation Pascal.

Procédure d'entrée

La saisie de données est le processus de transfert des données source d'un périphérique externe vers la RAM.

Le périphérique d'entrée externe est généralement un clavier ou un fichier de données.

Pour saisir des données au clavier en Pascal, on utilise les procédures read et readln, ayant le format suivant :

lire (liste);
readln(liste);

La procédure readln est similaire à la procédure read, la seule différence est qu'après avoir lu la dernière valeur d'une variable de la liste, la saisie de données suivante est déplacée au début d'une nouvelle ligne.

L'élément « list » est une liste de noms de variables séparés par des virgules dont les valeurs seront saisies au clavier (notez que la liste peut être vide), par exemple :

lire (a, b, c);
lire;

Les valeurs saisies doivent être séparées par des espaces (espace, tabulation, nouvelle ligne) et leur nombre n'est pas limité. La saisie des données pour une procédure est terminée en appuyant sur la touche Entrée. Si la procédure readln est utilisée sans paramètres, elle attend que la touche Entrée soit enfoncée.

ATTENTION : les valeurs saisies doivent correspondre aux types des variables, sinon une erreur se produit (par exemple, la variable b est de type entier , mais l'entrée est un nombre réel).

Procédure de retrait

La sortie est le processus de transfert de données après traitement de la RAM vers un périphérique externe.

Pour afficher les données à l'écran en Pascal, on utilise les procédures write et writeln, qui ont la forme suivante :

écrire(liste);
écrire(liste);

Si vous utilisez la procédure d'écriture, après avoir affiché le dernier élément de la liste à l'écran, le curseur restera sur la même ligne. La routine writeln, une fois la sortie terminée, déplace le curseur vers la ligne suivante. Si aucun paramètre n’est passé à la procédure writeln, le curseur est simplement déplacé vers la ligne suivante.

Règles d'enregistrement des paramètres de la procédure de sortie

La liste de sortie est séparée par des virgules
La liste de sortie peut contenir des variables, des constantes et des expressions
Pour la sortie de n'importe quelle valeur, vous pouvez définir le format du champ de sortie - le nombre de positions dans lesquelles la valeur sera placée (indiqué immédiatement après la valeur de sortie, séparées par deux points) :
- si la valeur de la valeur affichée est plus courte, alors elle est « pressée » jusqu'au bord droit du champ alloué, sinon le champ est « agrandi » à la taille requise ;
- Pour les nombres réels, le format du champ de sortie permet de préciser le nombre de positions à afficher et celles allouées pour la partie fractionnaire du nombre (le point décimal occupe également une position).

Par exemple:

writeln("a = ", a:2, " ", 10 + sqrt(a):2:4, " ", pi:4:2);