Home | Linux | Réseaux | Developpement | Divers | FAQ | Forum | Guestbook | Musique |

Turbo Pascal

1 - Les instructions

1.1 - Les instructions simples

1.1.1 - L'instruction d'affectation

L'instruction d'affectation fait partie des instructions de base de tout langage de programmation. Elle est de forme : Variable:=Expression ce qui implique en général que le type d'expression doit correspondre à celui de la variable.

1.1.2 - L'instruction de procédure

Pascal permet de pratiquer l'analyse descendante. On peut donc être ammené à définir des procédures dans lesquelles on dira exactement de quelle façon on veut qu'une tâche soit réalisée. Les procédures permettent ainsi de nommer une succéssion d'instructions simples et d'instructions de commandes, et l'instruction d'appel de procédure réalise l'activation d'une procédure. La syntaxe est la suivante : NomProcedure(Liste de paramètres.

1.2 - Les insructions de commandes

1.2.1 - La séquence d'instructions

Dans les langages de proggrammation, une séquence d'instruction est une structure de commande qui regroupe ou délimite des instructions d'action ou de commande que l'on doit executer l'une après l'autre et traiter comme une action composée. En Turbo Pascal, comme dans bien d'autres langages de programmation, une séquence d'instructions est délimitée par les mots réservés begin et end.

begin
  <instruction 1>;
  <instruction 2>;
  <instruction 3>;
   
  <instruction n>;
end;

1.2.2 - La sélection

Lorsqu'un programmeur veut, étant donné la valeur d'une expression booléenne, choisir entre plusieurs instructions à exécuter, il doit effectuer une sélection :

if <expression booléenne> then
  <instruction>

Une expression booléenne est tout simplement une expression dont la valeur est soit true soit false. Lorsque la sélection comporte une alternative , on utilise une instruction if/then/else de la forme :

if <expression booléenne> then
  <instruction 1>
else
  <instruction 2>

Si l'on doit exécuter plusieurs instructions, on délimite chaque bloc d'instructions par begin et end. Si notre choix à effectuer ne se réduit pas à une simple alternative, nous pouvons utiliser l'instruction case :

case <expression scalaire> of
  <cas 1> : <instruction 1>;
  <cas 2> : <instruction 2>;
        
  <cas n> : <instruction n>
else
  <instruction par défaut>
end;

1.2.3 - La répétitions

Turbo Pascal permet de faire des répétitions de trois façons différentes : while/do, repeat/until et for/do.

La boucle while/do est une boucle de pré-condition ce qui signifie que l'expression booléenne qui contrôle l'execution de la séquence d'instruction à repeter est évaluée en début de boucle. Sa syntaxe est la suivante :

while <expression booléenne> do
  <instruction>

La boucle for/do est un cas particulier du while/do, puisque c'est une boucle de pré-condition ; avec cette instruction, on modifie la valeur d'une variable de contrôle qui au départ a une valeur initiale et on la compare à une valeur finale avant chaque début de boucle. Sa syntaxe est la suivante :

for i:=0 to 49 do
  <instruction>
  //on additione 1 à i
        
for ch:='Z' downto 'A' do
  <instruction>
  //ch prend la valeur du caractère précédent

La troisième forme de boucle, l'instruction repeat/until est une boucle de post-condition c'est à dire que la séquence d'instruction est exécutée avant que l'on teste l'expression booléenne. Noter egalement que la boucle repeat/until différe des autres en ce qu'elle contrôle directement une séquence d'instruction et non une instruction unique. La boucle repeat/until s'écrit de la façon suivante :

repeat
  <instruction 1>
  <instruction 2>
  <instruction 3>
    
  <instruction n>
until <expression booléenne>

2 - Les types de données

Nous venons de voir les outils logiques dont on disposait avec Turbo Pascal, outoils qui permettent de contrôler les opérations portant sur les données. Lorsque nous utilisons correctement ces outils, nous réalisons ce que l'on appele un algorythme, et lorsque l'on aplique ds algorythmes à des données, alors on obtient des programmes.

2.1 - Les types simples

2.1.1 - Les types entiers

Toutes les versions de Turbo Pascal disposent de types scalaires prédéfinis : boolean pour les booléens, char pour les caractères et integer pour les entiers. Turbo Pascal comporte quatre types supplémentaires qui dérivent du type integer : byte pour les octets non signés, longint pour les entiers longs, shotint pour les entiers couts et word pour les mots de 16 bits non signés.

2.1.2 - Les types réels

Turbo Pascal offre toute une famille de type réels. Dans chaque type, l'ensemble des valeurs est un sous ensemble de nobres réels représentés en virgule flotante avec un nombre de chiffre limité. On trouve ainsi cinq types de réel : comp, single, real, double et extended.

2.2 - Les types définis par le programmeur

En partant des types prédéfinis dans le langage, un programmeur peut définir ses propres types de données.

2.2.1 - Equivalence de type

La façon la plus simple de définir un nouveau type est de l'identifier à un type déjà existant :

type
  entier = integer;
  flotant = real;
  flotantlong = extended;
  caractere = char;
  logique = boolean;