Section courante

A propos

Section administrative du site

Les instructions

Les instructions décrivent des actions algorithmiques pouvant être exécutées. Les étiquettes peuvent préfixer des instructions, et ces étiquettes peuvent être référencées par des instructions goto.

Une étiquette est soit une séquence de chiffres comprise entre 0 et 9999, soit un identificateur. Il existe deux principaux types d'instructions : les instructions simples et les instructions structurées.

Instructions simples

Une instruction simple est une instruction ne contenant aucune autre instruction.

Instructions d'affectation

Les instructions d'affectation remplacent la valeur actuelle d'une variable par une nouvelle valeur spécifiée par une expression. Ils peuvent également être utilisés pour définir la valeur de retour de la fonction.

L'expression doit être compatible avec l'affectation avec le type de la variable ou le type du résultat de la fonction. Voici des exemples d'instructions d'affectation :

  1. X := Y + Z;
  2. Done := (I >= 1) and (I < 100);
  3. Hue1 := [Bleu, Succ(C)];
  4. I := Sqr(J) - I * K;

Les règles de compatibilité d'attribution de type d'objet permettent à une instance d'un type d'objet de se voir attribuer une instance de l'un de ses types descendants. Une telle affectation constitue une projection du descendant sur l'espace parcouru par son ancêtre. L'affectation en tant qu'instance d'un objet n'initialise pas l'instance. En référence à l'exemple précédent, l'affectation F := Z ne signifie pas qu'un appel de constructeur pour F peut être omis.

Déclarations de procédure

Une instruction de procédure active une procédure spécifiée par un identificateur de procédure, un indicateur de méthode, un indicateur de méthode qualifié ou une référence de variable de type procédural. Si la déclaration de procédure correspondante contient une liste de paramètres formels, alors l'instruction de procédure doit avoir une liste correspondante de paramètres réels (les paramètres répertoriés dans les définitions sont des paramètres formels ; dans l'instruction appelante, ce sont des paramètres réels). Les paramètres réels sont transmis aux paramètres formels dans le cadre de l'appel.

Voici quelques exemples d'instructions de procédure :

  1. PrintHeading;
  2. Transpose(A, N, M);
  3. Find(Name,Address);

Instruction GOTO

Une instruction goto transfère l'exécution du programme à l'instruction marquée par l'étiquette spécifiée. Le diagramme de syntaxe d'une instruction goto suit :

Lorsque vous utilisez des instructions goto, respectez les règles suivantes :

Instructions structurées

Les instructions structurées sont des constructions composées d'autres instructions devant être exécutées de manière séquentielle (instructions composées et avec), conditionnellement (instructions conditionnelles) ou répétées (instructions répétitives).

Instructions composées

L'instruction composée spécifie que ses instructions composantes doivent être exécutées dans le même ordre qu'elles sont écrites. Les instructions des composantes sont traitées comme une seule instruction, cruciale dans les contextes où la syntaxe Pascal n'autorise qu'une seule instruction. Les mots réservés BEGIN et END mettent entre crochets les instructions, étant séparées par des points-virgules.

Voici un exemple d'instruction composée :

  1. Begin
  2.  Z := X;
  3.  X := Y;
  4.  Y := Z;
  5. End;

Instructions conditionnelles

Une instruction conditionnelle sélectionne pour l'exécution une seule (ou aucune) de ses instructions composantes.

La syntaxe d'une instruction IF se lit comme suit :

L'expression doit donner un résultat du type standard Boolean. Si l'expression produit la valeur True, l'instruction suivant THEN est exécutée.

Si l'expression produit False et que la partie ELSE est présente, l'instruction suivant ELSE est exécutée ; si la partie ELSE n'est pas présente, l'exécution se poursuit à l'instruction suivante suivant l'instruction IF. L'ambiguïté syntaxique résultant du construit :

  1. If e1 Then If e2 Then s1 Else s2;

est résolu en interprétant la construction comme suit :

  1. If e1 Then Begin
  2.  If e2 Then
  3.   s1
  4.  Else
  5.   s2
  6. End;

Habituellement, un ELSE est associé au plus proche s'il n'est pas déjà associé à un ELSE. Voici deux exemples d'instructions IF :

  1. If x < 1. 5 Then Z := X + Y
  2.             Else Z := 1.5;
  3. If P1 <> NIL Then P1 := P1^.Father;

Instruction CASE

L'instruction CASE se compose d'une expression (le sélecteur) et d'une liste d'instructions, chacune précédée d'une ou plusieurs constantes (appelées constantes CASE) ou du mot ELSE. Le sélecteur doit être d'un type ordinal de la taille d'un octet ou d'un mot, de sorte que les types chaîne de caractères et le type entier LongInt sont des types de sélecteur non valides. Toutes les constantes de casse doivent être uniques et d'un type ordinal compatible avec le type de sélecteur.

L'instruction CASE exécute l'instruction précédée d'une constante case égale à la valeur du sélecteur ou d'une intervalle CASE contenant la valeur du sélecteur. Si aucune constante case de l'intervalle CASE n'existe et qu'une partie ELSE est présente, l'instruction suivant ELSE est exécutée. S'il n'y a pas de partie ELSE, l'exécution se poursuit avec l'instruction suivante suivant l'instruction IF.

Voici des exemples d'instructions de CASE :

  1. Case Operator of
  2.  Plus: X := X + Y;
  3.  Minus: X := X - Y;
  4.  Times: X := X * Y;
  5. End;
  6. Case I of
  7.  0, 2, 4, 6, 8: Writeln('Chiffre pair ');
  8.  1, 3, 5, 7, 9: Writeln('Chiffre impair');
  9.  10..100: Writeln('Entre 10 et 100');
  10.  Else Writeln('Négatif ou supérieur à 100');
  11. End;

Instructions répétitives

Les instructions répétitives spécifient certaines instructions à exécuter de manière répétée.

Si le nombre de répétitions est connu à l'avance, l'instruction FOR est la construction appropriée. Sinon, l'instruction WHILE ou REPEAT doit être utilisée. Les procédures standard BREAK et CONTINUE peuvent être utilisées pour contrôler le flux d'instructions répétitives : BREAK termine une instruction répétitive et CONTINUE continue avec l'itération suivante d'une instruction répétitive.

Instruction REPEAT

Une instruction REPEAT contient une expression contrôlant l'exécution répétée d'une séquence d'instructions dans cette instruction REPEAT.

L'expression doit produire un résultat de type Boolean. Les instructions entre les symboles répéter et jusqu'à sont exécutées en séquence jusqu'à ce que, à la fin d'une séquence, l'expression donne True. La séquence est exécutée au moins une fois car l'expression est évaluée après l'exécution de chaque séquence. Voici des exemples d'instructions REPEAT :

  1. Repeat
  2.  K := I mod J;
  3.  I := J;
  4.  J := K;
  5. Until J = 0;
  6. Repeat
  7.  Write('Entrer la valeur (0..9): ');
  8.  ReadLn(I);
  9. Until (I >= 0) and (I <= 9);

Instructions WHILE

Une instruction WHILE contient une expression contrôlant l'exécution répétée d'une instruction (pouvant être une instruction composée).

L'expression contrôlant la répétition doit être de type Boolean. Elle est évaluée avant l'exécution de l'instruction contenue. L'instruction contenue est exécutée à plusieurs reprises tant que l'expression est True. Si l'expression est False au début, l'instruction n'est pas du tout exécutée.

Voici des exemples d'instructions WHILE :

  1. While Donnees[I] <> X do I := I + 1;
  2. While I > 0 do Begin
  3.  If Odd (I)Then Z := Z * X;
  4.  I := I div 2;
  5.  X := Sqr(X);
  6. End;
  7. While Not Eof(InFile) do Begin
  8.  Readln(InFile,Ligne);
  9.  Process(Ligne);
  10. End;

Instruction FOR

L'instruction FOR provoque l'exécution répétée d'une instruction tandis qu'une progression de valeurs est affectée à une variable de contrôle. Une telle déclaration peut être une déclaration composée.

La variable de contrôle doit être un identificateur de variable (sans aucun qualificateur) de portée locale au bloc contenant l'instruction FOR. La variable de contrôle doit être de type ordinal. Les valeurs initiales et finales doivent être d'un type compatible avec le type ordinal. Lorsqu'une instruction FOR est saisie, les valeurs initiale et finale sont déterminées une fois pour le reste de l'exécution de l'instruction FOR.

L'instruction contenue par l'instruction FOR est exécutée une fois pour chaque valeur comprise entre la valeur initiale et la valeur finale. La variable de contrôle démarre toujours à la valeur initiale. Lorsqu'une instruction FOR utilise TO, la valeur de la variable de contrôle est incrémentée de un pour chaque répétition. Si la valeur initiale est supérieure à la valeur finale, l'instruction contenue n'est pas exécutée. Lorsqu'une instruction FOR utilise DOWNTO, la valeur de la variable de contrôle est décrémentée de un pour chaque répétition. Si la valeur initiale est inférieure à la valeur finale, l'instruction contenue n'est pas exécutée.

Si l'instruction contenue modifie la valeur de la variable de contrôle, vos résultats ne seront probablement pas ceux que vous attendez. Après l'exécution d'une instruction FOR, la valeur de la variable de contrôle value n'est pas définie, à moins que l'exécution de l'instruction FOR n'ait été interrompue par un GOTO à partir de l'instruction FOR. Avec ces restrictions à l'esprit, l'instruction FOR :

  1. For V := Expr1 to Expr2 do Body;

est équivalent à :

  1. Begin
  2.  TempI := Expr1;
  3.  Temp2 := Expr2;
  4.  If TempI <= Temp2 Then Begin
  5.   V := Temp1;
  6.   Body;
  7.   While V <> Temp2 do Begin
  8.    V := Succ(V);
  9.    Body;
  10.   End;
  11.  End;
  12. End;

et l'instruction FOR :

  1. For V:=Expr1 DownTo Expr2 do Body;

est équivalent à :

  1. Begin
  2.  Temp1 := Expr1;
  3.  Temp2 := Expr2;
  4.  If Temp1 >= Temp2 Then Begin
  5.   V := Temp1;
  6.   Body;
  7.   While V <> Temp2 do Begin
  8.    V := Pred(V);
  9.    Body;
  10.   End;
  11.  End;
  12. End;

où Temp1 et Temp2 sont des variables auxiliaires du type hôte de la variable V et n'apparaissent pas ailleurs dans le programme. Voici des exemples d'instructions FOR :

  1. For I := 2 to 63 do If Donnees[I] > Max Then Max := Donnees[I]
  2. For I := 1 to 10 do For J := 1 to 10 do Begin
  3.  X := 0;
  4.  For K := 1 to 10 do X := X + Mat1[I, K] * Mat2[K, J];
  5.  Mat [I, J] : = X;
  6. End;
  7. For C := Rouge to Bleu do Verifier(C);

Instruction WITH

L'instruction WITH est un raccourci pour référencer les champs d'un enregistrement et les champs et méthodes d'un objet. Dans une instruction WITH, les champs d'une ou plusieurs variables d'enregistrement spécifiques peuvent être référencés à l'aide de leurs identifiants de champ uniquement. La syntaxe d'une instruction WITH suit :

Compte tenu de cette déclaration de type :

  1. Type
  2.  TDate=Record
  3.   Day:Integer;
  4.   Month:Integer;
  5.   Year:Integer;
  6.  End;
  7. Var 
  8.  OrderDate:TDate;

Voici un exemple d'instruction WITH :

  1. With OrderDate do If Month = 12 Then Begin
  2.  Month:=1;
  3.  Year:=Year+1
  4. End
  5.  Else
  6. Month:=Month+1;

Ceci équivaut à :

  1. If OrderDate.Month = 12 Then Begin
  2.  OrderDate.Month:=1;
  3.  OrderDate.Year:=TDate.Year+1
  4. End
  5.  Else
  6. OrderDate.Month:=TDate.Month+1;

Dans une instruction WITH, chaque référence de variable est d'abord vérifiée pour voir si elle peut être interprétée comme un champ de l'enregistrement. Si c'est le cas, il est toujours interprété comme tel, même si une variable du même nom est également accessible. Supposons que les déclarations suivantes aient été faites :

  1. Type
  2.  TPoint=Record
  3.   X,Y:Integer;
  4.  End;
  5. Var
  6.  X:TPoint;
  7.  Y:Integer;

Dans ce cas, X et Y peuvent faire référence à une variable ou à un champ de l'enregistrement. Dans l'instruction :

  1. With X do Begin
  2.  X := 10;
  3.  Y := 25;
  4. End;

Le X entre avec et DO fait référence à la variable de type TPoint, mais dans l'instruction composée, X et Y font référence à X.X et X.Y. L'instruction suivante :

  1. With V1, V2, ... Vn do S;

est équivalent à :

  1. With V1 do
  2.  With V2 do
  3.   With Vn do
  4.    S;

Dans les deux cas, si Vn est un champ à la fois de V1 et de V2, il est interprété comme V2.Vn, pas V1.Vn. Si la sélection d'une variable d'enregistrement implique l'indexation d'un tableau ou le déréférencement d'un pointeur, ces actions sont exécutées une fois avant l'exécution de l'instruction de composante.



Dernière mise à jour : Vendredi, le 31 décembre 2021