Les instructions structurées sont des instructions qui incluent d'autres instructions et contrôlent la séquence de leur exécution. Ceux-ci inclus:
- opérateur composé;
- instruction If conditionnelle;
- instruction conditionnelle Case;
- opérateur de boucle Répéter;
- instruction de boucle While;
- opérateur pour boucle.
Opérateur composé
Il est souvent nécessaire que par rapport à une action, plusieurs énoncés soient perçus dans le programme comme une seule déclaration. Un tel opérateur peut être obtenu si la séquence requise d'opérateurs est combinée avec des parenthèses d'opérateurs. Les mots de service Begin et End sont appelés parenthèses d'opérateur.
Format opérateur:
opérateur # 1;
opérateur # 2;
opérateur # 3;
opérateur # n-1;
opérateur # n; Fin;
Le mot Begin joue le rôle de la parenthèse ouvrante, le mot End joue le rôle de la parenthèse fermante.
Une instruction composée est traitée comme une instruction unique. Il peut être inséré n'importe où dans le programme où une seule instruction est autorisée.
Les opérateurs inclus dans un opérateur composé, comme tous les opérateurs, sont séparés par un point-virgule, mais ce séparateur peut être omis avant la fin. Après la fin, un point-virgule est nécessaire comme séparateur entre l'instruction composée et l'instruction suivante.
Dans les sections suivantes, la signification et le but de l'opérateur composé seront illustrés par de nombreux exemples.
Instruction IF conditionnelle
L'opérateur If implémente la construction algorithmique "Décision" et vous permet de changer l'ordre d'exécution des opérateurs en fonction de la vérité ou du mensonge d'une certaine condition. Le format opérateur peut être rédigé sous deux formes: complet et incomplet.
Format opérateur dans son intégralité:
Si<условие> ensuite<оператор 1> Autre<оператор 2>
Format d'opérateur incomplet:
Si<условие>ensuite<оператор 1>
Si (si), Then (alors), Else (sinon) sont des mots réservés.
Les organigrammes de l'instruction if sont présentés ci-dessous:
L'opérateur conditionnel fonctionne comme suit. L'expression conditionnelle est évaluée en premier< условие >... Si le résultat est vrai, alors< оператор 1 > (après le mot Then), et< оператор 2 > ignoré. Si le résultat est faux, alors< оператор 1 > ignoré mais exécuté< оператор 2 > (après le mot Else). Else n'est jamais précédé d'un point-virgule, car ce n'est pas la fin de l'instruction If.
Autre partie<оператор 2> opérateur conditionnel Si peut être omis. Si un< условие > Si l'opérateur évalue à True, alors<оператор 1> sinon cet opérateur est ignoré. Dans ce cas, le format de l'instruction conditionnelle est incomplet:
Comparons deux constructions:
Si<условие>ensuite<оператор 1>;
Si<условие>ensuite<оператор 1>; <оператор 2>;
Dans la première ligne<оператор 1> soit exécuté ou non exécuté selon l'exécution<условия> ... Dans la deuxième ligne<оператор 2> est toujours exécuté, car après<оператора 1> il y a un séparateur ";" et tout ce qui se trouve dans le champ délimiteur est considéré comme un autre opérateur. Par conséquent, selon le format de l'instruction If, il ne peut y avoir qu'une seule instruction après les mots réservés Then et Else.
Exemple:
Si a\u003e 0 Alors b: \u003d 1;
Si a\u003e 0 Alors b: \u003d 1; a: \u003d b; (opérateur a: \u003d b; est toujours exécuté)
S'il est nécessaire d'exécuter après Then et Else non pas un, mais plusieurs opérateurs, vous devez mettre des crochets d'opérateur, c'est-à-dire utiliser un opérateur composé.
Dans ce cas, l'instruction If ressemblera à ceci:
Si<условие>ensuite
opérateur 11;
opérateur 1n;
opérateur 21;
opérateur 2n;
Exemple.
Si a\u003e 0 Alors commencez b: \u003d 1; a: \u003d b; fin;
TACHE 1. Calculer la valeur de la fonction donnée par les inégalités
y \u003d x + 1 pour x<0; y=2∙x при x>0.programme a5; var x, y: réel; commencer l’écriture (‘Entrez la valeur x:’); readln (x); if x writeln (‘La valeur de y est:’, y: 6: 2) end.
Les résultats du programme:
Entrez les valeurs x: 0,5
La valeur de y est: 1,00
TÂCHE 2. Écrivez un programme pour résoudre une équation quadratique. Si le discriminant est inférieur à zéro, affichez le message approprié.
Programme a6; var a, b, c: réel; (coefficients d'équation) x1, x2: réel; (racines de l'équation) d: réel; (discriminant) begin Writeln («Solving a quadratic equation»: 50); Ecrire (‘Entrez les valeurs des coefficients a, b, c:’); Readln (a, b, c); (entrée des coefficients) d: \u003d b * b-4 * a * c; si (d<0) then Writeln(‘Уравнение не имеет корней.’) else begin {операторные скобки} x1:=(-b+sqrt(d))/(2*a); x2:=(-b-sqrt(d))/(2*a); WriteLn(‘Корни уравнения: ’, x1:8:2,x2:8:2); end; end.
Les résultats du programme:
Résolution d'une équation quadratique
Entrez les valeurs des coefficients a, b, c: 3 1 6
L'équation n'a pas de racines.
Dans l'instruction If, vous pouvez utiliser non seulement une instruction composée, mais également n'importe quelle instruction structurée. L'instruction conditionnelle If que nous avons considérée peut également être utilisée comme un tel opérateur. Dans ce cas, on parle d'instructions If imbriquées.
Exemple.
| si condition alors | |||||
| commencer | Supports opérateur | ||||
| opérateur; | imbriqué Instruction IF, formulaire incomplet |
||||
| si condition alors opérateur | |||||
| opérateur else; | |||||
| fin | |||||
| autre | |||||
| commencer | Supports opérateur | ||||
| opérateur; | imbriqué instruction IF, formulaire incomplet |
||||
| si condition | |||||
| puis déclaration; | |||||
| fin; | |||||
Lorsque vous travaillez avec des opérateurs imbriqués si les règles suivantes doivent être respectées:
- avant le mot réservé, sinon le symbole ";" jamais mis;
- le mot réservé else est toujours associé au mot réservé alors précédent.
TÂCHE 3. Améliorons le programme de résolution de l'équation quadratique (PROBLÈME 2). Lorsque la valeur du coefficient a \u003d 0, l'équation dégénère. Ce fait n'a pas été pris en compte dans le programme, ce qui provoquerait une erreur fatale lors de l'exécution du programme (division par zéro). Afin d'exclure la division par zéro, nous vérifierons la valeur du coefficient a après sa saisie par l'opérateur Readln (a, b, c).
Puisque la variable a est déclarée dans le programme comme une variable de type réel, sa valeur numérique dans la machine n'est pas représentée exactement, avec une certaine erreur. Par conséquent, une entrée comme
Il existe plusieurs options pour comparer correctement les valeurs d'une variable réelle à zéro:
TÂCHE 4. Solveur d'équations quadratiques avancé.
Programme a7; Var a, b, c: réel; (coefficients d'équation) x1, x2: réel; (racines de l'équation) d: réel; (discriminant) begin Writeln («Solving a quadratic equation»: 50); Ecrire (‘Entrez les valeurs des coefficients a, b, c:’); Readln (a, b, c); (saisir les cotes) si tour (a)<>0 puis commencer d: \u003d b * b-4 * a * c; si d<0 then Writeln(‘Уравнение не имеет корней.’) else begin{операторные скобки} x1:=(-b+sqrt(d))/(2*a); x2:=(-b-sqrt(d))/(2*a); WriteLN(‘Корни уравнения: ’, x1:8:2,x2:8:2); end; end else Writeln(‘Деление на нуль.’); end.
Les résultats du programme:
Résolution d'une équation quadratique Entrez les valeurs des coefficients a, b, c: 0 1 6 Division par zéro.
Instruction de sélection conditionnelle Case
L'opérateur de sélection est une généralisation de l'opérateur If et est utilisé dans les cas où un seul opérateur d'un ensemble d'opérateurs doit être exécuté, en fonction de la valeur de la touche de sélection.
Une expression est utilisée comme touche de sélection, située entre la casse et des mots réservés. Les expressions peuvent être de types entier, booléen et caractère. L'expression ne peut pas être de type Real, String.
Format opérateur:
Cas de "<ключ выбора>"constante1: opérateur 1; constante2: opérateur 2; constante3: opérateur 3; ... constanteN-1: opérateur N-1; constanteN: opérateur Nn; Sinon opérateur Fin;
Ici Case (au cas où), of (from), Else (autrement), End (end) sont des mots réservés.
La touche de sélection est une expression de tout type autre que Real et String.
Constant1 est une constante du même type que l'expression.
Operator1 est un opérateur arbitraire.
L'opérateur de sélection fonctionne comme suit. L'expression est évaluée en premier<ключ выбора> , puis dans la séquence d'opérateurs on en trouve un précédé d'une constante égale à la valeur calculée<ключ выбора> ... L'opérateur trouvé est exécuté, après quoi l'opérateur de sélection termine son travail (le contrôle est transféré à la fin). Si aucune constante n'est trouvée dans la liste des constantes correspondant à la valeur calculée de la touche de sélection, le contrôle est transféré à l'opérateur derrière le mot Else.
Autre partie<оператора> peut être omis, alors si la constante requise est absente de la liste des constantes, rien ne se passe et l'opérateur de sélection termine simplement son travail.
TÂCHE 5. Ecrire un programme de calcul simple.
Programme a8; var x, y: réel; z: réel; (résultat) op: char; (touche de sélection) begin Write (‘Entrez les opérandes x, y:’); Readln (x, y); Ecrire (‘Enter operation (+, -, *, /):’); Readln (op); cas op de '+': z: \u003d x + y; «-»: z: \u003d x-y; '*': Z: \u003d x * y; «/»: Si y0 alors z: \u003d x / y Elsewriteln («Division par zéro»); Else writeln («Aucune action fournie!»); fin; (op) (pour que vous puissiez marquer la fin de "dont") writeln (‘Result is \u003d’, z: 8: 2); fin.
Les résultats du programme:
Entrez les opérandes x, y: 4 2
Entrer l'opération (+, -, *, /): *
Le résultat est \u003d 8,00
Dans le programme, la touche de sélection est une variable de caractère. En fonction de la valeur saisie des symboles (+, -, *, /), une des opérations arithmétiques est effectuée: addition, soustraction, multiplication ou division. Si zéro est entré comme diviseur, alors la division est impossible et le message "Division par zéro" s'affiche. Si un autre caractère est entré, le résultat sera le message "Aucune action fournie!" Si des opérations valides sont entrées, le résultat est renvoyé.
TÂCHE 6. Écrivez un programme qui demande à l'utilisateur le numéro du jour de la semaine, puis affiche le nom du jour de la semaine ou un message d'erreur si des données incorrectes sont saisies.
Programme a9; Var n: entier; (numéro du jour de la semaine) Commencez l’écriture (‘Entrez le numéro de la semaine:’); readln (n); cas n de 1: writeln («lundi»); 2: writeln («mardi»); 3: writeln («mercredi»); 4: writeln («jeudi»); 5: writeln («vendredi»); 6: writeln («samedi»); 7: writeln («dimanche»); sinon écrivez («vous vous trompez!») end; (n) fin.
Les résultats du programme:
Entrez le jour de la semaine: 1
Lundi
Aucune constante ne doit être la même qu'une autre. Si pour plusieurs constantes il est nécessaire d'exécuter le même opérateur, elles peuvent être répertoriées séparées par des virgules, par exemple
cas n de 1,3,5,7,9: writeln («Ce sont des nombres impairs»); 2,4,6,8,10: writeln («Ce sont des nombres pairs»); fin;
Opérateur est une phrase d'un langage de programmation qui spécifie une description complète d'une action à effectuer. La partie principale d'un programme Turbo Pascal est une séquence d'instructions. Les opérateurs sont séparés par des points-virgules. Tous les opérateurs Turbo Pascal peuvent être divisés en deux groupes: simple et structurel.
Les opérateurs qui ne contiennent aucun autre opérateur sont appelés facile... Il s'agit notamment de l'affectation, du saut, de l'appel de procédure et opérateur vide.
Opérateur d'assignation
Opérateur d'assignation (:=) demande d'exécuter l'expression spécifiée sur son côté droit et d'affecter le résultat à la variable dont l'identifiant est situé sur le côté gauche. La variable et l'expression doivent être compatibles avec le type.
L'opérateur d'affectation est exécuté comme suit: tout d'abord, l'expression du côté droit de l'affectation est évaluée, puis sa valeur est affectée à la variable spécifiée sur le côté gauche de l'opérateur.
Par exemple, pour l'opérateur
Rezult: \u003d A div B;
tout d'abord, la division entière de la valeur de la variable est effectuée ET par la valeur de la variable DANSpuis le résultat est affecté à une variable Rezult.
Exemples d'utilisation de l'opérateur d'affectation:
ET:= 8;
S: \u003d A *DANS;
Ostatok: \u003d A mod B;
Rapport: \u003d A / B;
Opérateur de saut inconditionnel (aller à)
Opérateur de saut inconditionnel (aller à) signifie "aller à" et est utilisé dans les cas où, après avoir exécuté un certain opérateur, il est nécessaire d'exécuter non pas le suivant dans l'ordre, mais un autre opérateur marqué d'une étiquette.
Rappelez-vous qu'une balise est déclarée dans la section de description de balise et peut contenir à la fois des caractères numériques et alphabétiques.
Lors de l'utilisation de l'opérateur aller àil faut se rappeler que la portée du label n'est que le bloc dans lequel il est décrit. Le transfert de contrôle vers un autre bloc est interdit.
Règles d'utilisation de l'opérateur de saut inconditionnel. L'utilisation de transferts de contrôle inconditionnels dans un programme est considérée comme théoriquement redondante et est sujette à de sérieuses critiques, car elle contribue à la création de programmes obscurs et difficiles à modifier qui causent de grandes difficultés de débogage et de maintenance. Par conséquent, une utilisation minimale de l'opérateur est recommandée aller à conformément aux règles suivantes:
Vous devriez vous efforcer d'utiliser des opérateurs de saut (s'il semble impossible de vous en passer) pour transférer le contrôle uniquement vers le bas (vers l'avant) dans le texte du programme; lorsqu'il est nécessaire de renvoyer le contrôle, utilisez des instructions de boucle;
La distance entre l'étiquette et l'opérateur pour y accéder ne doit pas dépasser une page de texte (ou la hauteur de l'écran d'affichage).
Un exemple d'utilisation de l'opérateur de saut inconditionnel:
label Metka; (dans la section de description de balise, une balise a été décrite avec le nomMetka}
commencer (programme principal)
(opérateurs du programme principal)
(instructions du programme principal marquées d'une étiquette)
Demande de service
Pour étudier les informations théoriques sur le sujet: "Ecrire un programme en Pascal à l'aide d'opérateurs d'affectation et de saut inconditionnel."
Recevoir un devoir individuel d'un enseignant et développer un programme en fonction de la tâche.
Montrez le programme en cours à l'enseignant.
Répondre à des questions de sécurité.
questions de test
Éléments de programmation de base.
Les principales caractéristiques du programme. Les concepts de langage, de superpositions, de blocs globaux et locaux.
Opérateurs du langage de programmation Pascal. Opérateur d'assignation. Format, exemples.
Opérateur de saut inconditionnel. Format, exemples. Règles d'utilisation de base
Travaux de laboratoire n ° 7
Ecrire un programme Pascal à l'aide d'opérateurs conditionnels et SelectCas
Objectif : formation de connaissances et de compétences pour travailler avec des opérateurs linguistiques. Acquérir les compétences de rédaction de programmes à l'aide d'opérateurs d'affectation et de saut inconditionnel.
Brèves informations théoriques
Opérateurs conditionnels
Les opérateurs conditionnels sont conçus pour sélectionner pour exécution l'une des actions possibles (opérateurs) en fonction d'une certaine condition (dans ce cas, l'une des actions peut être vide, c'est-à-dire absente). La valeur expression logique.
Turbo Pascal a deux opérateurs conditionnels: si et cas.
Si déclaration de condition
Opérateur de condition si est l'un des outils les plus populaires qui modifient l'ordre naturel d'exécution des instructions de programme.
Il peut prendre l'une des formes suivantes:
si<условие> puis<оператор1>
autre<оператор2>;
si<условие> puis<оператор>;
Traduits de l'anglais, ces formats peuvent être définis comme:
SI UN <условие> À <оператор1> AUTRE <оператор2>
SI UN <условие> À <оператор>
Opérateur de condition si est effectuée comme suit. Tout d'abord, l'expression écrite dans la condition est évaluée. À la suite de son calcul, une valeur booléenne est obtenue.
Dans le premier cas, si la valeur de l'expression est Vrai (vrai), exécuté <оператор1>, spécifié après le mot puis(traduit par «ça»). Si le résultat de l'évaluation de l'expression dans la condition est Faux (false) puis il est exécuté <оператор2> .
Dans le second cas, si le résultat de l'expression Vrai, effectué <оператор>, si un Faux - l'opérateur qui suit immédiatement l'opérateur si... Les opérateurs si peut être imbriqué.
Un exemple de fragment de programme avec une instruction de condition if:
si Ch \u003d "N" alors Parol: \u003d True
else Parol: \u003d Faux;
si Parol \u003d True alors
si X \u003d 100 alors Ecrire ("Le mot de passe et le code sont corrects")
Writeln ("Erreur dans le code");
Dans cet exemple, la valeur d'une variable de type caractère est lue à partir du clavier Ch... Ensuite, la condition est vérifiée DEh=" N" ... Si elle est exécutée, alors la variable Parolle type booléen reçoit une valeur Vraisi la condition n'est pas remplie, Faux... Ensuite, la valeur du code est lue à partir du clavier X... Ensuite, l'instruction if vérifie la condition Parol \u003d True. Si ça compte Vrai, puis le mot de passe saisi est vérifié par l'opérateur si X \u003d 100... Si la condition X \u003d 100 a le sens Vrai, puis le message "Le mot de passe et le code sont corrects" s'affiche et le contrôle dans le programme est transféré à l'opérateur après le mot finsi ça compte Faux, l'instruction composée après l'exécution du mot autre, qui affiche le message "Erreur dans le code" sur le moniteur vidéo et appelle la procédure standard Halte (1) pour arrêter le programme.
Caractéristique de l'opérateursi. Une ambiguïté syntaxique peut survenir lors de l'utilisation de conditions imbriquées, par exemple:
si condition1 alors si condition2 alors<оператор1> autre<оператор2>
L'ambiguïté qui en résulte quant à quel opérateur si une partie appartient autre <оператор2>, permis par le fait que le mot de service autre toujours associé (lié) au mot de service le plus proche dans le texte si, qui n'est pas encore associé à un mot de service autre.
Par conséquent, vous devez être prudent lorsque vous écrivez des instructions conditionnelles imbriquées.
Exemple 1 . Écrivez un programme qui calcule le quotient de deux entiers. En raison du fait qu'il est impossible de diviser par zéro, le contrôle de la saisie des données doit être organisé.
Pour contrôler les valeurs de diviseur saisies, nous utilisons l'opérateur de saut conditionnel si ... alors ... autre.
Le texte du programme pourrait ressembler à ceci:
programme Primer1;
A, B: entier;
Ecrire ("Entrez la valeur du dividende A:");
Write ("Entrez la valeur du diviseur B:");
si B \u003d 0 (Contrôle d'entrée numériqueB}
puis Writeln ("Vous ne pouvez pas diviser zéro") (Condition remplie)
(Condition non remplie)
Rezult: \u003d A / B;
Writeln ("Numéros privés", A, "et", B, "\u003d", Rezult);
L'instruction jump vous permet de passer de l'emplacement actuel du programme à un autre emplacement qui n'est pas le suivant dans l'ordre. Cette instruction perturbe le déroulement normal du programme.
La transition est effectuée à l'aide de ce que l'on appelle des étiquettes.
Une étiquette est un identificateur ou un entier non signé compris entre 0 et 9999 qui précède toute instruction de programme et en est séparé par un signe deux-points. Toutes les étiquettes utilisées dans le programme doivent être préalablement déclarées dans la section de déclaration d'étiquette, en commençant par l'étiquette WORD.
Il peut théoriquement montrer que les opérateurs considérés sont tout à fait suffisants pour écrire des programmes de toute complexité. A cet égard, la présence d'opérateurs de saut dans le langage semble superflue. De plus, la technologie de programmation structurée moderne est basée sur le principe de «programmation sans GOTO»: on pense que l'abus des instructions de saut rend le programme difficile à comprendre, le rend déroutant et difficile à déboguer. Cependant, dans certains cas, l'utilisation d'opérateurs de branche peut simplifier votre programme.
L'opérateur de transition a la forme:
Ici goto est un mot réservé (go [to the label]); - étiquette.
Étiquette 1; // Déclarer une étiquette nommée 1 var
a: Entier; commencer
a: \u003d 10;
Goto 1; // Aller à l'étiquette 1
a: \u003d sqrt (a); // Cette instruction ne sera jamais exécutée! 1: a: \u003d a + a; // Opérateur marqué avec 1 extrémité;
Opérateurs de saut conditionnel
L'opérateur de condition est destiné à effectuer ou non des actions en fonction du résultat de la condition de type booléen. Cet opérateur permet de dériver l'exécution du programme,
autrement dit, si cette condition est vraie (et seulement dans ce cas!), alors une certaine séquence d'opérateurs est exécutée, sinon d'autres opérateurs sont exécutés. L'opérateur de condition est le suivant:
si état puis instruction1 autre instruction2;
L'opérateur de condition peut également être écrit sous une forme simplifiée:
si état puis opérateur;
Voici des exemples d'utilisation des opérateurs de condition:
si a\u003e 0 alors b: \u003d sqrt (a) sinon b: \u003d a * 2; // Opérateur de condition
si a \u003d 10 alors b: \u003d b + 1; // Forme simplifiée
Afin d'organiser le branchement dans plusieurs directions (plus de deux), vous pouvez utiliser plusieurs instructions conditionnelles, imbriquées les unes dans les autres. L'imbrication d'instructions conditionnelles suit les mêmes règles que l'imbrication d'instructions composées.
Contrairement aux autres langages de programmation d'Object Pascal, la priorité des opérations sur les relations est inférieure à celle des opérations logiques. Par conséquent, les composants individuels d'une expression logique complexe sont entre parenthèses. Par exemple, un tel enregistrement de la déclaration précédente sera incorrect:
si a\u003e b et b 0 alors ... // Erreur car en fait (en tenant compte de la priorité de l'opération) le compilateur traduira la ligne suivante:
si a\u003e (b et b) 0 alors ...
Opérateur de saut
Cette fois, je continuerai mon examen du sujet "Opérateurs".
Les instructions Jump (inconditionnelles) sont conçues pour transférer le contrôle à un opérateur marqué d'une étiquette (précédée d'une étiquette).
La version de l'auteur du langage suppose la conception de l'étiquette sous la forme d'un nombre décimal entier dans la plage 1..9999 ... Comme étiquettes Turbo pascal permet l'utilisation d'identifiants. Lorsque vous utilisez des opérateurs de saut, les règles suivantes doivent être suivies:
1) Toutes les étiquettes du bloc doivent être décrites. De plus, chaque étiquette ne peut être décrite plus d'une fois. Ceux. il ne peut y avoir deux étiquettes avec le même nom dans un bloc.
2) Le libellé spécifié dans l'opérateur de transition doit pointer vers l'opérateur (le marquer), qui se trouve dans le même bloc que l'opérateur de transition lui-même. Ceux. les transitions en dehors des procédures (fonctions) ou à l'intérieur de celles-ci ne sont pas autorisées.
3) Une tentative de saut (transfert de contrôle) dans un opérateur structuré peut provoquer des effets imprévisibles, bien que dans ce cas, le compilateur puisse ne pas émettre de message d'erreur.
L'utilisation d'un saut inconditionnel dans un programme est considérée comme théoriquement redondante, car elle peut créer une confusion dans la chaîne d'opérations de programme logiquement placées, ce qui peut conduire à de grandes difficultés de débogage et de modification d'un tel programme. Il est recommandé d'utiliser des opérateurs de saut, en respectant les règles suivantes:
1) s'il semble impossible de se passer d'opérateurs de saut, vous devez vous efforcer de les utiliser pour transférer le contrôle uniquement vers le bas du texte du programme (vers l'avant); lorsqu'il devient nécessaire de transférer le contrôle «en arrière», il est préférable d'utiliser des opérateurs de boucle (voir ci-dessous);
2) pour plus de clarté, la distance entre l'étiquette et l'opérateur de transition vers celle-ci ne doit pas dépasser une page de texte (ou la hauteur de l'écran d'affichage), sinon la signification d'une telle transition inconditionnelle sera difficile à saisir.
Les étiquettes sont définies par des descriptions commençant par un mot de service étiquetteet contiennent une séquence de noms d'étiquettes séparés par des virgules. Pour transférer le contrôle à l'opérateur marqué d'une étiquette, un opérateur de saut inconditionnel est fourni aller à... Une étiquette est séparée de l'instruction suivante par le caractère «:» (deux-points). Exemple:
var j: entier;
(nous déclarons deux étiquettes)
étiquetteDébut Fin;
Démarrer: writeln («Démarrer le programme»);
aller à Terminer;
Terminer: writeln ('Fin du programme');
Opérateur composé
L'opérateur structuré le plus simple est l'opérateur composé. Cet opérateur définit la séquence d'exécution des opérateurs qu'il contient. Un opérateur composé est formaté comme une liste d'opérateurs séparés les uns des autres par le symbole «;» (point-virgule) et entre les mots de service commenceret fin.
Le besoin d'une instruction composée peut survenir dans les cas où la syntaxe langage Pascal permet l'utilisation d'un seul opérateur à la place du programme où un certain nombre d'actions sont nécessaires (opérateurs, voir exemples ci-dessous). Voici un exemple simple d'opérateur composé:
Opérateur conditionnel
La signification d'un opérateur conditionnel est d'analyser une condition logique et, selon que cette condition est remplie ou non, de transférer le contrôle à l'opérateur correspondant. Une expression qui renvoie une valeur booléenne de type booléen peut être utilisée comme condition. Le résultat de l'analyse de la condition peut être la valeur vrai, c'est à dire. la condition est remplie et faux, c'est à dire. la condition n'est pas remplie.
L'instruction conditionnelle est exécutée comme suit. L'expression spécifiée après le mot de service est précalculée SI... Si la condition est remplie, le contrôle est transféré à l'opérateur spécifié après le mot de service puissinon, alors l'opérateur spécifié après le mot de service else est exécuté. Dans ce cas, une partie de l'opérateur conditionnel, commençant par le mot else, peut être manquante. Voici des exemples d'instructions conditionnelles:
Si Touché puis writeln («Touche enfoncée»);
Si A\u003e B puis Min: \u003d B
autre Min: \u003d A;
si X1\u003e X2 alors commencez
Le dernier exemple est juste le cas lorsqu'il est nécessaire qu'un certain nombre d'opérateurs soient exécutés par condition, mais du fait que derrière le mot de service puisou autreun seul opérateur peut suivre, c'est-à-dire la capacité de résoudre la situation en utilisant un opérateur composé contenant juste un certain nombre de ces opérateurs nécessaires.
Lorsque vous composez des instructions conditionnelles imbriquées, gardez à l'esprit que la branche else appartient toujours à la branche précédente. SIqui n'a pas encore de branche else. Ceux. après la construction
si Condition1 puis si Condition2 puis Opérateur1 autreOperator2;
pour plus de clarté, il peut être interprété comme suit
si Condition1 alors commencez
siCondition2 puis Opérateur1 autreOperator2;
Il est nécessaire d'être prudent lors de l'utilisation d'instructions conditionnelles imbriquées, afin que dans le feu de la composition de la prochaine instruction conditionnelle d'un programme, vous ne perdiez pas de vue, à première vue, un petit détail qui peut conduire à une exécution complètement différente du branchement conditionnel.
Opérateur de variante
Assez souvent, une situation survient lorsque la chaîne d'opérateurs conditionnels se développe à une échelle énorme, par exemple, l'exemple suivant illustre une ramification de taille modeste, mais contenant déjà la complexité de percevoir le sens qui lui est inhérent:
type TWay \u003d (Haut, Droite, Bas, Gauche);
var Chemin: TWay;
MapX, MapY: mot;
siWay \u003d Up puis MapY: \u003d MapY - 1
autre si Chemin \u003d Droite puisMapX: \u003d MapX + 1
autresi Way \u003d Down puisMapY: \u003d MapY + 1
autre MapX: \u003d MapX - 1;
La dernière branche d'autre n'a pas d'opérateur Si, car si les trois conditions ne sont pas remplies, il serait logique que l'opérateur correspondant à la quatrième et dernière variante des valeurs possibles du type TWay.
Dans ce cas, nous avons également de la chance que le type TWaya seulement quatre options pour les valeurs acceptées. La compilation de telles branches deviendrait-elle une routine s'il y avait dix options ou plus? Mais dans la ramification présentée, il y a un modèle simple. Pouvez-vous donc le simplifier et le rendre plus efficace et lisible? C'est possible, et pour cela le langage fournit un opérateur variant, dont la construction peut contenir un nombre arbitraire d'alternatives pour une certaine expression. Ensuite, le dernier exemple peut être réécrit d'une nouvelle manière:
cas Façon de
En haut: MapY: \u003d MapY - 1;
Droite: MapX: \u003d MapX + 1;
Bas: MapY: \u003d MapY + 1;
Gauche: MapX: \u003d MapX - 1;
Eh bien, c'est une autre affaire. Regardons maintenant l'ordre d'exécution de cet opérateur. La valeur de l'expression qui suit le mot de service est précalculée cas, mais puisque dans ce cas il y a un nom de variable Façon, puis la valeur de cette variable est lue. La valeur résultante est comparée tour à tour à chaque alternative (constante, valeur immédiate) spécifiée après le mot de service de... Si la valeur de l'expression est égale à la constante suivante, l'opérateur alternatif est exécuté à la suite de cette constante, séparé d'elle par un deux-points. Après avoir terminé l'exécution de l'opérateur alternatif, l'action passe à l'opérateur suivant l'opérateur variante. Si la valeur ne correspond pas Façonsans constante, cet opérateur l'option ne prend aucune mesure.
Mais que se passe-t-il s'il est nécessaire de prévoir une certaine branche d'opérateurs, qui serait exécutée en cas de non-concordance de la valeur de l'expression avec une constante? Vous pouvez utiliser l'alternative else pour cela, par exemple:
casFaçon de
En haut: MapY: \u003d MapY - 1;
Droite: MapX: \u003d MapX + 1;
Bas: MapY: \u003d MapY + 1;
autre MapX: \u003d MapX - 1;
Par conséquent, la construction construite à l'aide de l'instruction case est complètement équivalente à la construction construite précédemment à l'aide de l'opérateur SI... De plus, c'est plus clair et il n'y a aucun risque de se confondre dans de nombreux autre.
Encore une fois, je souhaite attirer votre attention sur le fait que les constantes de l'opérateur variant peuvent être soit des entiers directs, soit les noms de constantes non typées décrites précédemment. L'utilisation de constantes typées dans des alternatives à l'opérateur variant n'est pas autorisée. De plus, dans chaque option, vous pouvez spécifier une liste complète de constantes séparées par des virgules ou une plage de valeurs, par exemple:
casFaçon de
Haut, Bas: writeln («Déplacement vertical»);
Droite, Gauche: writeln ("Déplacement horizontal");
casX de
10,20,30: writeln («dizaines»);
1..9: writeln («unités»);
Dans la dernière construction, l'opérateur writeln («unités») sera exécutée si la variable X a l'une des valeurs 1,2,3,..,8,9 .
Comme vous l'avez peut-être remarqué, j'ai aligné les lignes avec les constantes par deux points, car il me semble que cette vue est plus claire, bien que ce soit une question de goût, et comme vous le savez, il n'y a pas de camarade de goût et de couleur; O)
L'opérateur de variante doit être utilisé selon les règles suivantes:
1) Valeurs valides expressions - "commutateur" écrit après le mot de service cas, doivent satisfaire un type discret: pour un type entier, ils doivent être dans l'intervalle -32768..32767 .
2) Toutes les constantes alternatives spécifiées doivent être d'un type compatible avec le type de l'expression.
3) Les constantes des alternatives ne doivent pas être répétées dans un opérateur de variante, et les plages ne doivent pas se chevaucher et ne doivent pas contenir de constantes spécifiées dans cette alternative ou dans d'autres alternatives.
Encore une chose. Conception casfournit un opérateur pour chaque alternative. S'il devient nécessaire d'exécuter plusieurs instructions, regroupez-les dans une instruction composée begin..end... Il est possible de spécifier un opérateur vide pour une alternative en plaçant un ";" (point-virgule) juste après les deux points, ce qui ne fera rien. Et la syntaxe de la branche autrepermet de spécifier une séquence d'opérateurs, séparés par le symbole «;» (point-virgule).
