Section courante

A propos

Section administrative du site

Les premiers pas

Dans sa forme la plus simple, un programme Turbo Pascal est composé d'un entête de programme, nommant le programme, et du bloc de programme principal, accomplissant l'objectif du programme. Dans le bloc de programme principal se trouve une section de code apparaissant entre deux mots clefs : BEGIN et END. Voici un programme très simple illustrant ces concepts :

  1. Program Bonjour;
  2.  
  3. BEGIN
  4.  Writeln('Bonjour le Turbo Pascal !');
  5. END.

La première ligne est l'entête du programme, nommant le programme. Le reste du programme est le code commençant par BEGIN et se termine par END. Bien que cette section de code particulière ne contienne qu'une seule ligne, elle peut en contenir plusieurs. Dans n'importe quel programme Turbo Pascal, toute l'action se produit entre le BEGIN et END.

Procédures et fonctions

Le code entre le dernier BEGIN et la dernière END d'un programme pilote la logique du programme. Dans un programme très simple, cette section de code pourrait être tout ce dont vous avez besoin. Dans des programmes plus gros et plus complexes, mettre tout votre code ici peut rendre votre programme plus difficile à lire et à comprendre, et plus difficile à développer. Les procédures et les fonctions vous permettent de diviser la logique d'un programme en morceaux plus petits et plus faciles à gérer, et sont similaires aux sous-routines de certains autres langages. Toute l'action d'une procédure ou d'une fonction se produit dans le code entre son BEGIN et sa END, tout comme dans le bloc de programme principal. Chacun de ces segments de code exécute une petite tâche discrète.

Si vous constatez que votre programme fait la même chose plusieurs fois, vous voudrez peut-être mettre la logique dans une procédure ou une fonction. Vous écrivez le code dans une procédure ou une fonction une fois et votre programme peut l'utiliser aussi souvent que nécessaire. Voici un exemple de fonction. Cette fonction GetNumber obtient un numéro de l'utilisateur :

  1. Function GetNumber:Real;
  2. Var
  3.  Response:Real;
  4. Begin
  5.  Write('Entrer un nombre : ');
  6.  Readln(Response);
  7.  GetNumber:=Response;
  8. End;

Une procédure ou une fonction doit apparaître avant la section de code principal dans le bloc de programme principal. La section de code principal peut alors utiliser la procédure ou la fonction.

L'exemple suivant est un aperçu d'un programme utilisant la fonction GetNumber. Le programmeur a divisé la logique de ce programme en trois tâches :

La logique principale du programme se trouve entre le dernier BEGIN et la dernière END :

  1. Program Report;
  2. Var
  3.  A:Real; 
  4.  { Plus de déclarations }
  5.  { ... }
  6.  Function GetNumber:Real;
  7.  Var
  8.   Response:Real;
  9.  Begin
  10.   Write('Entrer un nombre : ');
  11.   ReadLn(Response);
  12.   GetNumber:=Response;
  13.  End;
  14.  
  15.  Procedure Calculate(X:Real);
  16.   { ... }
  17.  Procedure PrintReport;
  18. BEGIN
  19.  A:=GetNumber;
  20.  Calculate(A);
  21.  PrintReport;
  22. END.

La logique principale de ce programme est très simple à comprendre. Tous les détails sont cachés dans les corps des procédures et des fonctions. L'utilisation de procédures et de fonctions vous encourage à penser votre programme d'une manière logique et modulaire.

Instructions

La section de code entre BEGIN et END contient des instructions décrivant les actions que le programme peut effectuer et est appelée la partie instruction. Voici des exemples d'énoncés :

  1. A := B + C;
  2. Calculate(Longueur,Hauteur);
  3. If X < 2 Then Answer := X * Y;
  4. Begin
  5.  X:=3;
  6.  Y:=4;
  7.  Z:=5;
  8. End;
  9. While Not EOF(InFile) do Begin
  10.  ReadLn(InFile, Ligne);
  11.  Process(Ligne);
  12. End;

Des instructions simples peuvent soit affecter une valeur, activer une procédure ou une fonction, soit transférer l'exécution du programme à une autre instruction dans le code. Les deux premiers exemples présentés dans les exemples sont des déclarations simples. Les instructions structurées peuvent être des instructions composées contenant plusieurs instructions, des instructions conditionnelles et répétitives contrôlant le flux de la logique au sein d'un programme et des instructions simplifiant l'accès aux données d'un enregistrement. Vous pouvez comparer une déclaration Turbo Pascal à une phrase dans une langue humaine telle que l'anglais, le danois ou le grec. Les déclarations simples de Turbo Pascal et les phrases humaines simples contiennent une pensée complète. Les instructions Turbo Pascal structurées et les phrases complexes contiennent une logique plus compliquée.

Expressions

De même qu'une phrase est composée de phrases, un énoncé Turbo Pascal est composé d'expressions. Les expressions d'une phrase sont composées de mots et les expressions d'un énoncé sont composées d'éléments appelés facteurs et opérateurs. Les expressions comparent généralement des choses ou effectuent des opérations arithmétiques, logiques ou booléennes.

Tout comme les phrases dans une langue humaine peuvent être composées de phrases plus petites, les expressions en Turbo Pascal peuvent être composées d'expressions plus simples. Ils peuvent être assez complexes. Pour l'instant, il peut être utile de voir quelques exemples d'expressions :

  1. x + Y
  2. Fait <> Erreur
  3. I <= Longueur
  4. -x

Jetons

Les jetons sont les plus petits éléments significatifs d'un programme Turbo Pascal. Ils constituent les facteurs et opérateurs des expressions. Les jetons sont des symboles spéciaux, des mots réservés, des identificateurs, des étiquettes, des nombres et des constantes de chaîne de caractères ; ils s'apparentent aux mots et à la ponctuation d'un langage humain écrit. Voici des exemples de jetons Turbo Pascal :

  1. Function { Mot réservé }
  2. (        { Symbole spécial }
  3. :=       { Symbole spécial }
  4. Calculer { Identificateur pour une procédure }
  5. 9        { Nombre }

Voici une illustration d'une déclaration. Vous pouvez voir que les déclarations sont constituées d'expressions, étant constituées de jetons.

Types, variables, constantes et constantes typées

Une variable peut contenir une valeur pouvant changer. Chaque variable doit avoir un type. Le type d'une variable spécifie l'ensemble de valeurs que la variable peut avoir. Par exemple, ce programme déclare que les variables X et Y sont de type Integer ; par conséquent, les seules valeurs que X et Y peuvent contenir sont des nombres entiers, étant des nombres entiers. Le Turbo Pascal affiche un message d'erreur si votre programme essaie d'affecter un autre type de valeur à ces variables.

  1. Program Exemple;
  2. Const
  3.  A=12;             { Constante ne changeant jamais de valeur }
  4.  B:Integer=23;     { Constante typé B demande une valeur initiale }
  5.  
  6. Var
  7.  X,Y:Integer;      { Variables X et Y sont de type Integer }
  8.  J:Real;           { Variable J est de type Real }
  9.  
  10. BEGIN
  11.  X:=7;             { La variable X est assigné à une valeur }
  12.  Y:=8;             { La variable Y est assigné à une valeur }
  13.  X:=Y + Y;         { La valeur de la variable X change }
  14.  B:=57;            { La constante typé B demande une nouvelle valeur }
  15.  J:=0.075;         { La variable J demande une valeur de point flottante }
  16. END.

Dans ce programme simple et peu utile, X se voit attribuer la valeur 7 à l'origine ; deux instructions plus tard, une nouvelle valeur lui est attribuée, Y + Y. La valeur d'une variable peut varier. A est une constante. Le programme lui donne une valeur de 12 et cette valeur ne peut pas changer-sa valeur reste constante tout au long du programme.

B est une constante typée. On lui donne une valeur lorsqu'elle est déclarée, mais on lui donne également un type Integer. Vous pouvez considérer une constante typée comme une variable avec une valeur initiale. Le programme peut plus tard changer la valeur initiale de B en une autre valeur. La partie de ce programme déclarant les constantes et les variables est appelée la partie déclaration. Si vous revenez à l'exemple Report, vous verrez que la fonction GetNumber a une partie de déclaration déclarant une variable. Les procédures et les fonctions peuvent contenir une partie de déclaration tout comme un programme ou une unité.

Mettre tous ensemble

Maintenant que vous avez été initié aux principaux composantes d'un programme Turbo Pascal, vous devez voir comment ils s'emboîtent tous. Voici une illustration d'un programme Turbo Pascal :

L'entête du programme, la clause facultative USES et le bloc de programme principal constituent un programme Turbo Pascal. Dans le bloc de programme principal peuvent exister les plus petits blocs de procédures et de fonctions. Bien que le diagramme ne le montre pas, les procédures et fonctions peuvent être imbriquées dans d'autres procédures et fonctions. En d'autres termes, les blocs peuvent contenir d'autres blocs.

Combinés à d'autres jetons et espaces vides, les jetons constituent des expressions constituant des déclarations. À leur tour, des instructions combinées avec des parties de déclaration constituent des blocs, soit le bloc principal du programme, soit un bloc dans une procédure ou une fonction.

Les unités

Un programme Turbo Pascal peut utiliser des blocs de code dans des modules séparés appelés unités. Vous pouvez considérer une unité comme un mini-programme que votre application peut utiliser. Comme un programme, il a un entête, appelé entête d'unité, et un bloc principal contenant une section de code délimitée par un début et une fin.

Tout bloc de programme principal Turbo Pascal peut inclure une ligne permettant au programme d'utiliser une ou plusieurs unités. Par exemple, si vous écrivez un programme appelé Colors et que vous souhaitez modifier la couleur du texte tel qu'il apparaît sur votre écran, vous pouvez spécifier que votre programme utilise l'unité Crt standard faisant partie de la bibliothèque d'exécution Turbo Pascal :

  1. Program Colors;
  2.  
  3. Uses Crt;
  4.  
  5. BEGIN
  6. END.

La ligne Uses Crt indique à Turbo Pascal d'inclure l'unité Crt dans le programme exécutable. L'unité Crt contient tout le code nécessaire pour changer la couleur du texte dans votre programme, entre autres. En incluant simplement utilise Crt, votre programme peut utiliser toutes les procédures et fonctions de l'unité Crt. Si vous mettez tout le code requis pour créer la fonctionnalité de l'unité Crt dans votre programme, ce serait beaucoup plus de travail, et cela vous détournerait de l'objectif principal de votre programme.

La bibliothèque d'exécution de Turbo Pascal comprend plusieurs unités que vous trouverez utiles. Par exemple, utilisez l'unité DOS et votre programme a accès à plusieurs systèmes d'exploitation et routines de gestion de fichiers.

Vous pouvez également écrire vos propres unités. Utilisez-les pour diviser de grands programmes en modules logiquement liés. Le code que vous placez dans une unité peut être utilisé par n'importe quel programme. Vous n'avez qu'à écrire le code une fois, puis vous pouvez l'utiliser plusieurs fois.



Dernière mise à jour : Dimanche, le 26 décembre 2021