Section courante

A propos

Section administrative du site

Bases de la programmation

Cette page vous présente certains principes de base de la programmation Pascal, tels que les types de données, les constantes, les variables, les opérateurs et les expressions. Si vous êtes déjà un programmeur expérimenté dans une autre langue, vous trouverez peut-être que la plupart de ce matériel vous est familier. Dans ce cas, vous voudrez peut-être parcourir rapidement cette page ou simplement passer à la page suivante.

Types de données

Toutes les données de votre programme sont soit une constante, soit une variable ; chacun a un type de données associé. Deux types de types de données existent dans QuickPascal : les types de données prédéfinis et les types de données définis par l'utilisateur. Les types de données prédéfinis, tels que REAL et STRING, font partie intégrante du langage et sont décrits ci-dessous. Les types de données définis par l'utilisateur augmentent considérablement votre puissance de programmation. Les types de données prédéfinis pris en charge par QuickPascal et expliqués dans les sections suivantes sont :

Types entiers

Les nombres entiers sont des nombres entiers comme les nombres avec lesquels vous comptez ; c'est-à-dire qu'ils n'ont pas de parties fractionnaires. Le nombre 12 est un entier ; 12.0 et 12.5 ne le sont pas. Le tableau suivant répertorie les cinq types d'entiers pris en charge par le QuickPascal. Les programmes discutés plus loin dans cette page montrent comment ces nombres entiers sont utilisés :

Type entier Intervalle de valeurs Taille en octets Exemples
ShortInt -128 à 127 1 -7, 55, 123,0, $F
Byte 0 à 255 1 55,123, $F, 0
Integer -32768 à 32767 2 -555,30000, 0, $FF
Word 0 à 65535 2 30000, 60000, $FFFF
LongInt -2147483648 à 2147483647 4 -100000,100000, $FFFF

Les types d'entiers Byte et Word sont appelés entiers "non signés", tandis que les autres types d'entiers sont appelés entiers "signés". Le mot «non signé» indique que l'entier comprend des valeurs allant de zéro à la limite positive supérieure. Les entiers signés incluent les nombres négatifs.

Vous pouvez voir que la principale différence entre les différents types d'entiers est l'intervalle des valeurs pouvant être entreposées. Dans la section VAR de votre programme, vous déclarez l'identificateur de la variable et le type spécifique.

Comme le montrent les exemples du tableau précédent, le QuickPascal vous permet d'écrire des nombres entiers en notation décimale (base 10) ou hexadécimale (base 16). Les nombres hexadécimaux commencent par le signe dollar ($) et utilisent les caractères 0 à 9 et A à F. Le programme INTTYPES.PAS ci-dessous illustre différents types d'entiers :

  1. Program IntTypes;
  2. { INTTYPES.PAS démonstration des types de données entiers. }
  3.  
  4. Uses
  5.  Crt;
  6.  
  7. Var
  8.  short_int_val:ShortInt;
  9.  byte__val:Byte;
  10.  integer_val:Integer;
  11.  word_val:Word;
  12.  long_int_val:LongInt;
  13.  
  14. BEGIN
  15.  short_int_val:=-31;
  16.  byte_val:=255;
  17.  integer_val:=-21212;
  18.  word_val:=$FFFF;
  19.  long_int_val:=12918656;
  20.  ClrScr;
  21.  WriteLn('short_int_val = ',short_int_val);
  22.  WriteLn('byte_val = ', byte_val);
  23.  WriteLn('integer_val = ', integer_val);
  24.  WriteLn('word_val = ', word_val);
  25.  WriteLn( 'long_int_val = ', long_int_val);
  26. END.

Voici la sortie de INTTYPES.PAS :

short_int_val = -31
byte_val = 255
integer_val = -21212
word_val = 65535
long_int_val = 12918656

Types à virgule flottante

Les nombres à virgule flottante ne sont pas des entiers ; c'est-à-dire qu'ils sont écrits avec un point décimal. Ainsi, le nombre 12,5 est un nombre à virgule flottante, tout comme .00021459862. De plus, le QuickPascal traite les constantes supérieures à son maximum comme des nombres à virgule flottante de taille entière, même s'ils ne contiennent pas de point décimal. Les nombres à virgule flottante sont également appelés nombres "réels". Le QuickPascal prend en charge un groupe de types à virgule flottante dont la précision, l'intervalle de valeurs et les exigences d'entreposage varient. Ils sont présentés dans le tableau suivant :

Type Intervalle de valeur Taille en octet Chiffres significatifs
Single 1.5E-45 à 3.4E+38 4 7-8
Real 2.9E-39 à 1.7E+38 6 11-12
Double 5.0E-324 à 1.7E+308 8 15-16
Extended 3.4E-4951 à 1.1E+4932 10 15-16
Comp -9.2E+18 à 9.2E+18 8 15-16

Par défaut, le QuickPascal suppose que votre ordinateur n'utilise pas de coprocesseur mathématique, ce qui entraîne moins de chiffres significatifs que s'il utilisait un coprocesseur. Cependant, si vous disposez d'un coprocesseur mathématique (n'importe quel membre de la famille de processeurs 8087), vous pouvez augmenter la précision des types de données Comp et Extended de 4 chiffres significatifs en incluant la directive de compilateur {$N+} dans votre programme.

Contrairement à certains autres compilateurs Pascal, le QuickPascal met à votre disposition tous les types de nombres réels, que votre ordinateur dispose ou non d'un coprocesseur numérique.

Le type Comp est un peu différent des autres types à virgule flottante. Le type de données Comp est conçu pour compter de très grands nombres, et donc il n'entrepose que la partie entière d'un nombre entre -(2^63)+1 et (2^63)-1.

Type de caractère

Le type de données caractère Char n'entrepose qu'un seul caractère. Chaque caractère occupe un octet d'entreposage. Vous pouvez représenter des caractères en utilisant les formats suivants :

Caractères Représentation
Caractères lisibles (c'est-à-dire l'alphabet, les chiffres et les caractères de ponctuation) Peut être représenté en utilisant les mêmes lettres, chiffres et ponctuation.
Caractères de contrôle (caractères ASCII 0 à 31) Peut être représenté à l'aide du symbole carat (^) suivi de la lettre de contrôle. Par exemple, le saut de page est représenté par ^L, car le saut de page est ASCII 12 et L est la 12e lettre de l'alphabet.
Tous les caractères, y compris ceux de la table ASCII étendue Peut être représenté en utilisant le signe dièse (#) suivi du numéro de code ASCII. Ainsi, #65 est la lettre A, #12 est le saut de page, et ainsi de suite.

Types String

Ce type de données entrepose une chaîne de caractères telle qu'un nom ou une adresse. Les chaînes de caractères QuickPascal peuvent contenir jusqu'à 255 caractères. De nombreux exemples de ces pages utilisent des chaînes de caractères pour afficher des messages et entreposer des entrées. Le programme STRINGS.PAS montre comment créer, lire et écrire des chaînes de caractères simples :

  1. Program Strings;
  2.  { STRINGS.PAS Simple démonstration d'opération de chaîne de caractères. }
  3.  
  4. Uses
  5.  Crt;
  6.  
  7. Const
  8.  str_constant = 'Tapez quelque chose et appuyez sur Enter : ';
  9.  
  10. Var
  11.  prompt_one:String;
  12.  prompt_two:String;
  13.  input_str:String;
  14.  
  15. BEGIN
  16.  prompt one := str_constant;
  17.  prompt_two := 'Vous tapez: ';
  18.  ClrScr;
  19.  Write(prompt_one);
  20.  ReadLn(input_str);
  21.  Write(prompt_two);
  22.  WriteLn(input_str);
  23. END.

Voici une sortie typique de STRINGS.PAS :

Tapez quelque chose et appuyez sur Enter : QuickPascal!
Vous tapez: QuickPascal!

Déclarer des chaînes de caractères

Les chaînes de caractères Pascal sont généralement du type STRING. Dans STRINGS.PAS, les instructions :

  1. Var
  2.  prompt_one:String;
  3.  prompt_two:String;
  4.  input_str:String;

déclarez trois variables de chaîne de caractères nommées prompt_one, prompt_two et input_str.

Initialisation des chaînes de caractères

Vous pouvez initialiser des variables de chaîne en leur affectant des littéraux de chaîne ou des constantes :

  1. CONST
  2.  str_constant = 'Tapez quelque chose et appuyez sur Enter : ';
  3.  
  4. prompt_one := str_constant; { Attribuer une constante de chaîne de caractères }
  5. prompt_two := 'Vous tapez: '; { Attribuer un littéral de chaîne de caractères }

Les chaînes de caractères Pascal peuvent contenir jusqu'à 255 caractères. Le premier caractère d'une chaîne de caractères est un "octet de longueur" indiquant le nombre de caractères de la chaîne de caractères. Des procédures telles que Writeln examinent cet octet pour déterminer la taille de la chaîne de caractères. Ainsi, si vous affectez Bonjour à une variable chaîne de caractères, la variable contient en fait 8 caractères : un octet de longueur contenant le chiffre 7, suivi des 7 caractères de Bonjour.

Lecture et écriture de chaînes de caractères

Vous pouvez utiliser les procédures Read et Readln pour lire une chaîne de caractères :

  1. ReadLn(input_str);

et les procédures Write et Writeln pour écrire une chaîne de caractères :

  1. Write(prompt_two);
  2. Writeln(input_str);

Ces procédures lisent les entrées du clavier et écrivent les sorties à l'écran.

Type Boolean

Une variable de type Boolean peut être affectée d'une valeur True ou False. Les variables de ce type sont souvent utilisées comme "drapeaux" lorsqu'une condition de votre programme devient vraie (ou fausse). Supposons, par exemple, que vous vouliez vérifier si un utilisateur a fini de saisir des données. Si la variable all_done avait été déclarée de type Boolean, vous pouvez l'utiliser comme ceci :

  1. If(x=0)Then all_done:=True;

Plus tard, vous devrez peut-être vérifier la variable all_done :

  1. If(all_done = True)Then ...

Une manière abrégée d'écrire cette instruction est :

  1. If(all_done)Then ...

Il est entendu que «If all_done» signifie la même chose que «If (all_done = True)» et par la même compréhension, «If(Not all_done)» signifie «If (all_done = False)».

Constantes

Les données fixes, ou "constantes", se voient attribuer une valeur n'étant jamais modifiée (une exception à cela, appelée "constantes typées", est décrite ci-dessous). Lorsque vous déclarez des constantes en Pascal, vous leur attribuez un nom et une valeur. Cette valeur, une fois signée, ne peut plus être modifiée dans votre programme. L'affectation d'un nom et d'une valeur à une constante s'appelle une déclaration de constante. Le QuickPascal prend en charge deux types de constantes : simples et typées.

Constantes simples

Les constantes simples peuvent être utilisées à deux fins. Premièrement, ils peuvent entreposer des valeurs fixes, comme le nombre de pouces dans un pied. Deuxièmement, ils peuvent entreposer des valeurs que vous souhaitez utiliser dans votre programme, comme le texte d'un écran de titre ou votre hypothèse pour le taux d'inflation. Puisque les constantes sont toutes déclarées au début de votre programme, il est facile de changer n'importe laquelle de ces valeurs et de recompiler votre programme. N'oubliez pas que la modification de la valeur d'une constante dans sa déclaration initiale donne cette nouvelle valeur à la constante partout où elle est utilisée. En fait, toutes les autres constantes dépendant de celle que vous modifiez recevront également leurs valeurs mises à jour lorsque vous recompilerez le programme.

La syntaxe générale pour déclarer et initialiser une constante est :

CONST
   Constantldentifier = {ConstantValue|Expression}

Par exemple :

  1. CONST
  2.  ft_per_mile=5280;

Dans cet exemple, le ConstantIdentifier est ft_per_mile et la ConstantValue est 5280.

Dans QuickPascal, vous pouvez utiliser une expression contenant une constante précédemment déclarée. Vous pouvez également définir une constante égale à une expression, comme dans :

  1. CONST
  2.  days_per_year=365;
  3.  seconds_per_day=60*60*24;
  4.  light_speed=186282;
  5.  light_year=light_speed*seconds_per_day*days_per_year;

Cependant, si vous déclarez une constante égale à une expression, cette expression ne peut contenir que des opérations simples comme l'addition, la soustraction, la multiplication et la division. Les fonctions Pascal plus avancées comme la racine carrée ne peuvent pas être utilisées.

Voici d'autres exemples de constantes :

  1. Const
  2.  max_row=10;
  3.  max_col=10;
  4.   { Utilise des constantes précédemment déclarées }
  5.  table_size=max_row*max_col;
  6.  prompt='Appuyez sur n''importe quelle touche pour reprendre...';
  7.  byebye='Merci d''avoir utilisé le programme...';
  8.  euler_const=0.577215664901;
  9.   { Une approximation de la constante d'Euler }
  10.  euler_const2=228.0/395.0;

Constantes typées

Le QuickPascal vous permet d'utiliser un autre type de constante appelée "constante typée". En Pascal standard, vous ne pouvez pas spécifier le type de données d'une constante. Le compilateur signe les données d'un type en fonction de la manière dont elles sont présentées. Par exemple, une constante appelée number_of_people avec une valeur de 35 se verrait attribuer un type entier par QuickPascal, ce qui est logique. Cependant, si vous avez déclaré number_of_people égal à 35,0, le compilateur attribuerait un type de nombre réel à number_of_people, ce qui n'a pas beaucoup de sens.

Heureusement, QuickPascal vous permet d'indiquer spécifiquement le type de données associé à une constante, étant la constante typée. Vous pouvez également voir les termes "constante variable" ou "variable statique" utilisés pour décrire une telle constante. La déclaration de données avec une constante typée transforme en fait la constante en une variable initialisée. Autrement dit, la valeur associée à l'identificateur de constante typée peut être modifiée dans le programme, contrairement aux constantes régulières dont la valeur ne peut pas être modifiée dans le programme.

Une constante typée peut être considérée comme un croisement entre une constante et une variable. La valeur d'une constante est déclarée mais ne peut jamais être modifiée. Une variable, en revanche, n'est pas déclarée avec une valeur prédéfinie et sa valeur peut changer au sein du programme. Une constante typée est comme une variable dont la valeur prédéfinie est déclarée mais pouvant être redéfinie dans le programme.

La syntaxe générale est illustrée ci-dessous :

CONST
   ConstantIdentifier:TypeName = {ConstantValue|Expression}

Des exemples de déclarations de constantes typées sont donnés ci-dessous. Notez que la ConstantValue ou l'Expression affectée à la constante typée ressemble beaucoup à une valeur ou à une expression affectée à une variable régulière. Notez que vous utilisez le :TypeName pour spécifier le type de la constante, comme vous le feriez dans une déclaration VAR :

  1. Const
  2.  max_row:Word=10;
  3.  max_col:Word=10;
  4.  table_size:Word=max_row*max_col;
  5.  prompt:String='Appuyez sur n''importe quelle touche pour reprendre...';
  6.  byebye:String='Merci d''avoir utilisé le programme...';
  7.  euler_const:Real=0.577215664901;
  8.  { Une approximation de la constante d'Euler }
  9.  euler_const2:Real=228.0/395.0;

Variables simples

Alors que les constantes sont des identificateurs déclarés et affectés d'une valeur fixe, les variables sont des identificateurs simplement déclarés. Des valeurs leur sont affectées dans le programme principal ou un sous-programme. La syntaxe générale pour déclarer une variable et identifier son type est la suivante :

VAR
   VariableName [[, VariableName...]] : DataType
   .
   .
   .

Quelques exemples de déclaration de variables :

  1. Var
  2.   { Variables déclarées avec un type prédéfini }
  3.  column_index:Word;
  4.  area,circumference:Real;
  5.  message:String;
  6.  input_character:Char;

Une fois qu'une variable est déclarée, le QuickPascal réserve la quantité de mémoire requise pour entreposer les données associées à la variable. La quantité de mémoire réservée est basée sur le type de données de la variable. Par exemple, une variable déclarée avec le type STRING[40] obtient 41 octets de mémoire dont 40 octets sont disponibles pour les données (l'octet restant contient la longueur de la chaîne de caractères) ; une variable de type Integer obtient 2 octets de mémoire.

Une fois qu'une variable est déclarée, vous pouvez lui affecter une valeur. Vous utiliserez souvent l'opérateur d'affectation (:=), ne devant pas être confondu avec l'opérateur d'égalité (=). La valeur assignée peut être une constante, une autre variable ou une expression.

Le programme VARS.PAS montre une simple affectation de variables. Le rayon variable se voit attribuer une valeur par l'entrée de l'utilisateur (la procédure ReadLn). La variable area reçoit la valeur d'une expression à l'aide de l'opérateur d'affectation.

  1. Program Vars;
  2.  { VARS.PAS: Déclaration et utilisation des variables }
  3.  
  4. Var
  5.  radius,area:Real;
  6.  
  7. BEGIN
  8.  Writeln('Entrer rayons');
  9.  ReadLn(Radius);
  10.  Area:=(Pi*(radius*radius));
  11.  WriteLn('Aire du cercle = ', area:8:2);
  12.  WriteLn;
  13. END.

La sortie typique de VARS.PAS ressemble à ceci :

Entrer rayons
12
Aire du cercle = 452.39

Opérateurs Pascal

Les opérateurs vous permettent de manipuler les données. Les opérateurs Pascal sont utilisés pour construire des expressions. Cette section décrit certains des opérateurs disponibles dans QuickPascal. En plus de ceux discutés ici, QuickPascal prend en charge certains opérateurs pour une utilisation avancée, notamment les opérateurs au niveau du bit et les opérateurs d'ensemble.

Types d'opérateurs

Le QuickPascal prend en charge les catégories d'opérateurs suivantes :

Opérateurs arithmétiques

Le tableau suivant répertorie les opérateurs arithmétiques, effectuant la manipulation numérique des types entiers et à virgule flottante. Alors que les opérateurs d'addition (+), de soustraction (-) et de multiplication (*) fonctionnent à la fois avec des entiers et des types à virgule flottante, l'opérateur de division (/) effectue une division à virgule flottante (même si les opérandes sont des entiers), et les opérateurs DIV et MOD ne fonctionnent qu'avec des nombres entiers.

Alors que la plupart des opérateurs prennent deux opérandes, les opérateurs unaires plus et unaires moins fonctionnent avec un seul opérande.

Opérateur Objectif
+ Signe plus unaire
- Signe moins unaire
+ Additionne deux nombres
- Soustrait deux nombres
* Multiplie deux nombres
/ Divise deux nombres à virgule flottante
DIV Divise deux nombres entiers
MOD Renvoie le reste de la division entière

Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour comparer deux opérandes, pouvant être des constantes, des variables, des fonctions ou des expressions. Les opérandes doivent être de types identiques ou compatibles. Quelques opérateurs relationnels utiles sont présentés dans le tableau suivant :

Opérateur Objectif
= Égale à
<> Pas égale à
> Plus grand que
>= Plus grand ou égale à
< Inférieur à
<= Inférieur ou égale à

Opérateurs de chaîne de caractères

Le QuickPascal a un opérateur de chaîne de caractères, l'opérateur (+), pour la concaténation de chaînes et de caractères. D'autres aspects de la manipulation de chaînes de caractères sont exécutés par des procédures et des fonctions prédéfinies.

Opérateur d'adresse

L'opérateur d'adresse de (@) est utilisé pour renvoyer l'adresse des variables, des routines, des paramètres,...

Priorité de l'opérateur

Les opérateurs dans les expressions sont évalués dans l'ordre de leur priorité. Le tableau suivant répertorie les opérateurs QuickPascal selon leur niveau de priorité. Bien que tous les opérateurs présentés dans le tableau ne soient pas abordés dans cette section, ils sont dans le tableau par souci d'exhaustivité :

Niveau de priorité Les opérateurs Classe d'opérateur
1 (haute priorité) @, NOT Unaire
2 *, /, DIV, MOD, AND, SHL, SHR Multiplier
3 +,-, OR, XOR Ajouter
4 (basse priorité) =, <>, <, <=, >, >=, IN Relationnelle

La liste suivante interprète ce tableau et donne des exemples d'utilisation des opérateurs :

Expressions Pascal simples

Les expressions sont une partie spéciale et très importante de tout langage de programmation. Ils sont créés pour évaluer les données de votre programme. Les expressions utilisent les opérateurs décrits dans la section précédente et les opérandes, étant les types de données de votre programme, comme leurs composantes. Le QuickPascal prend en charge les expressions simples et avancées.

Cette page présente brièvement les expressions simples. Chaque type d'expression suit une règle de syntaxe donnant ses composantes et sa syntaxe. Les expressions simples expliquées dans cette page sont :

Expressions arithmétiques

Les expressions arithmétiques combinent des constantes, des nombres, des variables et des fonctions avec des opérateurs arithmétiques. La syntaxe d'une expression est :

{ Constante | Expression ) |
[[ Constante | Expression ] { Opérateur Constante | Expression }

Par exemple :

  1. (_length * width)

Les expressions se combinent avec des constantes ou des variables et des opérateurs relationnels ou d'affectation pour créer des instructions Pascal :

  1. area:=(_length * width)

Dans l'exemple ci-dessus, l'expression _length * width est évaluée, puis le résultat est entreposé dans la variable area. Les expressions sont évaluées en fonction de la priorité des opérateurs. Utiliser des parenthèses pour forcer l'évaluation correcte d'une expression est toujours une bonne idée. Une expression peut contenir des expressions imbriquées, étant des expressions dans des expressions. Des exemples sont présentés ci-dessous :

  1. K:=(1 + 6) DIV (55 - J);
  2. Z:=(2 * X) + (Y / 4);
  3. T:=(((2 * X + 2) * X - 5) * X + 1) * X - 10;

Expressions de chaîne de caractères

Les expressions de chaîne de caractères utilisent l'opérateur (+) pour concaténer des chaînes et des caractères. La règle de syntaxe générale est indiquée ci-dessous :

{Caractère | Chaîne de caractères} + { Caractère | Chaîne de caractères}...

Par exemple :

  1. 'Chien' + 'Maison'; { crée le mot "ChienMaison" }

L'opérateur (+) fonctionne de manière identique à la fonction Concat. La concaténation de chaînes et de caractères ne peut pas créer une chaîne de caractères de plus de 255 caractères.



Dernière mise à jour : Dimanche, le 28 août 2022