Le langage Pascal Objet

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Avant-propos

Le Pascal est un langage fortement typé qui sert de support à Delphi. La version utilisée par Delphi est une version enrichie appelée Pascal Objet qui permet la programmation orientée objet dans l'environnement Windows. Ce chapitre propose une présentation du langage Pascal sous Delphi, mais n'aborde pas la programmation orientée objet.

I. Les règles de base

Toutes les instructions se terminent par un point-virgule. Le point n'est utilisé qu'une seule fois par unité pour en marquer la fin.
On peut écrire plusieurs instructions sur une même ligne.
Un bloc d'instructions est délimité par les instructions Begin et End.

I-A. Les directives standard du Pascal Objet

absolute

far

on

published

assembler

forward

persistent

resident

dynamic

index

private

vitual

export

name

protected

external

near

public

   

I-B. Les mots réservés

and

else

in

or

to

asm

asm

inherited

packed

try

array

except

inline

procedure

type

begin

exports

interface

program

unit

case

file

label

record

until

const

finally

library

repeat

uses

constructor

for

mod

set

var

destructor

function

nil

shl

while

div

goto

not

shr

with

do

if

object

string

xor

downto

implementation

of

then

 

I-C. La syntaxe

Le Pascal ne tient pas compte de la casse (minuscule/majuscule).
Une ligne de code peut être écrite sur plusieurs lignes.
Le séparateur décimal est le point.

I-D. Le style de codage

Voici quelques conseils pour rendre le code plus lisible :

  • placer les paramètres d'une fonction ou procédure sur des lignes séparées ;
  • formater le code source suivant le standard « bonne impression » : indentation avec deux espaces de chaque bloc de code. Ce format est utilisé dans le code source Delphi, les manuels et les exemples d'aide.

I-E. Les commentaires

Exemple :

 
Sélectionnez
{ ceci est un commentaire }
(* un autre commentaire *)
// le reste de la ligne est ignorée (seulement depuis Delphi 2)

Pour obtenir les accolades sur un clavier n'en disposant pas, il faut utiliser : Alt 123 et Alt 125.

Remarque : si une accolade ouverte ou la parenthèse-étoile sont suivies du caractère dollar ($), cela devient une directive de compilation, car les directives de compilation sont des commentaires.

Exemple :

 
Sélectionnez
{$X+ avec un commentaire} // ceci est autorisé

II. Variables et constantes

La déclaration d'une variable se fait dans une clause particulière du programme, identifiée par le mot clé var.

Les contraintes de formation d'un identificateur sont : seuls les 63 premiers caractères sont pris en compte, les caractères accentués sont interdits, la différence minuscule/majuscule n'est pas prise en compte, il doit commencer par une lettre ou un souligné.

Il est possible de déclarer plusieurs variables du même type en une seule ligne, chacune étant séparée par une virgule.

Exemple :

 
Sélectionnez
var
  valeur : integer ;
  fin : boolean ;
  car1, car2 : char ;
begin
  valeur :=10 ;
  fin :=True ;

II-A. Portée d'une variable

Le niveau procédure : les variables sont locales à la procédure ou à la fonction où elles sont déclarées et sont stockées dans le segment de pile.

Le niveau unité : les variables déclarées dans la section var de l'unité sont globales à toutes les procédures et fonctions de l'unité. Elles sont stockées dans le segment de données du programme.

On peut accéder aux variables déclarées dans la section interface d'une unité à partir d'un autre point du programme ou d'un autre programme, en déclarant cette unité dans la section uses de l'unité appelante.

Le Pascal Objet permet l'utilisation d'expressions constantes : l'affectation d'une valeur à une constante s'effectue en même temps que sa déclaration.

 
Sélectionnez
const ident1 : type1 = valeur1;

Exemple :

 
Sélectionnez
const
  tva := 18.6 ;
  initiales : string[2] = 'JM'
  age : byte = 24;

II-B. Les types de données

II-B-1. Les types de données prédéfinis

Il existe trois groupes de types de données : les ordinaux, les réels et les chaines.

II-B-1-a. Les types ordinaux

Les types ordinaux sont fondés sur un concept d'ordre qui permet de faire des comparaisons, d'obtenir la valeur suivante ou précédente et de calculer la plus grande et la plus petite valeur possible.

La liste des types ordinaux est la suivante :

  • Integer, Cardinal, Shortint, SmallInt, Longint, Byte, Word ;
  • Boolean, ByteBool, WordBool, LongBool ;
  • Char, ANSIChar, WideChar.

Type

Intervalle

Longueur

Shortint

-128 .. 127

1 octet (8 bits)

Integer

-32768 .. 32767

2 octets

Longint

-2147483648 .. 2147483647

4 octets

Byte

0 .. 255

1 octet

Word

0 .. 65535

2 octets

Boolean

0, 1 (ou False, True)

1 octet

Char

0 .. 255

1 octet

Byte et Word réprésentent des valeurs non signées.

Integer et Cardinal utilisent la représentation native (2 octets sur plateforme 16 bits, 4 octets sur 32 bits) signée et non signée respectivement. La taille des entiers varie selon le microprocesseur et le système d'exploitation (ex. : un entier est codé avec 2 octets sous Windows 3.x, 4 octets sous Window 95).

Cela peut poser des problèmes lors de la sauvegarde dans un fichier d'un entier sur une plateforme et la relecture sur une autre. Il faut utiliser un type de données qui soit indépendant de la plateforme utilisée (ex. : LongInteger ou SmallInteger). Mais pour une utilisation normale, il est préférable d'utiliser une représentation native.

Les quatre booléens sont utiless pour la programmation avec les API Windows.

Les trois types de caractères sont utilisés pour indiquer des caractères 8 bits (ANSI) ou 16 bits (UniCode).

Char correspond à ANSIChar dans les versions 16 et 32 bits.

Contrairement à Windows NT, Windows 95 n'a qu'un support limité de l'Unicode (le nouvel ensemble de caractères capable de représenter les lettres de chacun des alphabets connus en utilisant 16 bits au lieu de 8).

Le type char est un entier compris entre 0 et 255, interprété comme une lettre selon le code ASCII. Une affectation du type caractère :='q' ; est autorisée. La variable contiendra la valeur ASCII de la lettre sous forme d'entier.

Il existe différentes routines système pour la gestion des types ordinaux :

Routine

Rôle

Dec

Décrémente la variable passée en paramètre par un ou par la valeur du second paramètre éventuel

Inc

Incrémente la variable passée comme paramètre d'un ou de la valeur spécifiée

Odd

Retourne vrai si l'argument est un nombre impair

Pred

Retourne le prédécesseur de l'argument dans l'ordre déterminé par le type de données

Succ

Retourne le successeur

Ord

Retourne un nombre indiquant l'ordre de l'argument dans l'ensemble des valeurs du type de données

Low

Retourne la plus petite valeur du type ordinal passé en paramètre

High

Retoune la plus grande valeur du type ordinal passé en paramètre

II-B-1-b. Les types réels

Le type réel représente des nombres en virgule flottante :

  • Single ;
  • Real ;
  • Double ;
  • Extended ;
  • Comp ;
  • Currency.

Type

Intervalle

Longueur

Nb chiffres pris en compte

Real

2.9 * 10-39 .. 1.7 * 1038

6 octets

11 - 12

Single

1.5 * 10-45 .. 3.4 * 1038

4 octets

7 - 8

Double

5.0 * 10-324 .. 1.7*10328

8 octets

15 - 16

Extended

3.4 * 10-4932 .. 1.1 * 104932

10 octets

19 - 20

Comp

-263+1 .. 263-1

8 octets

19 -20

Comp est en fait un type entier traité comme un type réel permettant de décrire de très grands entiers.

Currency (disponible uniquement depuis Delphi 2) indique un type en virgule flottante avec quatre chiffres décimaux et une représentation 64 bits pour représenter des valeurs monétaires énormes sans perdre le moindre chiffre significatif.

Remarque : Delphi utilise des nombres réels dans les types de données TDateTime pour stocker jour, mois, heures, minutes, secondes et millisecondes dans une seule variable.

II-B-1-c. Les types de données spécifiques à Windows

Ces types de données ne font pas partie du langage Pascal, mais des bibliothèques de Windows.

Thandle représente un Handle et est une redéfinition du type Cardinal. Un Handle est un code interne qui est une référence vers un élément spécifique géré par le système. Il est utile pour appeler une API non supportée par Delphi.

TColorRef représente une référence couleur et est une redéfinition du type LongInt.

II-B-1-d. Le type caractère

Le type char qualifie un caractère alphanumérique. Les données de type char sont notées entre deux apostrophes.

Affectation d'un caractère ASCII à une variable ou une constante de type char : c := #7;

Plusieurs fonctions de l'unité System permettent de manipuler les caractères :

 
Sélectionnez
Chr (X : Byte) : Char;

Obtenir un caractère à partir de son code ASCII

 
Sélectionnez
UpCase (c : Char) : Char;

Convertir un caractère compris entre 'a' et 'z' en majuscule

II-B-1-e. Le type de données Variant

La version 32 bits de Delphi introduit une nouvelle approche pour gérer les variables pour supporter OLE Automation : le type Variant. Ces variables peuvent stocker n'importe quel type de données. Les variants sont vérifiés et calculés en mode exécution.

Exemple :

 
Sélectionnez
var
  v : Variant ;
begin
  v :=10 ;
  v :='Hello' ; ...

Une fois la valeur du variant affectée, on peut la copier vers n'importe quel type de données compatible ou non sachant que dans ce dernier cas, Delphi tente une conversion, si c'est possible.

Les variants stockent à la fois le type d'information et les données et permettent un certain nombre d'opérations à l'exécution. Ceci peut être pratique, mais cela s'avère souvent lent et peu sûr : il faut réserver leur utilisation pour utiliser OLE Automation.

II-B-2. Transtypage et conversion de types

Pour assigner une variable à une autre variable d'un autre type, il faut utiliser le transtypage (Casting).

Exemple :

 
Sélectionnez
var
  n : integer ;
  c : char ;
  b : boolean ;
begin
  n :=Integer(‘X') ;
  c :=Char(n) ;
  b :=Boolean(0) ;

On peut généralement effectuer un transtypage entre deux types de données de même taille.

Il est possible d'utiliser une routine système de conversion de type :

Routine

But

Chr

Convertit un ordinal en caractère

Ord

Convertit la valeur d'un type ordinal en nombre indiquant son ordre

Round

Convertit la valeur d'un type réel en celle d'un type entier, en arrondissant sa valeur

Trunc

Convertit la valeur d'un type réel en celle d'un type entier, en tronquant sa valeur

Frac

Renvoie les décimales d'un réel

Int

Renvoie la partie entière d'un réel

IntToStr

Convertit un nombre en chaine

IntToHex

Convertit un nombre en chaine, avec une représentation hexadecimale

StrToInt

Convertit une chaine en nombre, en affichant une erreur si la chaine est incorrecte

StrToIntDef

Convertit une chaine en nombre, en utilisant une valeur par défaut si la chaine est incorrecte

Val(s : string ; i , j : Integer)

Convertit une chaine s en nombre i. j contient en cas d'erreur la position du premier caractère non converti

Str

Convertit un nombre en chaine, en utilisant des paramètres de formatage

StrPas

Convertit une chaine terminée par un caractère Null en chaine de type Pascal

StrPCopy

Convertit (copie) une chaine de style Pascal en chaine terminée par un caractère Null

StrPLCopy

Convertit (copie) une portion de chaine de style Pascal en une chaine terminée par un Null

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2003 J.M.Doudoux. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.