Qu'est-ce qu'un opérateur d'entrée. Saisie et sortie de données en langage Pascal. Cycle. Types de cycles

L'interaction du programme avec l'environnement externe (utilisateur, autres programmes, données stockées) est absolument nécessaire. Pour une telle interface dans les langages de programmation responsable Instructions d'E/S information. Ces instructions vous permettent d'entrer des données dans le programme pendant 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 par l'homme.

Ces commandes vous permettent d'entrer 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 d'entrée 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, le curseur est affiché à l'écran, l'ordinateur attend de l'utilisateur un ensemble de données pour les variables dont les noms sont spécifiés dans la liste d'entrée. L'utilisateur du clavier saisit les signes nécessaires dans l'ordre dans lequel ils sont requis par la liste de saisie, appuie sur Entrée. Après cela, les données saisies entrent dans les variables qui leur correspondent et l'exécution du programme se poursuit. Les données d'entrée sont séparées par des espaces.

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

La différence entre le fonctionnement de l'opérateur Read et Readln en Pascal est la suivante : après l'exécution de Read, la valeur de la donnée suivante est lue sur la même ligne, et après l'exécution de Readln, sur une nouvelle ligne.

Ces instructions 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, des constantes. Avant d'afficher les valeurs des expressions, l'ordinateur les évalue d'abord. Les éléments de la liste, ainsi que dans les instructions d'entrée, sont séparés par des virgules.

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

En BASIC, chaque nouvelle instruction PRINT imprime des 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 tant qu'élément de la liste de sortie, en plus des noms de variables, des expressions et des chaînes peuvent être utilisées.

La sortie de chaque valeur dans une ligne de l'écran se produit conformément à 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, type de caractère et chaîne - comme symboles, type booléen - en tant que constantes logiques TRUE et FALSE.

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. Aucune opération ne peut être effectuée sur eux (attribuer une valeur, comparer, etc.). Ils ne peuvent être utilisés que pour effectuer des opérations sur les fichiers (lecture, écriture, etc.).

Avant d'effectuer des E/S, 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 défini soit comme une constante de chaîne, soit via une variable de type chaîne. Le nom du fichier doit respecter les règles du système d'exploitation en cours d'exécution. Si la chaîne de nom est vide, la variable de fichier est associée au périphérique d'E/S standard (généralement la console).

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

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

Un fichier existant est ouvert en lecture, le pointeur du composant de fichier courant est défini sur le 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 donné par la procédure Assign. Si un fichier portant le même nom existe déjà, il est détruit. Après avoir travaillé avec un fichier, il doit généralement être fermé avec la procédure de fermeture.

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

Cette exigence doit être respectée pour le fichier sur lequel l'enregistrement a été effectué.

Lorsque nous considérons un exemple d'opérateur d'affectation, nous sommes confrontés à la nécessité de connaître le résultat de l'exécution du programme. Nous avons compris comment stocker des informations (dans des variables), comment les traiter (à l'aide d'expressions), mais deux des processus d'information les plus fondamentaux ont été laissés de côté : recevoir des informations et les transmettre au monde extérieur à l'ordinateur. Jusqu'à présent, nos programmes ne peuvent utiliser que les informations qui se trouvent directement dans le texte du programme. Il n'a pas non plus été possible de savoir quelles valeurs ont actuellement les variables. La programmation dans de telles conditions n'a pas de sens.

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

Instructions d'entrée (formats d'instruction) :

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

Dans ce format, ces commandes vous permettent d'entrer des données dans des variables pendant l'exécution du programme à partir du clavier. Les éléments de la liste d'entrée 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, le curseur est affiché à l'écran, l'ordinateur attend de l'utilisateur un ensemble de données pour les variables dont les noms sont spécifiés dans la liste d'entrée. L'utilisateur du clavier entre les valeurs nécessaires dans l'ordre dans lequel elles sont requises par la liste de saisie, appuie sur Entrée. Après cela, les données saisies entrent dans les variables qui leur correspondent et l'exécution du programme se poursuit.

Remarque : les données d'entrée 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 de la donnée suivante est lue à partir de la même ligne, et après l'exécution de Readln, à partir d'une nouvelle ligne.

Pour afficher des informations en Pascal, il existe également deux commandes :

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

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, des constantes. Avant d'afficher les valeurs des expressions, l'ordinateur calcule d'abord. Les éléments de la liste, ainsi que dans les instructions d'entrée, sont séparés par des virgules. La différence entre les deux instructions de sortie est la suivante : après l'exécution de l'instruction Writeln (à partir de la ligne Write), une nouvelle ligne apparaît, 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 Les commandes de sortie Write ou Writeln se produiront sur la même ligne. Lorsque vous appelez l'instruction Writeln sans paramètres, elle passe simplement à une nouvelle ligne.

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

interface de programme ;

Write("Entrez le rayon du cercle"); (Impression à l'écran demandant une entrée)

readln(R); (Saisie d'une valeur dans

variable R du clavier)

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

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

Ce programme demande à l'utilisateur le rayon d'un cercle, offre la possibilité d'entrer sa valeur, calcule et affiche l'aire d'un cercle avec un tel rayon. Ainsi, il devient possible, sans apporter de modifications au texte du programme, de saisir différentes valeurs du rayon et d'obtenir les valeurs correspondantes de l'aire du cercle. Pour ce faire, il suffit d'exécuter 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, il serait possible de se limiter à Writeln(S), mais la signification du nombre sorti par le programme dans ce cas ne serait claire que pour celui qui a écrit ce programme.

Afin de visualiser la sortie 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 à l'endroit de l'erreur). Si aucune erreur n'a été trouvée, le résultat s'affichera et vous pourrez le visualiser en appuyant sur la combinaison de touches Alt + F5.

L'ensemble d'un programme Pascal est similaire à l'ensemble d'un fichier texte normal, seul l'environnement TurboPascal est utilisé pour cela. Vous pouvez l'exécuter 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 la base du cylindre)

H, (hauteur du cylindre)

V, (volume du cylindre)

S : Réel ; (surface côté cylindre)

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

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

V := Pi*R*R*H ;

S==2*Pi*R*H ; WriteLn ;

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

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

Mission de travail en laboratoire.

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

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

Si vous vous souvenez, lors de l'examen d'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 des informations (dans des variables), comment les traiter (à l'aide d'expressions), mais deux des processus d'information les plus fondamentaux ont été laissés de côté : recevoir des informations et les transmettre au monde extérieur à l'ordinateur. Jusqu'à présent, nos programmes ne peuvent utiliser que les informations qui se trouvent directement dans le texte du programme. Il n'a pas non plus été possible de savoir quelles valeurs ont actuellement les variables. La programmation dans de telles conditions n'a pas de sens.

Premières instructions d'entrée (formats d'instructions) :

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

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

L'exécution des instructions d'entrée se déroule comme suit : le programme est suspendu, le curseur est affiché à l'écran, l'ordinateur attend de l'utilisateur un ensemble de données pour les variables dont les noms sont spécifiés dans la liste d'entrée. L'utilisateur du clavier entre les valeurs nécessaires dans l'ordre dans lequel elles sont requises par la liste de saisie, appuie sur Entrée. Après cela, les données saisies entrent dans les variables qui leur correspondent et l'exécution du programme se poursuit.

Remarque : les données d'entrée sont séparées par des espaces.

Pour afficher des informations en Pascal, il existe également deux commandes :

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

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

La différence entre les deux instructions de sortie est la suivante : après l'exécution de l'instruction Writeln (à partir de la ligne Write), une nouvelle ligne apparaît, 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 Les commandes de sortie Write ou Writeln se produiront sur la même ligne. Lorsque vous appelez l'instruction Writeln sans paramètres, elle passe simplement à une nouvelle ligne.

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

interface de programme ;

Write("Entrez le rayon du cercle"); (Impression à l'écran demandant une entrée)

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

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

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

OPÉRATEURS D'ENTRÉE ET DE SORTIE

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

Ces fichiers sont divisés en lignes de longueur variable, séparées les unes des autres par un terminateur de ligne. La fin de la ligne est réglée en appuyant sur la touche ENTER.

Pour la saisie des données initiales, des opérateurs de procédures de saisie sont utilisés :

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

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

Le premier d'entre eux met en œuvre la lecture des valeurs K des données initiales 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 initiales, en sautant les valeurs restantes jusqu'au début de la ligne suivante, en attribuant les valeurs lues aux variables A1, A2, ..., AK. Le troisième opérateur implémente le saut de la ligne de données d'entrée.

Les instructions d'entrée, lors de la lecture des valeurs des variables de type entier et réel, ignorent les espaces précédant le nombre. Dans le même temps, ces opérateurs n'ignorent pas les espaces qui précèdent les valeurs des variables de caractère, car 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 initiales peuvent être séparées les unes des autres par des espaces et en appuyant sur les touches de tabulation et Entrée.

Pour afficher les résultats du programme à l'écran, les instructions suivantes sont utilisées :

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

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

Le premier de ces opérateurs implémente la sortie des valeurs des variables A1, A2,...,AK à la ligne d'é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 un saut de ligne et une transition au début de la ligne suivante.

La sortie de chaque valeur dans une ligne de l'écran se produit conformément à la largeur du champ de sortie, déterminée par l'implémentation particulière 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, type de caractère et chaîne - en tant que symboles, type booléen - en tant que constantes logiques TRUE et FALSE.

L'instruction 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 de type entier. Si la valeur de sortie occupe moins de positions dans le champ de sortie que K, des espaces sont placés avant cette valeur. Si la valeur affichée ne rentre pas dans la largeur du champ K, le nombre de positions requis sera attribué à cette valeur. Pour les valeurs de type réel, l'élément de liste de sortie peut être de 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 et 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 sorties sous forme de 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 ;

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

EcrireLn(rA, rB:10:2);

EcrireLn(iP, iQ:8);

EcrireLn(bR, bS:8);

EcrireLn(chT, chV, chU, chW);

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

Chaque maison de la rue a son propre numéro, toutes les personnes ont leurs propres noms, même les cellules de mémoire d'ordinateur ont chacune leur propre adresse. Tout cela est accepté afin de pouvoir indiquer sans ambiguïté l'objet en cours de définition. De même, les étiquettes sont utilisées pour faire référence à des instructions dans les programmes.

L'étiquette dans la norme du langage Pascal est un entier non négatif. Tous les libellés utilisés dans le programme doivent être répertoriés dans la section de description du libellé, qui commence par le mot-clé Libellé, par exemple :

Un seul opérateur peut être étiqueté avec une étiquette. L'étiquette est séparée de l'instruction étiquetée par deux-points.

6 : Écriture dans (14/2) ;

Dans tous les programmes ci-dessus, les instructions étaient exécutées les unes après les autres dans l'ordre dans lequel elles étaient écrites dans le texte. Une telle structure algorithmique est appelée suite directe. Cependant, dans le langage Pascal, il existe initialement un opérateur qui viole l'exécution directe du programme, transférant le contrôle à un point arbitraire de celui-ci. Une telle instruction s'appelle un branchement inconditionnel et a le format suivant :

aller à<метка>;

L'instruction vers laquelle la transition se produit doit être marquée avec cette étiquette.

Utilisez l'opérateur de branchement inconditionnel 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 parmi les programmeurs est considérée comme une mauvaise forme. Comme vous le verrez, il y a toujours la possibilité de s'en passer.

ÉLÉMENTS DE PROGRAMMATION STRUCTURELLE

Un programme structuré (ou sous-programme) est un programme composé d'un ensemble fixe de constructions de base. Considérons les principales définitions et manières de former ces constructions dans les schémas algorithmiques.

Opérations, bifurcations et fusions forment les structures de base : suivi, embranchement, cycle. En utilisant uniquement ces trois constructions, il est possible d'implémenter un algorithme pour résoudre n'importe quel problème.

La construction, qui est l'exécution séquentielle de deux opérations ou plus, est appelée comme suit.

Une construction composée d'un fork, de deux opérations et d'une fusion est appelée une branche. Une des opérations est peut-être manquante.

Une structure qui a des lignes de contrôle menant à des opérations ou à des fourches précédentes est appelée un cycle.

Les constructions de suivi, 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.

Une opération peut être mise en œuvre par n'importe quelle instruction PASCAL (simple ou composée) ou par un groupe d'instructions, à l'exception de l'instruction de transition GOTO.

Dans le langage PASCAL, le nombre de structures de base a été porté à six, ce sont :

Suivre;

ramification;

Boucle avec précondition ;

Boucle avec postcondition ;

Boucle avec paramètre ;

Opérateur conditionnel

L'une des principales structures algorithmiques est la branche (alternative).

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 schéma, une seule sera exécutée car la condition est fausse ou vraie. Il n'y a pas de tiers. Un tel schéma permet de résoudre des problèmes dans lesquels, selon les circonstances, l'une ou l'autre action est requise. Il ne fait aucun doute que le nombre de problèmes de ce genre est énorme. De plus, il est très difficile d'imaginer une tâche réellement significative, dont l'algorithme d'exécution contiendrait un simple suivi direct de commandes. Même un exemple primitif tiré d'un cours de mathématiques, comme vous le verrez, ne peut être résolu sans branchement. Il faut donc calculer la valeur de l'expression y=1/x. Vous savez que cette fonction 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'interprète ne reste en aucun cas bloqué, même en recevant zéro comme argument. Il n'est pas difficile de formuler ceci en langage naturel :

1. Obtenez la valeur x.

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

Ainsi, la structure algorithmique ci-dessus est utilisée. Elle peut être exprimée en mots simples :

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

ensuite<действие 1>(puis effectuez l'action #1)

Par ailleurs<действие 2>(sinon - effectuez l'action #2)

Comment l'écrire en Pascal ? Oui, exactement le même, seulement en anglais.

Format d'opérateur conditionnel en Pascal :

Si<условие>

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

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

Notez qu'il n'y a qu'une seule instruction dans les parties Then et Else. Mais que faut-il faire pour résoudre un problème dans lequel, lors de la réalisation ou de la non-satisfaction d'une condition, il est nécessaire d'effectuer non pas une, mais plusieurs actions ? C'est là que l'opérateur composé que vous connaissez déjà vient à la rescousse. Les parenthèses d'opérateurs peuvent contenir n'importe quel nombre d'opérateurs.

Variante de l'opérateur conditionnel dans ce cas :

Si<условие>

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

Sinon commencer< группа операторов 2>finir;

Le signe "point-virgule" n'est pas placé devant le mot de service Else, mais les opérateurs des groupes sont naturellement séparés les uns des autres par ce signe.

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 signes d'opérations 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 à gauche est supérieure ou égale à la valeur de l'expression à droite)

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

Donnons un exemple de résolution d'un autre problème : "De deux nombres, choisissez le plus grand."

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

Exemple de programme ;

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

Writeln("Entrez deux nombres");

ReadIn(A,B); (Entrez les arguments au 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)

écrireln(C); (Mettre le résultat à l'écran)

Autre exemple classique : "Résoudre une équation quadratique en utilisant les coefficients donnés." Cette tâche est plus difficile, donc, avant d'écrire un programme, on va composer un algorithme en l'écrivant sous forme d'organigramme, d'abord on rentre les coefficients, puis on calcule le discriminant. Maintenant deux possibilités se présentent : soit l'absence de racines réelles dans le cas d'un discriminant négatif, soit ces racines peuvent encore ê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 elles sont identiques J).

Lors de l'écriture d'un algorithme dans un langage de programmation, il convient de tenir compte du fait que dans la branche "non", il n'y a pas une action, mais trois, par conséquent, un opérateur composé doit être utilisé. N'oubliez pas d'écrire les expressions arithmétiques conformément aux 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;

Fait intéressant, 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'imbrication d'instructions conditionnelles. Lors de la résolution de tels problèmes, je vous recommande fortement de rédiger un organigramme de l'algorithme dans un cahier. Seulement alors, lors de la compilation d'un programme, il vous suffit d'écrire soigneusement toute la partie Then en premier, puis de passer à la partie Else. Habituellement, lors de l'écriture d'instructions conditionnelles en Pascal (en particulier avec plusieurs branches), les commandes sont écrites avec un rebord vers la droite et vers le bas. Cela augmente la visibilité et, croyez-moi, réduit le temps de débogage.

Pour illustrer, résolvons un autre problème : "résoudre une équation de la forme A*x^2 + B*x + C = 0". S'il vous plaît ne pas confondre avec l'équation quadratique, pour laquelle nous savions que le coefficient A n'est pas égal à zéro. Ici, les coefficients peuvent être n'importe quels nombres. A partir d'un raisonnement mathématique élémentaire, on obtient 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 un nombre quelconque")

Sinon Writeln("Pas de racines !")

Sinon Commencer 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;

EcrireDans("X1=", X1:8:3, "X2=",X2:8:3)

Cycle. Types de cycles.

Un cycle est une répétition répétée du même type d'action. Le corps du cycle sera appelé les actions mêmes 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 l'une après l'autre et à la fin, placez une instruction 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 une instruction conditionnelle en conjonction avec l'instruction de transition, rendant l'exécution de la transition dépendante de la réalisation d'une certaine condition. Ainsi, nous obtiendrons la structure de la transition conditionnelle et la possibilité d'organiser le cycle final. 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 peut-on économiser en utilisant toutes sortes d'outils spéciaux ?". Pour quelle raison? - Pour la commodité, la brièveté, la facilité de lecture du programme et, je n'ai pas peur de ce mot, la beauté. Ainsi, il existe trois types de boucles qui ont leurs propres opérateurs Pascal pour les écrire. Ces types ont leurs propres noms conditionnels : "While", "Before", "With parameter". 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'instructions, appelé "corps de la boucle", selon ce schéma, sera exécuté tant que la condition de la boucle est vraie. La boucle se termine lorsque la condition n'est plus vraie.

Si la condition est initialement fausse, alors le corps de la boucle ne sera jamais exécuté. Si la condition est initialement vraie et qu'aucune action dans le corps de la boucle n'affecte la véracité de cette condition, le corps de la boucle sera exécuté un nombre infini de fois. Cette situation est appelée "boucle". Un programme en boucle peut être interrompu soit par un opérateur (en appuyant sur Ctrl + C), soit par un arrêt d'urgence du programme lui-même, en cas de dépassement de variable, division par zéro, etc.

En Pascal, la structure de la boucle while s'écrit :

Tandis que<условие>Fais<оператор>;

Est-ce vraiment succinct ? En russe, cela peut se lire comme suit : "Tant que la condition est vraie, exécutez l'instruction." 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, une instruction composée peut être utilisée. Alors le format de l'opérateur prend la forme suivante :

Tandis que<условие>Fais

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

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

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

Cycle "À"

Ce type de boucle diffère du précédent principalement en ce que le test de la condition de répétition du corps de la boucle n'est pas avant, mais après. Par conséquent, la boucle "Avant" est appelée boucle "postcondition", et la boucle "Tant que" est appelée boucle "précondition".

Notez également qu'une nouvelle itération (ré-exécution du corps de la boucle) se produit non pas lorsque la condition est vraie, mais juste lorsqu'elle est fausse. Par conséquent, la boucle porte son nom (exécutez le corps de la boucle jusqu'à ce que la condition correspondante soit remplie).

Structure du programme

La structure du programme dans Turbo Pascal 7.0 contient des sections :

Considérez la structure du programme sur un exemple spécifique.

Créons un nouveau fichier dans la fenêtre de l'éditeur, le programme "Hello, World !", qui contient un message d'accueil pour l'utilisateur :

Exemple 1

programme Hello_World ;

varName:chaîne;

Write('Entrez votre nom :');

WriteLn('Bonjour, ', Nom, '!');

La première ligne du programme contient le nom - "Hello_World", le programme de déclaration de service indique le nom du programme, ce qui n'est pas une construction obligatoire. Ensuite, nous connectons des modules supplémentaires, cela est indiqué par le mot-clé uses. Dans la liste ci-dessus du programme, le module CRT est connecté, qui remplit la fonction de travailler avec l'écran en mode texte.

La liste utilise ensuite l'opérateur begin, qui pointe vers le début du corps du programme.

Les cinq lignes suivantes contiennent la signification de l'ensemble du programme qui effectue une séquence d'actions :

L'écran est effacé des informations précédentes (ClrScr;).
Ensuite, l'utilisateur est invité à entrer un nom (Ecrire ('Entrez votre nom :');).
L'utilisateur est censé entrer des informations dans la variable Nom (ReadLn (Nom);).
Un message d'accueil s'affiche sur le moniteur (WriteLn ('Hi,', Name,' !');).
Le programme attend que l'utilisateur appuie sur la touche Entrée pour terminer le programme (ReadLn;).

La dernière ligne du programme contient une instruction de fin avec un point à la fin, qui indique la fin du programme.

Vous pouvez également utiliser des commentaires dans la liste. Ils font référence à la partie non exécutable du programme qui ne se compile pas en code machine. Des commentaires sont faits par le programmeur pour expliquer le fonctionnement du programme, ses éléments, ses opérateurs, etc.

Un commentaire peut être fait de la manière suivante :

sous forme de texte arbitraire, délimité des deux côtés par des accolades - (), (parfois un commentaire peut contenir plusieurs lignes) ;
en texte libre suivi du double signe "//" (dans ce cas, le commentaire ne peut contenir qu'une seule ligne).

Voici quelques conseils pour les programmeurs débutants :

Avant de commencer à écrire un programme, définissez clairement quelles sont les données d'entrée et quel résultat vous souhaitez obtenir lors de l'exécution du programme.
Le type de variables doit être choisi en tenant compte de la portée et de la précision requise de la présentation des données.
Il est recommandé de donner des noms aux variables de sorte qu'ils reflètent leur objectif.
Lorsque vous utilisez la saisie au clavier dans un programme, insérez une ligne contenant une invite dans le code du programme et accompagnez les résultats de sortie d'une explication.
Avant d'exécuter le programme, il est recommandé de préparer des cas de test qui contiendront les données initiales et les résultats attendus. Vous pouvez vérifier la réaction du programme en saisissant des données initiales incorrectes.
Lorsque vous écrivez des expressions, faites attention à la priorité des opérateurs.

Opérateurs de langage

Définition 1

L'opérateur est l'unité structurelle la plus simple du programme, qui est conçue pour fixer les actions algorithmiques par lesquelles les données seront converties et pour déterminer l'ordre dans lequel ces actions sont effectuées.

Les opérateurs fonctionnent en mode d'exécution séquentielle automatique dans le programme et sont séparés les uns des autres par le symbole ";".

Les opérateurs sont :

simple, c'est-à-dire ne contenant pas d'autres opérateurs ;
composite, c'est-à-dire y compris les opérateurs supplémentaires.

Opérateur d'affectation (:=)

Il attribue une nouvelle valeur à une variable. Format:

La valeur affectée ou l'expression doit être compatible avec le type de la variable.

Exemple 2

$X :=Pi ; $
$Y :=Carré(Z*Z+T*T)$ ;
$Bool :=(I>1)ou(I

Opérateurs de saisie de données

Ces opérateurs sont utilisés par l'utilisateur pour entrer les données initiales dans le programme et ont la forme :

lire(x,y,z,...);

readln(x,y,z,...);

où : x,y,z,... - noms de variables.

Les instructions ci-dessus permettent à l'utilisateur d'entrer des valeurs à partir du clavier et de les affecter aux variables x,y,z,....

L'opérateur Readln (x,y,z,...) diffère de Read(x,y,z,...) en ce qu'après la saisie de la dernière variable, le curseur est déplacé au début d'une nouvelle ligne.

Remarque 1

Vous pouvez utiliser l'instruction input sans paramètre : Readln, qui est placée avant la dernière instruction end., pour arrêter le programme et montrer son résultat à l'utilisateur.

Déclarations de sortie

Vous pouvez utiliser les instructions suivantes pour afficher des données à l'écran :

Écrire(x,y,z,...);
Writeln(x,y,z,...);
Ecriture.

Où : x,y,z,... sont les noms des variables saisies au clavier.

À l'aide de l'instruction Write(x,y,z,...), les valeurs des variables x,y,z,... sont affichées à l'écran sur une seule ligne.

En utilisant l'instruction Writeln (x,y,z,...), en plus d'afficher les valeurs x,y,z,..., le curseur est déplacé au début d'une nouvelle ligne après l'affichage de la dernière valeur.

L'instruction Writeln saute la ligne contenant le curseur au début d'une nouvelle ligne.

Dans les instructions de sortie, vous pouvez spécifier la largeur du champ alloué pour écrire explicitement la valeur :

Écrire(y:m:n,x:k:l,...);
Ecrireln(y:m:n:,x:k:l,...).

m et k sont le nombre de positions réservées à l'écriture de la partie entière de la valeur des variables y et x ;

n et l sont le nombre de positions réservées à l'écriture de la partie fractionnaire des nombres y et x.

Par exemple:

Exemple 3

Ecrire("Somme = ",Somme); (affichant le texte "Sum = ", puis la valeur de la somme, qui est stockée dans la variable Sum) Writeln("Enter ",I,"th element: ").

Pour saisir des données dans le langage Turbo Pascal, des opérateurs standard (procédures) sont fournis - READ et READLN , qui sont conçus pour lire des données à la fois à partir du clavier et à partir d'un fichier. Cette section traite uniquement de la saisie au clavier. L'ajout de caractères LN à l'instruction READ garantit que le curseur passe automatiquement à une nouvelle ligne après la saisie des données.

Format de l'opérateur :

LIRE(a1,a2,a3,...,an);

Ici a1,a2,a3,...,an sont des variables auxquelles sont assignées séquentiellement des valeurs. Si l'instruction READ est rencontrée dans le texte du programme, l'ordinateur s'arrête et attend que les valeurs des variables soient saisies au clavier. Lorsque toutes les valeurs des variables répertoriées dans l'instruction d'entrée sont saisies, l'exécution du programme se poursuit.

READLN;

qui effectue un saut de ligne en entrée.

Lorsque vous saisissez des données à l'aide de l'instruction READ, gardez à l'esprit les règles de base suivantes :

les données logiques en Turbo Pascal ne sont pas autorisées à être saisies ;
lors de la saisie de données numériques, les chiffres sont séparés par un espace ou un caractère de fin de saisie (touche ENTER). La saisie est toujours terminée en appuyant sur la touche Entrée - ENTER ;
les espaces avant et entre les nombres sont ignorés, vous pouvez donc les mettre dans n'importe quel nombre ;
si la variable est déclarée en tant que Integer , sa valeur est saisie sous la forme d'un entier, c'est-à-dire le point après le nombre n'est pas autorisé ;
si la variable est déclarée réelle (Real) et que sa valeur est un nombre entier, vous pouvez saisir le nombre sous forme de nombre entier (c'est-à-dire sans point) et sous forme de nombre réel - avec un point. La conversion d'un entier en nombre réel se fera automatiquement ;
la saisie de données de caractères a des caractéristiques spéciales. Étant donné que l'espace est un caractère, comme tout autre caractère Turbo Pascal, les données de caractère doivent être saisies sous forme de ligne continue ;
une variable de caractère peut recevoir la valeur d'un seul caractère ;
appuyer sur la touche ENTER est traité comme un caractère, donc pour la saisie correcte des données de caractère, il est recommandé de mettre un nouvel opérateur de ligne READLN avant chaque opérateur pour saisir des données de caractère afin qu'elles soient saisies à partir d'une nouvelle ligne.

UNE TÂCHE. Entrée de données.

programme a4; Var a,b,c:entier ; (Variables de type entier) x,y,z:real; (Variables de type réel) s1,s2,s3:char; (Variables de type caractère) Begin Write('Enter a,b,c:'); lireln(a,b,c); (Entrée entière : le point n'est pas autorisé dans l'entrée, mais n'importe quel nombre d'espaces est autorisé. Appuyer sur Entrée après avoir entré la valeur de la variable c termine l'instruction READLN.) Write('Enter x,y,z:'); readln(x,y,z); (Entrée de nombres réels) Writeln('Enter s1,s2,s3:'); Readln(s1,s2,s3);(Entrez les valeurs des variables symboliques. L'entrée doit être une ligne pleine.) Fin.

Nous introduisons les données initiales suivantes dans le programme :

x=44,4, y=47,5, z=76

s1='A',s2='B',s3='C'

Indiquez le caractère espace lors de la saisie. Lors de la saisie d'un nombre, nous le séparerons par un espace. N'importe quel nombre d'espaces est autorisé entre les nombres. Ensuite, l'écran du moniteur lors de la saisie des données peut ressembler à ceci :

Tapez a, b, c:23 (entre chiffres)

Entrez x, y, z:44.447.576 (n'importe quel nombre d'espaces autorisés)

Entrez s1,s2,s3:A B C

Sortie de données

L'instruction Write est utilisée pour sortir des données de la mémoire de l'ordinateur vers l'écran du moniteur.

Format de l'opérateur :

Écrire(a1,a2,a3,...,un);

Ici a1,a2,a3,...,an peuvent être soit des variables, soit une chaîne de caractères entourée d'apostrophes. Tous les éléments sont listés séparés par des virgules. L'ajout de caractères LN à l'instruction WRITE garantit que le curseur saute automatiquement après la sortie des données sur une nouvelle ligne.

Il est permis d'utiliser l'instruction d'entrée sans paramètres

ÉCRIT ;

qui effectue une nouvelle ligne, de sorte que l'instruction de sortie suivante avec des paramètres produira des données à partir d'une nouvelle ligne. L'instruction de sortie sans paramètre est souvent utilisée pour générer des chaînes vides.

Les paramètres de l'instruction WRITE peuvent être des données entières, réelles, booléennes, de caractère ou de chaîne.

L'emplacement des données sur l'écran du moniteur peut être spécifié par les paramètres de l'instruction WRITE, auquel cas la sortie est appelée sortie avec formats de données. Si aucun format n'est utilisé dans l'instruction WRITE, la sortie est appelée sortie non formatée ou sortie standard.

Sortie non formatée . La forme sous laquelle les données de sortie sont présentées dépend du type de données :

Les valeurs booléennes sont sorties sous forme de booléens TRUE et FALSE ;
les valeurs des variables symboliques sont sorties sous forme de symboles correspondants ;
la constante de caractère est sortie telle qu'elle est écrite, mais sans apostrophes ;
les valeurs entières sont sorties sous forme d'entiers ;
les valeurs des valeurs de type réel sont affichées au format virgule flottante.

Avec une sortie sans format, le nombre de positions allouées est égal à la taille des données. Lors de l'affichage d'un symbole, une position est attribuée, lors de la sortie d'un nombre entier, le nombre de positions est égal au nombre de chiffres significatifs plus une position sous le signe, si le nombre est négatif. Ceci doit être pris en compte lors de la sortie séquentielle de données, telles que des nombres, afin que les valeurs de différentes variables ne se confondent pas.

EXEMPLE. Prenons un fragment de programme:

var m,n:entier; début :=1234 ; m==7890; écrire(n,m); finir.

L'écriture(n,m); les nombres entiers sont affichés sur l'écran du moniteur : n=1234 et m=7890 . Étant donné que la sortie sans formats de données est utilisée, le résultat ressemblera à :

Les deux nombres sont fusionnés. Pour que les nombres ne fusionnent pas, il est nécessaire d'utiliser des espaces de séparation ou des informations d'espacement sur différentes lignes.

écrire(n,' ',m); (espace entre les nombres)

Résultat:

1234 7890

Résultat:

1234

formater la sortie . Pour générer des nombres réels, vous devez spécifier dans l'instruction WRITE le format de représentation des nombres, qui ressemble à :

ÉCRIVEZ(<переменная>:m:n);

où : m est un nombre entier indiquant le nombre total de positions attribuées à la valeur de la variable, y compris la position sous le signe du nombre, le point et le nombre de chiffres de la partie décimale ; n est un entier spécifiant le nombre de chiffres de la partie décimale.

Les informations de sortie sont alignées à gauche. Cela supprime l'impression des zéros non significatifs, c'est-à-dire si quatre positions ont été attribuées pour afficher un nombre, alors, par exemple, 6 sera affiché sur l'écran du moniteur, et non 0006 .

Exemple. Sortons la valeur de la variable A égale à 401,3 en utilisant l'opérateur write(A:8:2). Ce qui suit s'affichera sur l'écran du moniteur :

401,30

8 postes

Le symbole représente un espace.

La dérivation des nombres réels s'effectue selon les règles suivantes :

Si le nombre est plus court que m , il sera complété à gauche avec des espaces.
Si le nombre est plus long que m , alors le paramètre m est ignoré et le nombre sera affiché en entier.
Si la partie fractionnaire est supérieure au paramètre n, le nombre est arrondi. L'arrondi ne change pas la valeur de la variable elle-même, seule la représentation du nombre sur le moniteur change.
Si le paramètre n n'est pas spécifié, ni la partie fractionnaire du nombre ni le point décimal ne sont affichés. La sortie est au format virgule flottante.

Par exemple, envisagez d'imprimer un nombre réel dans différents formats.

écriture de programme ; varx : réel ; début x :=-12345.12345 ; writeln("Imprimer un nombre réel":50); writeln("Impression fixe"); écrireln(x:3:0); écrireln(x:3:1); écrireln(x:12:5); écrireln(x:20:5); écrire; writeln("Imprimer au format flottant"); écrireln(x); écrireln(x:3); écrireln(x:5); écrireln(x:15); écrireln(x:16); finir.

Le résultat du programme :

Impression d'un nombre réel

Impression au format fixe

Impression en format flottant

1.2345123450E+04

1.234512345E+04

Pour générer des nombres entiers, vous devez spécifier le format de représentation des nombres dans l'instruction WRITE, qui ressemble à ceci :

ÉCRIVEZ(<переменная>:k);

où:

k est un entier indiquant le nombre total de positions allouées pour la valeur de la variable.

Les nombres entiers n'ont pas de partie fractionnaire, il n'est donc pas nécessaire de spécifier le nombre de positions fractionnaires dans le format.