(3) Créer une fenêtre fille .190 (4) Choisir la création automatique ou non des fiches 190
                   L.                                                                                                                                       TP 12 : Créer un composant .193
1. Créer un nouveau composant ..193 2. Déclaration 193 a) Evénements existants ..193
b)     Evénement ajoutés ..194
c)     Propriétés existantes 194
d)     Propriétés ajoutées ..194
3. Implémentation ..195 4. Gérer son affichage .198 a) Déclaration .198
                            b) Implémentation ..199
5. Gérer les clics .201 a) Déclaration .201
                            b) Implémentation ..202
Delphi et KyliX : des descendants de PascalÂ
L’EDI est constitué de 4 fenêtres (seulement les 2 premières pour des applications consoles) .
Cette partie est elle-même divisée en trois parties :
 ("File Edit Search "), Â
- Les menus : il n'y a pas grand chose à en dire. Je ne vais pas tous les passer en revue, les noms sont en général bien explicite et il y a l'aide si vraiment il y a peu de chose qui sert dans un premier temps. A part "New Application", "Run" (la flèche jaune en icône) et "Program Reset" pour arrêter l'exécution d'un programme qui ne marche pas, c'est à peu près tout Â
2.           La barre d’outils
Des boutons permettent d’accéder aux commandes les plus fréquemment utilisées.
Les composants sont des bouts de programme qui ont déjà été fait pour vous. Exemple Si vous voulez mettre un bouton dans une fenêtre, vous avez juste à prendre un bouton, et le poser sur votre fenêtre sans avoir besoin d'expliquer à l'ordinateur ce qu'est un bouton, comment on clique dessus, ce qu'il se passe graphiquement quand on clique dessus, bref, c'est déjà fait.Â
Les plus couramment utilisés sont ceux de la palette de composants "Standard" : dans l'ordre, on peut y voir un menu déroulant, une liste, un label (de l'écriture, quoi ), une ligne d'édition ("edit box"), une zone de texte ("menu"), un bouton, une case à cocher, etc Tout les composants de base d'une fenêtre classique. Il existe des tonnes de composants, et ils sont souvent compatibles entre Delphi et C++ Builder. Vous en trouverez beaucoup de gratuit sur
Internet, et après, vous les ferez vousmême! Une adresse utile pour trouver de nouveaux composants : Â
Il écrit directement le minimum requis pour votre application et crée seul les fichiers associés. Par contre, le revers de la médaille, il n'est pas conseillé de modifier ce qu'il écrit. Si vous voulez supprimer un bouton par
Delphi et Kilix
exemple, ne l'effacez pas directement dans le code, mais effacez-le graphiquement : le compilateur s'occupera du reste. Nous verrons plus tard comment rajouter son programme Â
C'est la fenêtre que va voir l'utilisateur lorsqu'il lance le programme. Pour l'instant, elle est vide, mais c'est là qu'on peut rajouter les menus, les boutons et tout le reste Vous pouvez, bien entendu, l'agrandir, la réduire, bref, faire tout ce que vous voulez sans taper une ligne de code Â
C'est dans cette partie qu'on donne les caractéristiques des composants que l'on place sur sa fenêtre ou les caractéristiques de la fenêtre générale. Ici, on peut voir qu'il s'agit des caractéristiques générales de la fenêtre car on voit "Form1: TForm1". "Form1" signifie qu'on regarde les caractéristiques d'un composant de la fenêtre "Form1" (il peut en effet y avoir Form2, Form3, ou même canard ou poisson, puisque vous donnez le nom que vous voulez à chaque fenêtre ) et "TForm1" désigne la fenêtre en général. Même s'il est possible de changer le nom des composants ou des fenêtres, je vous conseille de laisser les noms par défaut si vous n'avez pas l'intention de faire un programme énorme avec 15 fenêtres différentes.Â
Remarque : quand je parle de nom de la fenêtre, ne confondez pas avec ce qu'il y aura d'écrit comme titre de fenêtre. Je parle du nom de la fenêtre pour le programme ("name" dans les "properties") et non pas du titre qui s'affiche à l'écran ("caption" dans les "properties"). Ainsi, si vous placez un bouton sur votre fenêtre, vous changerez ce qu'il y a d'écrit sur le bouton en changeant le "Button1" de
"caption" par
"quitter" ou "enregistrer" ou ce que vous voulez, mais le bouton s'appellera toujours "Button1" pour le
seul l'affichage changera lors de l'exécution Essayez de changer "caption" (la partie sélectionnée sur l'image) : le nom de la fenêtre change Â
Il ne faut pas hésiter à consulter l’aide Delphi pour obtenir tous les compléments nécessaires : en particulier les fonctions ne sont que décrites et on ne donne pas la liste des paramètres à employer, car ceci son décrits dans l’aide en utilisant la touche F1 ou l’index ou rechercher .
Cette structure ressemble fort à celle des programmes des langages de haut niveau tels : ADA, C++,Visual basic, Java …
Le programme
Program <nom_prog>;
Uses <liste des unités séparées par des virgules> ;
Déclaration des objets et des outils du programme
<Déclaration des constantes>
<Déclaration des types>
<Déclaration des variables>
Déclaration des procédures
Procedure <nom_proc>( <liste des Paramètres Formels avec leur type>) ;
Déclaration des objets et des outils de la procédure
< Structure identique à la déclaration des objets et des outils
du programme >
Corps de la procédure
<Instructions> End ;
…
Déclaration des autres procédures et des autres fonctions
…
Déclaration des fonctions
Function<nom_fonc>(<liste des P.F. avec leur type>) : <type du résultat> ;
Déclaration des objets et des outils
< Structure identique à la déclaration des objets et des outils du programme >
Corps de la fonction <Instructions> result := <le résultat de la fonction> End ;
Corps du programme
<Instructions> END .
Le nom du programme doit être le même que le nom du fichier qui le contient.
Ces parties encadrées sont facultatives
Il n’est pas impératif de respecter l’ordre indiqué ci-contre
Remarquons
que la structure des déclarations des outils et des objets (cadres doubles) est identique à la structure qui les contient : un peu à la manière des « poupées russes » qui s’ouvrent en 2 parties et qui contiennent des « poupées russes » qui s’ouvrent en 2 parties et qui contiennent …
A la différence des « poupées russes », cette structure de déclarations peut contenir récursivement non pas une mais plusieurs structures contiguës.
Une fonction renvoie un résultat par le biais de résult
Cette partie
aussi est facultative
En supprimant les parties facultatives, il reste le programme le plus simple que l’on puisse écrire.
Il s’agit d’une application console, la plus simple possible que vous pouvez compiler et exécuter depuis la ligne de commande
program Kedal; {$APPTYPE CONSOLE} | déclare un programme appelé Kedal indique au compilateur que c'est une application console qui doit être exécutée depuis la ligne de commande déclaration des constantes, des types, des classes, des variables, des | |||
begin end. | procédures et des fonctions (ici aucune) début de l’exécution du programme liste des instructions du programme (ici vide) fin de l’exécution du programme | |||
Remarques :
Si Delphi est installé et si votre chemin d'accès contient le répertoire Delphi\Bin (où se trouvent les fichiers et ), vous pouvez saisir ce programme dans un fichier appelé ou mieux à l’aide d’un éditeur texte (comme le bloc-notes de windows) puis le compiler en saisissant, dans une fenêtre dos, la ligne (il peut être nécessaire d’ajouter les chemins):Â
DCC32 Kedal sur la ligne de commande qui produira l'exécutable résultant () dont la taille est d’environ 37 ko. On peut l’exécuter en tapant sur la ligne de commande :Â
Kedal
Si l‘on double-clique sur  dans la fenêtre de l’explorateur, une fenêtre console va s’ouvrir et se refermer immédiatement puisque ce programme ne fait rien (mais il le fait bien) dans la mesure où il ne contient aucune instruction. Ainsi, on peut « bloquer » l’exécution en ajoutant l’instruction readln qui attend que l’utilisateur ait tapé sur des touches du clavier (éventuellement aucune) puis sur la touche entrée. Il est d’ailleurs possible, avec readln(x), de mémoriser dans une variable x par exemple, ce que l’utilisateur a tapé. On aura déclaré x avant le begin. On préviendra l’utilisateur auparavant grâce à un message au moyen de writeln(‘Appuyez sur entrée’). Tout ceci donne : program Kedal; {$APPTYPE CONSOLE} begin
 writeln(‘Appuyez sur entrée’) ;  readln end.
Il est possible, selon la nature des applications, d’utiliser ou non certaines bibliothèques qui contiennent fonctions, procédures et autres objets divers et variés. Le noyau se situe dans une unité nommée system qu’il est inutile de déclarer :
on aurait très bien pu mettre :
 uses system ;  dans le programme précédent, ça n’aurait rien changé).
Writeln et readln font partie du noyau de delphi, alors que le programme : program Kedal;
{$APPTYPE CONSOLE} uses   dialogs; begin
 ShowMessage('Cliquez pour quitter’) ; end.
Le programme précédent va, en plus de l’application console, ouvrir une boîte avec un message et un bouton. Lorsque l’on clique sur le bouton, on ferme la boite à message ce qui a pour effet de terminer l’application puisque ShowMessage est la dernière instruction du programme.
L'exemple suivant propose un programme constitué de deux fichiers : un fichier projet et un fichier unité. Le fichier projet, que vous pouvez enregistrer sous le nom , a la forme suivante :
program Kedal; {$APPTYPE CONSOLE} uses Unitstop; begin  stop end. | unit Unitstop; interface procedure stop; implementation procedure stop; begin  writeln(‘Appuyez sur entrée’) ;  readln end; end. |
La première ligne déclare un programme appelé Kedal qui, encore une fois, est une application console. La clause uses
UnitStop; spécifie au compilateur que Kedal inclut une unité appelée UnitStop. Enfin le programme appelle la procédure Stop. Mais où se trouve la procédure Stop ? Elle est définie dans UnitStop. Le code source de UnitStop (colonne de droite) que vous devez enregistrer dans un fichier appelé
Vous pouvez maintenant compiler Kedal depuis la ligne de commande en saisissant :
DCC32 KEDAL
Il n'est pas nécessaire d'inclure UnitStop comme argument de la ligne de commande. Quand le compilateur traite le fichier
, il recherche automatiquement les fichiers unité dont dépend le programme Kedal. L'exécutable résultant
() fait la même chose que le premier exemple : Rien de plus que d’afficher un message et d’attendre que l’utilisateur appuie sur entrée.
Utiliser des unités o évite au compilateur de recompiler une partie de code si le programmeur n’a pas modifié l’unité correspondante o permet au programmeur de fournir un fichier .DCU (Unité Delphi Compilée) et un mode d’emploi rendant cette unité parfaitement utilisable tout en protégeant son code.
En général, on regroupe tous ces fichiers (il peut y avoir plus d’une unité, et même d’autres fichiers ) dans un répertoire le fichier dpr en faisant partie lui aussi. On y trouve notamment :Â
Extension du fichier | Description et Commentaires |
DPR | (Delphi PRoject) Contient l'unité principale du projet |
PAS | (PAScal) Contient une unité écrite en Pascal. Peut avoir un .DFM correspondant |
DFM | (Delphi ForM : fiche Delphi) Contient une fiche (une fenêtre). Le .PAS correspondant contient toutes les informations relatives au fonctionnement de cette fiche, tandis que le .DFM contient la structure de la fiche (ce qu'elle contient, sa taille, sa position, …). Sous Delphi 5, les .DFM deviennent des fichiers texte qu'il est possible de visualiser et de modifier. La même manipulation est plus délicate mais possible sous Delphi 2 à 4. |
DCU | (Delphi Compiled Unit : Unité compilée Delphi) Forme compilée et combinée d'un .PAS et d'un .DFM optionnel |
~??? | |
EXE | Fichier exécutable de l'application. Ce fichier est le résultat final de la compilation et fonctionne sous Windows exclusivement. Pour distribuer le logiciel, copier ce fichier est souvent suffisant. |
RES | (RESsource) Fichier contenant les ressources de l'application, tel son icône. Ce fichier peut être édité avec l'éditeur d'images de Delphi. Ces notions seront abordées plus loin dans ce guide. |
DOF DSK CFG | Fichiers d'options : suivant les versions de Delphi, ces fichiers contiennent les options du projet, les options d'affichage de Delphi pour ce projet, |
Les commentaires se placent entre accolades ou parenthèses et étoiles ou derrière 2 slaches:
{ceci est un commentaire}
(*ceci est un autre commentaire*)
// tout ce qui suit et jusqu’à la fin de ligne est aussi un commentaire
Comme les commentaires, elles se mettent entre { }, mais la première accolade est suivie de $. Ce $ est lui-même immédiatement suivi de la directive. Ce ne sont pas des instructions du langage, elles servent à donner des instructions au compilateur, par exemple:
• Pour mettre au point un programme, on peut avoir besoin d’ajouter des instructions que l’on effacera dans la version définitive.
{$Define test}
{$IFDEF test}
 <Les instructions qui seront utilisées uniquement pendant la phase de mise au point>
{$ENDIF}
On compile le programme de cette manière pendant les tests, puis il suffit d’insérer un espace avant le $
{ $Define test}
pour transformer cette ligne en commentaire et de ce fait inhiber la définition test et par conséquent dé valider les instructions comprises entre le {$IFDEF test} et {$ENDIF}
• Pour écrire des programmes portables sous Windows et Linux :
uses
{$IFDEF WIN32}
{$ENDIF} {$IFDEF LINUX}
 QGraphics, QControls, QForms, QDialogs, QMenus, QStdCtrls, QButtons, QExtCtrls, QComCtrls,
{$ENDIF}
 SysUtils, Classes;
WIN32 ou LINUX sont automatiquement définis selon le Système d’Exploitation sous lequel on compile. Dans l’exemple précédent, les bibliothèques correspondant au bon S.E. seront utilisées. SysUtils et Classes étant communes aux 2 S.E.
• Pour forcer le compilateur à effectuer ou non certaines vérifications. Ce sont des directives bascules. Par exemple:
{$B+} Force l’évaluation complète des booléens alors que {$B-} effectue l’évaluation partielle (Voir le type booléen) {$R+} Vérifie le non-débordement des tableaux. Alors que {$R-} permet de définir un tableau de 5 cellules et l’écriture d’une valeur dans la 6éme ne déclenchera pas d’erreur (Mais aura pour conséquence d’écraser peut-être d’autres variables en mémoire). Il est clair que la vérification du non-débordement une sécurité dans le déroulement du programme mais aussi génère des instructions machines supplémentaires et donc ralentissent le déroulement du programme. On peut cumules ces directives bascules et même les commenter:
{$B+,R-,S-}
{$R- Désactive la vérification des limites}
• On peut aussi utiliser ces directives dans la ligne de commande: (Ne pas oublier le /): DCC32 MonProg /$R-,I-,V-,U+
Pour les autres directives comme $I, $L etc., on se référera à l’aide de Delphi.
En utilisant L’EDI, Ces directives sont générées automatiquement et rassemblées dans un fichier DOF, DSK CFGÂ
Un identificateur commence obligatoirement par une lettre ou un trait-bas suivi de lettres, chiffres ou trait-bas à l’exclusion de tout autre caractère. Les caractères accentués sont aussi interdits. Comme en ADA et contrairement à C et Java, il n’y a pas de différence entre majuscule et minuscules.
où identificateur1 qualifie identificateur2. Si, par exemple, deux unités déclarent une variable appelée MaVar, vous pouvez désigner MaVar de Unit2 en écrivant : Unit2.MaVar
Il est possible de chaîner les qualificateurs. Par exemple :
Form1.Button1.Click
Appelle la méthode Click de Button1 dans Form1.
Si vous ne qualifiez pas un identificateur, son interprétation est déterminée par les règles de portée décrites dans Blocs et portée.
On utilise le symbole := pour donner une valeur à une variable. Par exemple:
a:=5; b:=‘Bonjour’;
Ou encore Pour permuter les valeurs des variables x et y :Â
t:=x; x:=y; y:=t;
F.     Séparateur d’instruction.
Contrairement à d’autres langages (C, ADA, etc.) le Point-virgule n’est pas une fin d’instruction mais un séparateur. C’est à dire qu’il ne se place pas systématiquement à la fin d’une instruction, mais entre 2 instructions. En particulier il n’y a pas lieu de mettre un point-virgule avant un end même si le compilateur le tolère alors que le point-virgule devant un else provoque une erreur de compilation
On utilise TypeConst et Var. ainsi que les symboles : et = (pas le symbole := )
Const
                          lgmax=100;
 nl = #10{$IfNDef LINUX}#13{$end if} ; //Définition des caractères de contrôles permettant un saut de ligne
Type
               Ttableau = array[1..lgmax] of integer;          // tableau de lgmax (=100) entiersÂ
           Tchn32 = string[32];                          // chaine d’au plus 32 caractères
Var      i : integer;       x : real;   c : string[12];  c_32 : Tchn32;
           tb1 : array[1..5] ofstring[8];   tb2 : Ttableau;
Il peut y avoir des déclarations de variables de types et de constantes en plusieurs endroits du programme Dans la mesure où l’utilisation ne peut se faire qu’après déclaration
Les routines qui suivent sont données en vrac et correspondent à la version 5 de Delphi : Il convient de vérifier dans l’aide :
o   si elles existent dans la version utilisée
o   de quelle unité elles font partie (les principales font partie de l’unité system –unité par défaut- mais pas toutes !) o quels sont les paramètres utilisés ainsi que leur type
Un type scalaire définit un ensemble ordonné de valeurs dont chaque valeur, sauf la première, a un prédécesseur unique et dont chaque valeur, sauf la dernière, a un successeur unique. Chaque valeur a un rang qui détermine l'ordre du type. Pour les types entiers, le rang d'une valeur est la valeur même ; pour tous les autres types scalaires à l'exception des intervalles, la première valeur a le rang 0, la valeur suivante a le rang 1, etc. Si une valeur a le rang n, son prédécesseur a le rang n – 1 et son successeur a le rang n + 1.
Dec, procédure             Décrémente une variable de 1 ou de N
Inc, procédure              Incrémente X de 1 ou de N
Odd, fonction               Renvoie True si argument est un nombre impair
Ord, fonction                Renvoie la valeur scalaire d'une expression de type scalaire
Pred, fonction      Renvoie le prédécesseur de l'argument Succ, fonction                Renvoie le successeur de l'argument.
High, fonction               Renvoie la plus grande valeur du type
Low, fonction               Renvoie la plus petite valeur du type
@, not                                                                                       première (maximum)
*, /, div, Mod, and, shl, shr, as                                             seconde
+, –, or, xor                                                                               troisième
=, <>, <, >, <=, >=, in, is                                                       quatrième (minimum)
Un opérateur de priorité plus élevée est évalué avant un opérateur de priorité plus basse, les opérateurs de même priorité étant évalués à partir de la gauche
a) | Définition | ||||
Type | Étendue | Format | |||
Boolean | True et False | 1 octet (8 bits) | |||
ByteBool | True et False | 1 octet | |||
WordBool | True et False | 2 octets | |||
LongBool Quelques différences : | True et False | 4 octets | |||
Boolean | ByteBool, WordBool, LongBool | ||||
False < True | False <> True | ||||
Ord(False) = 0 | Ord(False) = 0 | ||||
Ord(True) = 1 | Ord(True) <> 0 | ||||
Succ(False) = True | Succ(False) = True | ||||
Pred(True) = False | Pred(False) = True | ||||
b) | Opérateurs | ||||
Opérateur                      Opération |                   Types d'opérande        Types du résultat | Exemple | |||
not                                  négation                         booléen                         Boolean | not (C in MySet) | Done and (Total > 0) | |||
or                                    disjonction                    booléen                         Boolean | A or B | ||||
xor                                   disjonction exclusive booléen                          Boolean | A xor B |
Table de vérité :
A | B | not A | A or B | A and B | A xor B |
False | False | True | False | False | False |
False | True | True | True | False | True |
True | False | False | True | False | True |
True | True | False | True | True | False |
Retour sur la directive de compilation $B+ :
Trueor X donne True quelque soit la valeur de X, de même Falseand X donne False quelque soit la valeur de X Dans une expression booléenne faisant intervenir un or, lorsque le premier opérande vaut True, il est inutile de calculer la valeur du second. Ceci pose un problème lorsque celui-ci est un prédicat (fonction à résultat booléen) et que cette fonction produit un effet de bord ( Modification de l’environnement global) La seconde évaluation n’étant pas faite, l’effet de bord n’a pas lieu. Il en va de même lorsque le premier opérande d’un and vaut faux
c)           Procédure et fonctions
Ce sont les routines ordinales valables pour tous les types scalaires
Les opérateurs relationnels sont utilisés pour comparer deux opérandes. Les opérateurs =, <>, <= et >= s'appliquent également aux ensembles (voir Opérateurs d'ensembles) ; = et <> s'appliquent également aux pointeurs (voir Opérateurs de pointeurs).
Opérateur | Opération | Types d'opérande | Type              du résultat | Exemple |
= | égalité | Boolean | I = Max | |
<> | différence | simple, classe, référence de classe, interface, chaîne, chaîne compactée | Boolean | X <> Y |
< | inférieur à | simple, chaîne, chaîne compactée, PChar | Boolean | X < Y |
> | supérieur à | simple, chaîne, chaîne compactée, PChar | Boolean | Len > 0 |
<= | inférieur ou égal à | simple, chaîne, chaîne compactée, PChar | Boolean | Cnt <= I |
>= | Supérieur ou égal à  | simple, chaîne, chaîne compactée, PChar | Boolean | I >= 1 |
in | Membre de | opérande              gauche: tout        type                ordinal  T, opérande droit: ensemble de base compatible avec T. | Boolean | 5 in [3..9]; 'K' in['a'..'z']; |
Dans la plupart des cas simples, la comparaison est évidente. Par exemple I = J vaut True uniquement si I et J ont la même valeur, sinon I>J vaut True. Les règles suivantes s'appliquent aux opérateurs de comparaison :
Les opérandes doivent être de types compatibles, sauf pour un réel et un entier qui peuvent être comparés.
Selon la règle des priorités des opérateurs :
A>B or C<=D provoquera une erreur car B or C sera évalué avant toute chose : Il faut donc systématiquement mettre de parenthèses pour modifier l’ordre d’évaluation:
(A>B) or (C<=D)
5. Â Â Â Â Â Â Â Â Â Â Le type entierÂ
Type | Étendue | Format |
Integer | –2147483648..2147483647 | 32 bits signé |
Cardinal | 0..4294967295 | 32 bits non signé |
Shortint | –128..127 | 8 bits signé |
Smallint | –32768..32767 | 16 bits signé |
Longint | –2147483648..2147483647 | 32 bits signé |
Int64 | –2^63..2^63–1 | 64 bits signé |
Byte | 0..255 | 8 bits non signé |
Word | 0..65535 | |
Longword                                               0..4294967295                                          32 bits non signé |
Par défaut les entiers sont exprimés en décimal , mais il est possible de manipuler des nombres hexadécimaux :
$FF vaut 255
En plus des opérateurs relationnels définis plus haut, les opérateurs arithmétiques suivants attendent des opérandes réels ou entiers : +, –, *, /, div et Mod.
Opérateur | Opération                         Types d'opérande | Type du résultat | Exemple | |
+ | addition                            entier, réel | entier, réel | X + Y | |
– | soustraction                     entier, réel | entier, réel | Result - 1 | |
* | multiplication                  entier, réel | entier, réel | P * InterestRate | |
/ | division réelle                  entier, réel | réel | X / 2 | |
div | division entière               entier | entier | Total div UnitSize | |
Mod | reste                                  entier | entier | Y Mod 6 | |
+ (unaire) | signe identité                   entier, réel | entier, réel | +7 | |
– (unaire) | signe négation                 entier, réel | entier, réel | -X | |
not | négation bit à bit            entier | entier | ||
and | et bit à bit                         entier | entier | ||
or | ou bit à bit                        entier | entier | ||
xor | ou exclusif bit à bit        entier | entier | ||
shl | rotation des bits vers entier la gauche | entier | rotation des bits vers entier | entier |
la droite Les règles suivantes s'appliquent aux opérateurs arithmétiques. |
La valeur de x/y est de type Extended (voir type réel), indépendamment du type de x et y. Pour les autres opérateurs, le résultat est de type Extended dès qu'au moins un des opérandes est de type réel ; sinon le résultat est de type Int64 quand au moins un des opérandes est de type Int64 ; sinon le résultat est de type Integer. Si le type d'un opérande est un sousintervalle d'un type entier, il est traité comme é
            La valeur de x div y est la valeur de x/y arrondi vers le bas à l'entier le plus proche.
A | B | not A | A or B | A and B | A xor B |
0 | 0 | 1 | 0 | 0 | 0 |
0 | 1 | 1 | 1 | 0 | 1 |
1 | 0 | 0 | 1 | 0 | 1 |
1 | 1 | 0 | 1 | 1 | 0 |
L'opérateur Mod renvoie le reste obtenu par la division de ses opérandes. En d'autres termes : x Mod y = x – (x div y) * y. Il y a une erreur d'exécution si y vaut zéro dans une expression de la forme x/y, x div y ou x Mod y. shl produit un décalage des bits de l’entier vers la gauche et ajoute un 0 donc à multiplier par 10 en binaire (c’est à dire2 en décimal).
Shr produit un décalage dans l’autre sens c’est à dire diviser par 2.
n shl p (décalage de p bits a gauche avec introduction de p 0) donne n*2p.
Fonction                abs        Valeur absolue Hi           poids fort Lo                poids faible odd  test de parité Sqr        carré du nombre
On remarquera que la fonction puissance n’est pas définie en standard : il faut utiliser l’unité Math ou la fonction
IntPower est définie
compte tenu de la priorité des opérateurs:
5+ 3*2 donne 11
56 or 20 donne 60
en binaire 56 s’écrit 00111000 et 20 s’écrit 00010100
              56 shl 2 donne 224         décaler 00111000 de 2 rangs à gauche donne 11100000
6.          Le type caractèreÂ
Les types de caractère fondamentaux sont AnsiChar et WideChar. Les valeurs AnsiChar sont des caractères sur un octet (8 bits) ordonnés selon le jeu de caractères ANSI étendu. Les valeurs WideChar sont des caractères sur un mot (16 bits) ordonnés selon le jeu de caractères Unicode. Les 256 premiers caractères Unicode correspondent aux caractères ANSI.
Le type de caractère générique Char est équivalent à AnsiChar. Comme l'implémentation de Char est susceptible de changer, il est judicieux d'utiliser la fonction standard SizeOf plutôt qu'une constante codée en dur dans les programmes qui doivent gérer des caractères de tailles différentes.
Une constante chaîne de longueur 1, comme 'A', peut désigner une valeur caractère. La fonction prédéfinie Chr renvoie la valeur caractère pour tout entier dans l'étendue de AnsiChar ou de WideChar ; ainsi, Chr(65) renvoie la lettre (code ASCII
65). un entier préfixé par # donne le caractère dont le code ASCII est cet entier.
b)           OpérateursÂ
Les opérateurs relationnels
Les routines ordinales etÂ
Fonction | |
chr | donne le caractère correspondant au code ASCII |
upcase | convertit un caractère en majuscule si elle existe et le conserve sinon. Attention aux caractères accentués |
Les valeurs de caractère, comme les entiers, bouclent quand elles sont décrémentées ou incrémentées au-delà du début ou de la fin de leur étendue (à moins que la vérification des limites ne soit activée). Ainsi, une fois le code suivant exécuté
var lettre : char;
begin
..lettre:=High(lettre); // est équivalent à la ligne précédente  inc(lettre,66); // caractère dont le code Ascii est 65 c’est à dire A
 lettre := #65; // est équivalent à  lettre := chr(65)
pred(‘D’) vaut C                   ‘C’<>‘c’ vaut True     Chr(66) vaut B           ord(‘B’) vaut 66
7.           Le type énuméréÂ
Un type énuméré définit une collection ordonnée de valeurs simplement en énumérant les identificateurs désignant ces valeurs. Les valeurs n'ont pas de signification propre et leur rang suit l'ordre d'énumération des identificateurs. Pour déclarer un type énuméré, utilisez la syntaxe suivante : type nomType = (val1, , valn) où nomType et les val sont des identificateurs valides.
Type
           Tcartes = (_7,_8,_9,_10,Valet,Dame,Roi,As); // Remarquons le trait_bas pour le respect des règles sur les identifiants
var   i:= ord(carte);
                                                                  carte : Tcartes;   writeln(i,’ ‘,_9<Dame,’ ‘,ord(_7)); // affichera
                                           i : byte;2 TRUE 0
BEGIN  readln; // la tentative d’afficher carte
 carte := _8; provoquerait une erreur   inc(carte,2); END.   carte := pred(carte); 8.  Le type intervalle
Un type intervalle représente un sous-ensemble de valeurs d'un autre type (appelé le type de base). Toute construction de la forme , où Bas et Haut sont des expressions constantes du même type scalaire, Bas étant inférieur à Haut, identifie un type intervalle qui inclut toutes les valeurs comprises entre Bas et Haut.
Type
 Tminuscules = ‘a’..’z’;
 Tcartes = (_7,_8,_9,_10,Valet,Dame,Roi,As); // C’est un type énuméré pour définir le type suivant  Tfigures = ;  // qui lui est du type intervalle
Un type réel définit un ensemble de nombres pouvant être représentés par une notation à virgule flottante. Le tableau suivant donne l'étendue et le format de stockage des types réels fondamentaux.
Type             Étendue                                                                                           Chiffres significatifs   Taille en octets
Real48        2.9 x 10^–39 .. 1.7 x 10^38                                                           11–12                             6
Single    1.5 x 10^–45 .. 3.4 x 10^38              7–8        4 Double              5.0 x 10^–324 .. 1.7 x 10^308                15–16    8 Real   5.0 x 10^–324 .. 1.7 x 10^308          15–16    8
Extended   3.6 x 10^–4951 .. 1.1 x 10^4932                                                   19–20                             10
Comp    –2^63+1 .. 2^63 –1            19–20    8 Currency           –922337203685477.5808.. 922337203685477.5807                19–20    8
Le type générique Real est équivalent, dans son implémentation actuelle, au type Double.
Il est possible de stocker un entier dans un réel mais pas l’inverse.
2.            OpérateursÂ
Voir les opérateurs sur les entiers.
Vérifier dans l’aide s’il est nécessaire d’utiliser l’unité Math
*Abs, fonction Ceil, fonction Exp, fonction Floor, fonction Frac, fonction Frexp, procédure | Renvoie une valeur absolue Arrondit des variables vers l'infini positif Renvoie la valeur exponentielle de X Arrondit les variables vers l'infini négatif Renvoie la partie décimale d'un réel Sépare la mantisse et l'exposant de X | Log2, fonction LogN, fonction Max, fonction Min, fonction Pi, fonction Poly, fonction | Calcule le logarithme en base 2 Calcule le logarithme en base N Renvoie la plus élevée des valeurs parmi deux valeurs numériques Renvoie la plus petite de deux valeurs numériques Renvoie 3.1415926535897932385 Évalue une polynomiale uniforme |
Int, fonction IntPower, fonction Ldexp, fonction Ln, fonction LnXP1, fonction Log10, fonction | Renvoie la partie entière d'un nombre réel Calcule la puissance entière d'une valeur de base Calcule X * (2**P) Renvoie le logarithme naturel d'une expression réelle Renvoie le logarithme naturel de (X+1) Calcule le logarithme en base 10 | Power, fonction Round, fonction Sqr, fonction Sqrt, fonction  Trunc, fonction | d'une variable à la valeur X Élève Base à n'importe quelle puissance Renvoie la valeur de X arrondi au plus proche entier Renvoie le carré d'un nombre Renvoie la racine carrée de X Tronque un réel en entier. |
              RandG, fonction                        Génère des nombres aléatoires avec une distribution gaussienne
              Random, fonction                     Génère des nombres aléatoires dans une étendue spécifiée
              Randomize, procédure           Initialise le générateur interne de nombre aléatoire avec une valeur aléatoire.
5. Â Â Â Â Â Â Â Â Â Â Exemples
7E-2                  signifie      7 x 10-2 et  12.25e+6 et 12.25e6 signifient 12.25 x 106.
Une chaîne représente une suite de caractères. Le Pascal Objet gère les types de chaîne prédéfinis suivants.
Type                   Longueur maximum           Mémoire nécessaire               Utilisation
              ShortString        255 caractères                     de 2 à 256 octets                     Compatibilité ascendante
               AnsiString         ~2^31 caractères                de 4 octets à 2Go                    Caractère sur 8 bits (ANSI)
              WideString        ~2^30 caractères                de 4 octets à 2Go                     Caractères Unicode;Â
Le mot réservé string fonctionne comme un identificateur de type générique. Dans l'état par défaut {$H+}, le compilateur interprète string (quand il apparaît sans être suivi d'un crochet ouvrant) comme désignant AnsiString. Utilisez la directive {$H–} pour que string soit interprété comme désignant ShortString.
AdjustLineBreaks, fonction | Standardise les caractères de fin de ligne en paires CR/LF | ||||
AnsiCompareStr, fonction | |||||
AnsiCompareText, fonction | Compare deux chaînes basées sur le pilote de langue de Windows (les différences de majuscules/minuscules ne sont pas détectées) | ||||
AnsiExtractQuotedStr, fonction | Convertit une chaîne guillemetée en une chaîne non guillemetée | ||||
AnsiLowerCase, fonction | Renvoie une chaîne, qui est une copie de la chaîne donnée convertie en minuscules | ||||
AnsiPos, fonction | Trouve la position d'une sous-chaîne dans une chaîne | ||||
AnsiQuotedStr, fonction | Renvoie la version guillemetée d'une chaîne | ||||
AnsiSameStr, fonction | Compare deux chaînes basées sur le pilote de langue de Windows (les différences de majuscules/minuscules sont détectées) | ||||
AnsiSameText, fonction | Compare deux chaînes basées sur le pilote de langue de Windows (les différences de majuscules/minuscules ne sont pas détectées) | ||||
AnsiUpperCase, fonction | Convertit une chaîne en majuscules | ||||
CompareStr, fonction | Compare des chaînes en tenant compte de la distinction minuscules/majuscules | ||||
CompareText, fonction | Compare des chaînes par valeur scalaire sans tenir compte de la distinction minuscules/majuscules | ||||
Concat, fonction | Concatène deux chaînes ou plus | ||||
Copy, fonction | Renvoie une sous-chaîne d'une chaîne ou un segment de tableau dynamique | ||||
Delete, procédure | Supprime une sous-chaîne d'une chaîne s | ||||
Insert, procédure | Insère une sous-chaîne dans une chaîne commençant au point spécifié | ||||
IsDelimiter, fonction | Indique si un caractère spécifié dans une chaîne correspond à un ensemble de délimiteurs | ||||
LastDelimiter, fonction | Renvoie l'index d'octet dans S du dernier caractère identique au caractère spécifié par la chaîne AnsiString Delimiters | ||||
Length, fonction | Renvoie le nombre de caractères dans une chaîne ou d'éléments dans un tableau | ||||
LowerCase, fonction | Convertit une chaîne ASCII en minuscules | Déclare un pointeur sur EmptyStr | |||
Pos, fonction | Renvoie la valeur d'index du premier caractère dans une sous-chaîne spécifiée qui se trouve dans une chaîne | ||||
QuotedStr, fonction | Renvoie la version guillemetée d'une chaîne | ||||
SetLength, procédure | Définit la taille d'une variable chaîne ou tableau dynamique | ||||
SetString, procédure | Définit le contenu et la taille d'une chaîne | ||||
Str, procédure | Formate une chaîne et la renvoie dans une variable | ||||
StringOfChar, fonction | Renvoie une chaîne avec le nombre de caractères spécifié | ||||
StringReplace, fonction | Renvoie une chaîne AnsiString dans laquelle des occurrences d'une sous-chaîne sont remplacées par une autre sous-chaîne | ||||
Trim, fonction | Supprime les caractères de contrôle et les espaces se trouvant en début et en fin de chaîne | ||||
TrimLeft, fonction | Supprime les caractères de contrôle et les espaces se trouvant en début de chaîne | ||||
TrimRight, fonction | Supprime les caractères de contrôle et les espaces se trouvant en fin de chaîne | ||||
UpperCase, fonction | Revoie une copie d'une chaîne en majuscules | ||||
Val, procédure | Convertit une chaîne en sa représentation numérique | ||||
WrapText, fonction | Décompose une chaîne en plusieurs lignes quand sa longueur se rapproche d'une taille donnée. | ||||
Opérateur      Opération              Types d'opérande                                                  Type du résultat       Exemple
+                      concaténation      chaîne, chaîne compactée, caractère                   chaîne                      Â
Les règles suivantes s'appliquent à la concaténation de chaîne :
L'opérateur + concatène deux chaînes.
Les opérandes pour l'opérateur + peuvent être des chaînes, des chaînes compactées (des tableaux compactés de type Char) ou des caractères. Cependant, si un opérande est de type WideChar, l'autre opérande doit être une chaîne longue.
 Le résultat d'une opération + est compatible avec tout type de chaîne. Cependant, si les opérandes sont tous deux des chaînes courtes ou des caractères, et si leur longueur cumulée est supérieure à 255, le résultat est tronqué aux 255 premiers caractères.
4.            Les chaînes courtesÂ
Une variable de type chaîne ShortString est une séquence de caractères de longueur variable au cours de l'exécution et une taille prédéfinie entre 1et 255. On peut préciser la longueur maxi entre crochets.
Type Tch32 = string[32]; // ou Tch32 = ShortString[32]
Var ch : Tch32 ; // Réserve 33 octets : ch[i] fait référence au ièmecaractère de la chaîne. ch[0] fait référence à sa longueur.
ch:=#98#111#110#106’o’#117#114; // représente la chaîne ‘bonjour ’ ch := ‘c’’est une chaîne’ // Lorsqu’une chaîne comporte une apostrophe, on doit la doubler.
5.           Les chaînes longues et étendues
Les types AnsiString (caractères Ansi 8 bits) et WideString (caractères Unicodes 16 bits) ou string sans crochets sont des chaînes allouées dynamiquement. (Ce sont en réalité des pointeurs.) La gestion de la mémoire est entièrement automatique. A priori les différents types de chaînes ne semblent pas présenter de grosses différences : c’est illusoire, nous y reviendrons lors de l’étude du type fichier.
Var Ch : string; // ou Ch : AnsiString;
Ch:=#98#111#110#106’o’#117#114; // représente la chaîne ‘bonjour ’
6.           Les chaînes AZTÂ
Pour des raisons de compatibilité avec d’autres langages (tel le C et C++), une chaîne à zéro terminal est un tableau de caractères d'indice de base zéro et terminé par NULL (#0). Comme le tableau n'a pas d'indicateur de longueur, le premier caractère NULL indique la fin de la chaîne.
 Le type Pchar est en réalité un pointeur Pour plus de précision voir l’aide Delphi et le type pointeur ci-après.
StrAlloc | Alloue sur le tas un tampon de caractères d'une taille donnée. | |
StrBufSize | Renvoie la taille du tampon de caractères alloué sur le tas en utilisant StrAlloc ou StrNew. | |
StrCat | Concatène deux chaînes. | |
StrComp | Compare deux chaînes. | |
StrCopy | Copie une chaîne. | |
StrDispose | Libère un tampon de caractères alloué en utilisant StrAlloc ou StrNew. | |
StrECopy | Copie une chaîne et renvoie un pointeur sur la fin de la chaîne. | |
StrEnd | Renvoie un pointeur sur la fin de la chaîne. | |
StrFmt | Formate une ou plusieurs valeurs dans une chaîne. | |
StrIComp | Compare deux chaînes sans tenir compte des différences majuscules/minuscules. | |
StrLCat | Concatène deux chaînes avec une longueur maximum donnée pour la chaîne résultante. | |
StrLComp | Compare deux chaînes sur une longueur maximum donnée. | |
StrLCopy | Copie une chaîne jusqu'à une longueur maximum donnée. | |
StrLen | Renvoie la longueur d'une chaîne. | |
StrLFmt | Formate une ou plusieurs valeurs dans une chaîne avec une longueur maximum donnée. | |
StrLIComp | Compare deux chaînes sur une longueur maximum donnée sans tenir compte des différences majuscules/minuscules. | |
StrLower | Convertit une chaîne en minuscules. | |
StrMove | Déplace un bloc de caractères d'une chaîne dans une autre. | Alloue une chaîne sur le tas. |
StrPCopy | Copie une chaîne Pascal dans une chaîne à zéro terminal. | |
StrPLCopy | Copie une chaîne Pascal dans une chaîne à zéro terminal avec une longueur maximum donnée. | |
StrPos | Renvoie un pointeur sur la première occurrence d'une sous-chaîne donnée dans une chaîne. | |
StrRScan | Renvoie un pointeur sur la dernière occurrence d'un caractère donné dans une chaîne. | |
StrScan | Renvoie un pointeur sur la première occurrence d'un caractère donné dans une chaîne. | |
StrUpper | Convertit une chaîne en majuscules. |
Var
Ch : Pchar;
Ch := ’bonjour’; // Là encore la gestion de mémoire est transparente pour le programmeur.
Les chaînes de format transmises aux routines de définition de format de chaînes contiennent deux types d'objets : les caractères simples et les spécificateurs de format. Les caractères simples sont copiés tels quels dans la chaîne résultante.
Les spécificateurs de format récupèrent les arguments dans la liste des arguments en y appliquant un format.
Les spécificateurs de format ont la forme suivante :
"%" [index ":"] ["-"] [width] ["." prec] type
Un spécificateur de format commence par un caractère %. Ce qui suit % est, dans l'ordre :
Le spécificateur facultatif d'indice de l'argument, [index ":"]
              L'indicateur facultatif d'alignement à gauche, ["-"]
              Le spécificateur facultatif de taille, [width]
              Le spécificateur facultatif de précision, ["." prec]
               Le caractère de type de conversion, type
Le tableau suivant résume les valeurs possibles de type :
e     Scientifique. L'argument doit être une valeur à virgule flottante. La valeur est convertie en une chaîne de la forme " E+ddd". La chaîne résultante débute par un signe moins si le nombre est négatif. Un chiffre précède toujours le séparateur décimal. Le nombre total de chiffres dans la chaîne résultante (y compris celui qui précède la virgule) est donné par le spécificateur de précision dans la chaîne de format. Si celui-ci est omis, une précision de 15 est prise en compte par défaut. Le caractère "E" dans la chaîne résultante est toujours suivi d'un signe plus ou moins, puis de trois chiffres au moins.
f      Fixe. L'argument doit être une valeur à virgule flottante. La valeur est convertie en une chaîne de la forme " ". La chaîne résultante débute par un signe moins si le nombre est né nombre de chiffres après la virgule est fourni par le spécificateur de précision de la chaîne de format ; 2 décimales sont prises en compte par défaut si le spécificateur de précision est omis.
g     Général L'argument doit être une valeur à virgule flottante. La valeur est convertie en une chaîne la plus courte possible en utilisant le format fixe ou scientifique. Le nombre de chiffres significatifs dans la chaîne résultante est fourni par le spécificateur de précision dans la chaîne de format : une précision par défaut de 15 est prise en compte si le spécificateur de précision est omis. Les caractères zéro sont supprimés de la fin de la chaîne résultante et le séparateur décimal n'apparaît que s'il est nécessaire. La chaîne résultante utilise le format fixe si le nombre de chiffres à gauche de la virgule est inférieur ou égal à la précision indiquée et si la valeur est supérieure ou égale à 0,00001. Sinon, la chaîne résultante fait appel au format scientifique.
"-d,ddd, ". Le format "n" correspond au format "f", sauf que la chaîne résultante contient le séparateur des milliers.
m          Monétaire. L'argument doit être une valeur à virgule flottante. La valeur est convertie en une chaîne représentant
un montant monétaire. La conversion est contrôlée par les variables globales CurrencyString, CurrencyFormat, NegCurrFormat, ThousandSeparator, DecimalSeparator et CurrencyDecimals. Si la chaîne de format contient un spécificateur de précision, il remplace la valeur envoyée par la variable globale CurrencyDecimals.
p Pointeur. L'argument doit être une valeur de type pointeur. La valeur est convertie en une chaîne de 8 caractères qui représente des valeurs de pointeur en hexadécimal.
s             Chaîne. L'argument doit être un caractère, une chaîne ou une valeur PChar. La chaîne ou le caractère est inséré à la place du spécificateur de format. Le spécificateur de précision, s'il est défini dans la chaîne de format, indique la taille maximale de la chaîne résultante. Si l'argument est une chaîne de taille supérieure, celle-ci est tronquée.
x             Hexadécimal. L'argument doit être une valeur entière. La valeur est convertie en une chaîne de chiffres hexadécimaux. Si la chaîne de format contient un spécificateur de précision, ce dernier spécifie que la chaîne doit contenir au moins le nombre indiqué de chiffres ; si cela n'est pas le cas, des caractères zéro de remplissage sont rajoutés dans la partie gauche de la chaîne.
Les caractères de conversion peuvent être indiqués indifféremment en majuscules ou en minuscules : le résultat obtenu est le même.
Quel que soit le format flottant, les deux caractères utilisés comme séparateur décimal et séparateur des milliers sont respectivement définis par les variables globales DecimalSeparator et ThousandSeparator.
Lorsque vous utilisez l'astérisque, l'argument suivant dans la liste (qui doit être obligatoirement une valeur entière) devient la valeur effectivement utilisée. Par exemple : Format('%*.*f', [8, 2, 123.456]) équivaut Ã
Format('%8.2f', [123.456]).
Un spécificateur de taille définit la taille minimale du champ lors de la conversion. Si la chaîne résultante est de taille inférieure à la taille minimale définie, elle est comblée par des espaces afin d'accroître la taille du champ. Par défaut, le résultat est aligné à droite en faisant précéder la valeur d'espaces, mais si le spécificateur de format contient un indicateur d'alignement à gauche (un caractère "-" précédant le spécificateur de taille), le résultat est aligné à gauche par l'ajout d'espaces après la valeur.
Un spécificateur d'indice définit la valeur courante de l'indice de la liste. L'indice du premier argument dans la liste est 0. A l'aide du spécificateur d'indice, vous pouvez formater un même argument plusieurs fois de suite. Par exemple "Format('%d %d %0:d %1:d', [10, 20])" produit la chaîne '10 20 10 20'.
              Remarque :        La définition du spécificateur d'indice affecte les formatages ultérieurs. Par exemple, Format('%d %d %d
%0:d %d', [1, 2, 3, 4]) renvoie '1 2 3 1 2', et pas '1 2 3 1 4'. Pour obtenir ce dernier résultat, vous devez utiliser Format('%d %d %d %0:d %3:d', [1, 2, 3, 4]).
Un pointeur est une variable qui désigne une adresse mémoire. Quand un pointeur contient l'adresse d'une autre variable, on dit qu'il pointe sur l'emplacement en mémoire de cette variable ou sur les données qui y sont stockées. Dans le cas d'un tableau ou d'un type structuré, un pointeur contient l'adresse du premier élément de la structure.
Le mot réservé nil est une constante spéciale qui peut être affectée à tout pointeur. Quand la valeur nil est affectée à un pointeur, le pointeur ne désigne plus rien.
Supposons que l’on ait déclaré une variable b de type byte (var b : byte;)et que 5 lui soit affecté (b:=5;) : Le système trouve une place en mémoire de 1 octet pour stocker cette valeur supposons que l’adresse trouvée soit 135. Voici une représentation partielle de la mémoire: supposons d’autre part que l’on ait aussi déclaré un pointeur d’octet (var p : ^byte) l’affectation:
p := @b ; // p vaut (pour notre exemple) 135 et p^ vaut 5 c’est à dire la valeur de b.
Opérateur | Opération | Types d'opérande | Type du résultat | Exemple |
+ | addition de pointeurs | pChar, entier | pChar | P + I |
- | soustraction de pointeurs | pChar, entier | pChar, entier | P - Q |
^ | déréférencement de pointeur | pointeur | type de base du pointeur | P^ |
= | égalité | pointeur | Boolean | P = Q |
<> | inégalité | pointeur | Boolean | P <> Q |
L'opérateur ^ déréférence un pointeur. Son opérande peut être un pointeur de type quelconque sauf un pointeur générique
(Pointer) qui doit être transtypé avant d'être déréférencé.
Le symbole ^ a deux fonctions, toutes deux illustrées dans l'exemple plus bas. Quand il apparaît avant un identificateur de type :
^nomType
il désigne un type qui représente des pointeurs sur des variables de type nomType. Quand il apparaît après une variable pointeur : pointeur^
P = Q vaut True si P et Q pointent sur la même adresse ; sinon, P <> Q est True.
•          L'opérateur @ renvoie l'adresse d'une variable, d'une fonction, d'une procédure ou d'une méthode ; @ construit un
Addr, fonction. Renvoie un pointeur sur un objet spécifique
Ptr, fonction Convertit l'adresse spécifiée en pointeur
Dispose, procédure Libère la mémoire allouée à une variable dynamique
Finalize, procédure Désinitialise une variable allouée dynamiquement
FreeMem, procédure Libère une variable dynamique d'une taille donnée
GetMem, procédure Crée une variable dynamique et un pointeur sur l'adresse du bloc
Initialize, procédure Initialise une variable allouée dynamiquement
New, procédure Crée une nouvelle variable dynamique et initialise P de telle façon qu'il pointe dessus.
Var
 pb:^byte; // un pointeur d’octet (8 bits)  pw:^word; // un pointeur de mots(16 bits)  p:pointer; // un pointeur non typé  j:word; // un mot (16 bits)
 j:=$10FF; // j reçoit la valeur 4351
 pw:[email protected]; // pw pointe sur l’adresse où est stocké j
{ pb:=pw;  // provoque une erreur pour mélange de types}   pb:[email protected]; // alors que qu’ici : pas de problème  p:=pw; // pas plus que là   pb:=p; // ni là   writeln(j,' = ',pw^); // pw est l’adresse de j, pw^ représente la valeur située à cette adresse soit j !  writeln(pb^); // Affiche 255 ($FF) les descendants du 8086 stockent les poids faibles avant les poids forts!
 pb:=pointer(longint(pb)+1); // Il est nécessaire de transtyper, Delphi accepte pb := pb+1 uniquement pour les pChar (voir plus loin)
 writeln(pb^); // affichage des poids faibles : 16 ($10) essayer writeln((pb+1)^); Autre exemple :
var
 p : ^byte ; // réserve 4 octets pour stocker la valeur d’une adresse; Mais PAS le contenu de ce que l’on veut stocker
Il aura donc fallu 5 octets pour mémoriser la valeur 17 : 4 pour l’adresse mémoire et 1 pour la valeur. Alors que : var  b : byte;
 b:=17; ne requière qu’un octet . Remarque @b (ou addr(b) ) est codé sur 4 octets.
Le type pointer est une adresse mémoire. ^montype est un pointeur sur un type montype
Il existe aussi des pointeurs implicites tels que Pchar ou ansiString vus plus haut ou encore des tableaux dynamiques (que l’on verra plus bas) qu’il ne faut pas déréférencer (^ ).
Il existe aussi bien d’autres pointeurs . Pour plus d’informations voir l’aide Delphi.
Il est parfois nécessaire de manipuler des données dont le type change ou est inconnu lors de la compilation. Dans ce cas, une des solutions consiste à utiliser des variables et des paramètres de type Variant qui représentent des valeurs dont le type peut changer à l'exécution. Les variants offrent une plus grande flexibilité que les variables standard mais consomment davantage de mémoire. De plus les opérations où les variants sont utilisés sont plus lentes que celles portant sur des types associés statiquement. Enfin, les opérations illégales portant sur des variants provoquent fréquemment des erreurs d'exécution, alors que les mêmes erreurs avec des variables normales sont détectées à la compilation. À l’exception du type Int64, les variants peuvent tout contenir sauf les types structurés et les pointeurs.
ceux du type de base
Null, variable Null représente le variant null
Unassigned, constante Utilisée pour indiquer qu'une variable Variant n'a pas encore été affectée d'une valeur
VarArrayCreate, fonction Crée un tableau de variants
VarArrayDimCount, fonction Renvoie le nombre de dimensions d'un tableau de variants
VarArrayHighBound, fonction Renvoie la limite supérieure de la dimension donnée du tableau de variants
VarArrayLock, fonction Ferme le tableau de variants et renvoie un pointeur sur les données VarArrayLowBound, fonction Renvoie la limite inférieure de la dimension donnée du tableau de variants
VarArrayOf, fonction Crée et remplit un tableau de variants unidimensionnel
VarArrayRedim, procédure Redimensionne un tableau de variants
VarArrayRef, fonction Renvoie une référence au tableau de variants spécifié
VarArrayUnlock, procédure Déverrouille un tableau de variants
VarAsType, fonction Convertit un variant et le met dans le type spécifié
VarCast, procédure Convertit un variant dans le type spécifié et stocke le résultat dans une variable
VarClear, procédure Efface le variant spécifié afin qu'il ne soit pas affecté
VarCopy, procédure Copie un Variant
VarFromDateTime, fonction Renvoie un variant contenant la date-heure spécifiée
VarIsArray, fonction Indique si le Variant spécifié est un tableau
VarIsEmpty, fonction Indique si le Variant spécifié est Unassigned
VarIsNull, fonction Indique si le Variant spécifié est Null
VarToDateTime, fonction Convertit le variant spécifié en une valeur TDateTime
VarToStr, fonction Convertit un variant en chaîne
VarType, fonction Renvoie le code du type du variant spécifié
Un ensemble est une collection de valeurs ayant le même type scalaire. Les valeurs n'ont pas d'ordre intrinsèque, une même valeur ne peut donc pas apparaître deux fois dans un ensemble.
Les valeurs possibles du type ensemble sont tous les sous-ensembles du type de base, y compris l'ensemble vide. Le type de base ne peut avoir plus de 256 valeurs possibles et leur rang doit être compris entre 0 et 255. Toute construction de la forme :
set of  <typeBase> où <typeBase> est un type scalaire approprié, identifie un type ensemble.
En raison des limitations de taille des types de base, les types ensemble sont généralement définis avec des intervalles.
Opérateur | Opération | Types d'opérande | < Exemple | |
+ | union | ensemble | ensemble | ens1 + ens2 |
– | différence | ensemble | ensemble | S - T |
* | intersection | ensemble | ensemble | S * T |
<= | sous-ensemble | ensemble | Boolean | Q <= MonEns |
>= | sur-ensemble | ensemble | Boolean | S1 >= S2 |
= | égalité | ensemble | Boolean | S2 = MonEns |
<> | différence | ensemble | Boolean | MonEns <> S1 |
in | inclusion | scalaire, ensemble | Boolean | A in ens1 |
  tlettres='a'..'z';
  Elettres= setof Tlettres ; var
  lettres,voyelles ,consonnes, vide,v2: Elettres; begin
 voyelles := ['a','e','i','o','u','y'];
 v2:=['u','o','u','i','a','e']; // Le u est répété 2 fois mais les doublons seront éliminés et il manque le y par rapport à voyelles  lettres := ['a'..'z'];
 consonnes := lettres - voyelles;
{Â writeln(voyelles); provoque une erreur } Â writeln(vide = [ ]);Â // TRUE
{Â writeln(v2 in voyelles);Â // provoque une erreur } Â Â writeln(v2+['y']=voyelles); // TRUE
Un tableau représente une collection indicée d'éléments de même type (appelé le type de base). Comme chaque élément a un indice unique, les tableaux (à la différence des ensembles) peuvent, sans ambiguïtés, contenir plusieurs fois la même valeur. Il est possible d'allouer des tableaux de manière statique ou dynamique.
2. Â Â Â Â Â Â Â Â Â Â Tableaux statiques
Les tableaux statiques sont désignés par des constructions de la forme : array[typeIndex1, , typeIndexn] of typeBase
où chaque typeIndex est un type scalaire dont l'étendue de doit pas dépasser 2 Go. Comme les typeIndex indicent le tableau, le nombre d'éléments que le tableau peut contenir est limité par le produit de la taille des typeIndex. Pratiquement, les typeIndex sont en général des intervalles d'entiers.
Dans le cas le plus simple d'un tableau à une dimension, il n'y a qu'un seul typeIndex.
Type  t3[TRUE]:= 'salut';
  Tlettres='a'..'z';  t4[o]:='R';
  Ttbl = array[boolean] ofstring[6]; Exemple 2   Tvoy=(a,e,o,i,u,y); // n’a rien à voir avecType
l’ensemble des voyelles ci-dessus  Tindice = (x,y); // Type énuméré pour éviter
varles apostrophes voir t2 ci-dessus
  t1: array[byte] of Tlettres;  Tpoint = array[x..y] of real;
  t2 : array[tlettres] of byte; Var
  t3 : tTbl; P1: Tpoint;   t4 : array[Tvoy] of char;
P1[x] := 5.9;
 t1[19]:='e'; P1[y] := 3;  t2['k']:= 11;
Type  m1[2] := v;
 Tmat2 = array[1..4] ofarray[1..3] of real; { m2 := m1;  m3 := m1;  m4 := m1;  m4 := m3; Â
 Tmat3 = array[1..4,1..3] of real; // Provoquent une erreur }
var    m1[3][1] :=7.2  m1: Tmat1;    m1[3,2] := 5.1;  m2: Tmat2;    m2[3][1] :=7.2;  m3: Tmat3;   m2[3,2] := 5.1;  v : Tvecteur; m3[3][1] :=7.2;
 m4 :array[1..4,1..3] of real;   m3[3,2] := 5.1;
3. Â Â Â Â Â Â Â Â Â Tableaux dynamiquesÂ
Les tableaux dynamiques n'ont pas de taille ou de longueur fixe. La mémoire d'un tableau dynamique est réallouée quand vous affectez une valeur au tableau ou quand vous le transmettez à la procédure SetLength. Les types de tableau dynamique sont désignés par des constructions de la forme : arrayof <typeBase>
Si X et Y sont des variables du même type de tableau dynamique, X := Y fait pointer X sur le même tableau que Y. (Il n'est pas nécessaire d'allouer de la mémoire à X avant d'effectuer cette opération.) A la différence des chaînes ou des tableaux statiques, les tableaux dynamiques ne sont pas copiés quand ils vont être modifiés. Donc,
Routines | |
copy (Fonctions) | Tronque une partie d’un tableau dynamique |
high(Fonctions) | renvoie l'indice le plus élevé du tableau (c'est-à -dire Length – 1) . Dans le cas d'un tableau de longueur nulle, High renvoie –1 (avec cette anomalie que High < Low). |
length (Fonctions) | renvoie le nombre d'éléments du tableau, |
low(Fonctions) | renvoie 0 |
setLength (procédure) |  Réserve de la mémoire |
•          Exemple 1 t1 : arrayof byte; t2 : arrayofarrayof real;
setLength(t1,3); setLength(t2,4,3); t1[2}:=17; t2[3,1] := 3.6; • Exemple2 var
  t : arrayofarrayof Byte;
 t[1,0] := 1; t[1,1] := 1;Â
 t[2,0] := 1; t[2,1] := 2; t[2,2] := 1;  t[3,0] := 1; // Et ainsi de suite. Ceci pourrait constituer le début du triangle de pascal.
•  Exemple3
Après l'exécution du code suivant :
var
 A, B: arrayof Integer; begin
 SetLength(A, 1);
 A[0] := 1;  B := A;  B[0] := 2; end;
La valeur de A[0] est 2. Si A et B étaient des tableaux statiques, A[0] vaudrait toujours 1.
L'affectation d'un indice d'un tableau dynamique (par exemple, MonTableauFlexible[2] := 7) ne réalloue pas le tableau. Les indices hors des bornes ne sont pas détectés à la compilation.
Le mot enregistrement est souvent employé et peut prêter à confusion : Il ne s’agit pas d’enregistrer quoi que ce soit sur disque
Un record ou enregistrement (appelé aussi structure ou fiches dans certains langages) représente un ensemble de données hétérogènes. Chaque élément est appelé un champ ; la déclaration d'un type enregistrement spécifie le nom et le type de chaque champ. Une déclaration d’une variable de type enregistrement a la syntaxe suivante :
Var
nomVarEnregistrement = record  Champ1: type1;
 Champn: typen; end
où nomVarEnregistrement est un identificateur valide, où chaque type désigne un type, et chaque listeChamp est un identificateur valide ou une liste d'identificateurs délimitée par des virgules. Le point-virgule final est facultatif.
Pour accéder au champ chanpi de l’enregistrement , on utilise la notation des identificateurs qualifiés:( voir page 16) nomVarEnregistrement.champi
Exemple1:
type
 TDate = record
   Jour: 1..31;
   Mois: (Jan, Fev, Mar, Avr, Mai, Jun, Juil, Aou, Sep, Oct, Nov, Dec);Â
   Annee: Word;  end;
Var
 D1,D2 : Tdate;
 := 10;  := Mai;
 D1.annee := 2002;
Exemple 2 : A comparer avec l’équivalent Tableau ci-dessus.
La règle veut que l’on utilise un tableau pour une collection d’éléments de même type et des records pour une collection
d’éléments de types différents. Néanmoins :Â
Var
P2: Record
           x,y : Real;
end;
P2.x := 5.9; P2.y := 3;
Exemple 3 : listes chaînées:
Type
 TptListe = ^Tliste;
 Tliste =           record
                                 valr : byte;                           svt : TptListe
end;
var
 deb,p_cour : TptListe;
BEGIN
// initialisation   new (p_cour);  p_cour^.valr := 43;  deb := p_cour;  new (p_cour);  deb^.svt := p_cour;  p_cour^.valr := 15;  p_cour^.svt := nil; // inutile ici car un pointeur non alloué est automatiquement à nil
//  Parcours   p_cour := deb;  writeln(p_cour^.valr);  p_cour := p_cour^.svt;  writeln(p_cour^.valr); // Libération de la mémoire   dispose(deb^.svt);  dispose(deb); END.
Ce programme crée un chaînage de ce style :Â
              deb                                                                                                                                     Â
nil
dispose(deb^.svt^.svt) permettrait de libérer un 3ème chaînon qui ici n’a pas été créé (il y a nil à sa place) . Dans cet exemple, cette instruction provoquerait une erreur d’exécution (et non de compilation car elle est correcte)
K.     Enregistrements à partie variable
Voir l’aide de Delphi
type <nomTypeFichier> = file of <type>
où nom<TypeFichier> est un identificateur valide et type un type de taille fixe. Les types pointeur, implicites ou explicites ne sont pas permis. Un fichier ne peut donc pas contenir des tableaux dynamiques, des chaînes longues, des classes, des objets, des pointeurs, des variants, d'autres fichiers ou des types structurés en contenant.
Append, procédure | Prépare un fichier existant pour l'ajout de texte |
BlockRead, procédure | Lit un ou plusieurs enregistrements d'un fichier ouvert et les place dans une variable |
BlockWrite, procédure | Écrit un ou plusieurs enregistrements d'une variable mémoire dans un fichier ouvert |
Eof, fonction | La fonction Eof détermine si la position en cours du pointeur se trouve en fin de fichier |
FileMode, variable | Détermine le mode d'accès à utiliser lorsque des fichiers typés ou non typés sont ouverts avec la classe Reset |
FilePos, fonction | Renvoie la position en cours dans un fichier |
FileSize, fonction | Renvoie la taille d'un fichier (en octets) ou le nombre d'enregistrements dans le fichier |
IOResult, fonction | Renvoie l'état de la dernière opération d'E/S |
Input, variable | Spécifie un fichier en lecture seule associée à un périphérique d'entrée standard du système d'exploitation |
MkDir, procédure | Crée un nouveau répertoire |
Output, variable | Spécifie un fichier en écriture seulement associé à une sortie standard, généralement l'affichage |
Rename, procédure | Renomme un fichier externe |
Reset, procédure | Ouvre un fichier existant |
Rewrite, procédure | Crée puis ouvre un nouveau fichier |
RmDir, procédure | Supprime un sous-répertoire vide |
Seek, procédure | Déplace la position en cours dans un fichier vers le composant spécifié |
Truncate, procédure | |
Write, procédure (for typed files) 3.           Routines de fichiers texte | Écrit dans un fichier typé. |
AssignPrn, procédure | Affecte une variable fichier texte à l'imprimante |
Eoln, fonction | Eoln détermine si la position en cours du pointeur se trouve en fin de ligne d'un fichier texte |
Erase, procédure | Supprime un fichier externe |
Flush, procédure | Efface le tampon associé à un fichier texte ouvert en écriture |
Read, procédure | Read lit les données d'un fichier |
Readln, procédure | Lit une ligne de texte dans un fichier |
SeekEof, fonction | Renvoie l'état de fin d'un fichier |
SeekEoln, fonction | Renvoie l'état de fin de ligne d'un fichier |
SetTextBuf, procédure | Affecte un tampon d'E/S à un fichier texte |
Write, procédure (for text files) | Écrit dans un fichier texte |
Writeln, procédure | Place une marque de fin de ligne dans un fichier texte. |
AssignFile, procédure                    Associe le nom d'un fichier externe à une variable fichier
ChDir, procédure                             Change le répertoire en cours
CloseFile, procédure                      Ferme l'association entre une variable fichier et un fichier disque externe (Delphi)
Constantes en mode ouverture de fichier | Les constantes de mode d'ouverture de fichier sont utilisées pour contrôler le mode d'accès a fichier ou au flux |
Constantes mode de fichier | Les constantes mode de fichier sont utilisées pour ouvrir et fermer des fichiers disque |
CreateD | Crée un nouveau répertoire |
DeleteFile, fonction | Supprime un fichier du disque |
DiskFree, fonction | Renvoie le nombre d'octets disponibles sur le lecteur spécifié |
DiskSize, fonction | |
FileClose, procédure | Ferme le fichier spécifié |
FileDateToDateTime, fonction | Convertit une valeur date ou heure DOS en valeur au format TDateTime |
FileExists, fonction | Teste si le fichier spécifié existe. |
FileGetAttr, fonction | Renvoie les attributs du fichier FileName |
FileGetDate, fonction | Renvoie la date et l'heure DOS du fichier spécifié |
FileOpen, fonction | Ouvre un fichier en utilisant le mode d'accès spécifié |
FileRead, fonction | Lit le nombre d'octets spécifié dans un fichier |
FileSearch, fonction | Recherche un fichier dans le chemin DOS spécifié |
FileSeek, fonction | Positionne le pointeur d'un fichier préalablement ouvert |
FileSetAttr, fonction | Définit les attributs du fichier spécifié |
FileSetDate, fonction | Définit la marque horaire du fichier DOS spécifié |
FileWrite, fonction | Ecrit le contenu du tampon à l'emplacement en cours dans un fichier |
FindClose, procédure | Libère la mémoire allouée par FindFirst |
FindFirst, fonction | Cherche la première occurrence d'un fichier avec un ensemble d'attributs précis dans un répertoire spécifié. |
FindNext, fonction | Renvoie l'entrée suivante correspondant au nom et aux attributs spécifiés dans un précédent appel à FindFirst |
GetCurrentDir, fonction | Renvoie le nom du répertoire en cours |
GetDir, procédure | Renvoie le répertoire en cours sur le lecteur spécifié |
RemoveDir, fonction | Efface un répertoire vide existant |
RenameFile, fonction | Renomme un fichier |
SetCurrentDir, fonction | Définit le répertoire en cours. |
Const Max=100;
type TDonnees=record
           Nom, Prenom : string[50]; // ne pas utiliser des string, ansiString ou Pchar !!
end;
var
 fic : file of tBase;
ATTENTION:
 nomtb : tbase
// Pour enregistrer la base de données sur disque  assignfile(fic,''); rewrite(fic); write(fic,montb); closefile(fic);
// Pour récupérer la base de données du disque  assignfile(fic,''); reset(fic); read(fic,montb); closefile(fic);
Il serait très tentant d’utiliser: type TDonnees=record
           Nom,Prenom, adresse:string;
           cdPostl:integer;      end;
à la place de la déclaration ci-dessus. Cela éviterait de tronquer les chaînes ou de les surdimensionné (pour éviter un encombrement inutile de la mémoire). Il n’y aurait aucune différence de comportement (apparent) pour tout ce qui est stockage des données en mémoire.
Le problème apparaîtrait lors de l’instruction: write(fic,montb);
en effet, on n’enregistrerait pas les valeurs des Nom,Prenom, adresse mais des pointeurs référençant les adresses de ces valeurs. Ce qui n’aurait aucun intérêt, puisque la création est dynamique et qu’une autre exécution sur le même ordinateur ne donnerait pas les mêmes adresses pour ces valeurs. Ne parlons pas d’une exécution sur une autre machine! Et le compilateur s’en rend compte (et c’est heureux) et il le signale par une erreur à la compilation.
var
 F: function(X: Integer): Integer;
AllocMem, fonction                                   Alloue un bloc mémoire et initialise chaque octet à zéro AllocMemCount, variable                         Représente la taille totale des blocs de mémoire alloués dans une application AllocMemSize, variable                            Représente la taille totale des blocs de mémoire alloués GetHeapStatus, fonction                            Renvoie l'état actuel du gestionnaire de mémoire GetMemoryManager, procédure              Renvoie les points d'entrée du gestionnaire de mémoire installé HeapAllocFlags, variable                           Indicateurs spécifiant comment le gestionnaire de mémoire obtient la mémoire depuis le système d'exploitation IsMemoryManagerSet, fonction               Indique si le gestionnaire de mémoire a été surchargé en utilisant la procédure SetMemoryManager ReallocMem, procédure                             Réalloue une variable dynamique SetMemoryManager, procédure               Définit les points d'entrée du gestionnaire de mémoire SysFreeMem, fonction                              Libère la mémoire sur laquelle pointe le pointeur spécifié | |||
SysGetMem, fonction | Alloue un nombre spécifié d'octets et leur renvoie un pointeur | ||
SysReallocMem, fonction 2.           routines diverses | Renvoie un pointeur sur le nombre d'octets spécifié, préservant les valeurs pointées par le paramètre Pointer. | ||
Assert, procédure | Teste la validité d'une expression booléenne | Teste un pointeur nil (non affecté) ou une variable procédurale | |
Beep, procédure | Génère un bip standard sur le haut-parleur | ||
Chr, fonction | Renvoie le caractère correspondant à une valeur ASCII | ||
CollectionsEqual, fonction | Compare le contenu de deux collections | ||
CompareMem, fonction | Effectue une comparaison binaire de deux images mémoire | ||
DLLProc, variable | Pointe sur une procédure déclenchée par un point d'entrée d'une DLL | ||
Default8087CW, variable | Default 8087 est le mot de contrôle par défaut | ||
FillChar, procédure | Remplit une succession d'octets avec la valeur spécifiée | ||
FormatMaskText, fonction | Renvoie une chaîne formatée à l'aide d'un masque d'édition | ||
FreeAndNil, procédure | Libère une référence d'objet et la remplace par nil | ||
Hi, fonction | Renvoie l'octet de poids fort de X comme valeur non signée | ||
High, fonction | Renvoie la plus grande valeur dans l'étendue d'un argument | ||
HtmlTable, fonction | Génère l'image HTML d'un ensemble de données à l'aide des propriétés et des événements d'un objet générateur de tableau | ||
IsAccel, fonction | Indique si un caractère particulier est un caractère accélérateur (ou touche de raccourci) à l'intérieur d'un menu donné ou d'une autre chaîne de texte | ||
IsValidIdent, fonction | Teste un identificateur Pascal | ||
Lo, fonction | Renvoie l'octet de poids faible de l'argument X | ||
Low, fonction | Renvoie la valeur la moins élevée d'une étendue d'arguments | ||
MaxInt, constante | Valeur maximale du type de données Integer | ||
MaxLongint, constante | Valeur maximale du type de données Longint | ||
Move, procédure | Copie des octets de la source vers la destination | ||
Printer, fonction | Renvoie une instance globale d'un TPrinter pour gérer l'interaction avec l'imprimante | ||
Set8087CW, procédure | |||
SizeOf, fonction | renvoie le nombre d'octets occupés par une variable ou un type | ||
Slice, fonction | Renvoie une sous-section d'un tableau | ||
UniqueString, procédure | Vérifie qu'une chaîne donnée a un compteur de référence à 1 | ||
UpCase, fonction | Convertit un caractère en majuscules | ||
ValidParentForm, fonction | Renvoie la fiche ou la page de propriétés qui contient le contrôle spécifié. |
3. Â Â Â Â Â Â Â Â Informations au niveau de l'application.
Application, variable (pour les Représente les informations au niveau de l'application applications standard)
CmdShow, variable | CmdShow est transmise à la routine ShowWindow de l'API Windows |
HInstance, variable | Indique le handle fourni par Windows pour une application ou bibliothèque |
HintWindowClass, variable | Indique la classe de la fenêtre utilisée pour l'affichage des conseils d'aide |
IsConsole, variable | Indique si le module a été compilé en tant qu'application console |
IsLibrary, variable | Indique si le module est une DLL |
JITEnable, variable | Contrôle lorsque le débogueur juste à temps est appelé |
Languages, fonction | Énumère les localisations pour lesquelles le support est disponible |
MainInstance, variable | Le handle Instance pour l'exécutable principal |
MainThreadID, variable | Le handle Instance pour le thread d'exécution principal des modules en cours |
NoErrMsg, variable | Contrôle si l'application affiche un message d'erreur lorsqu'une erreur d'exécution se produit |
PopupList, variable | Fournit une gestion centralisée des messages Windows adressés à des menus déroulants |
Screen, variable | Représente un périphérique écran |
Win32Platform, variable | Spécifie l'identificateur de la plate-forme Win32. |
BCDToCurr, fonction | |
Bounds, fonction | Renvoie le TRect d'un rectangle de dimensions données |
CompToCurrency, fonction | Convertit une valeur Comp en une valeur Currency |
CompToDouble, fonction | Convertit une valeur en une valeur double |
CurrToBCD, fonction | Convertit une valeur monétaire en la valeur décimale codée binaire (BCD) correspondante |
CurrencyToComp, procédure | CurrencyToComp convertit une valeur Currency en Comp |
Point, fonction | Crée une structure point Windows avec un couple de coordonnées |
Rect, fonction | Crée une structure TRect à partir de coordonnées fournies |
StrToInt, fonction | Convertit en nombre une chaîne AnsiString qui représente un entier (décimal ou hexadécimal) |
StrToInt64, fonction | Convertit en nombre une chaîne qui représente un entier (décimal ou hexadécimal) |
StrToInt64Def, fonction | Convertit en nombre une chaîne qui représente un entier (décimal ou hexadécimal) |
StrToIntDef, fonction | Convertit en nombre une chaîne qui représente un entier (décimal ou hexadécimal). |
Abort, procédure | Permet de sortir d'un chemin d'exécution sans signaler d'erreur | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Break, procédure | La procédure Break provoque l'interruption d'une boucle for, while ou repeat | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Continue, procédure | Continue provoque le passage du contrôle de l'exécution à l'itération suivante dans une instruction for, while ou repeat | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Exit, procédure | Quitte la procédure en cours | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Halt, procédure | Exécute une fin anormale d'un programme | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
RunError, procédure | Interrompt l'exécution et génère une erreur d'exécution.
              StringToOleStr, fonction                   Alloue de la mémoire et copie une chaîne vers le format OLE               Supports, fonction                                Indique si un objet donné ou l'interface Iunknown supporte une interface spécifiée.                8.          Routines de compatibilité descendante              AddExitProc, procédure     N'existe que pour des raisons de compatibilité descendante
9. Â Â Â Â Â Â Â Â Informations au niveau de l'application.
UnregisterModuleClasses, procédure Dérecense toutes les classes définies dans le module spécifié WriteComponentResFile, procédure Place des composants et leur propriétés dans un fichier, dans un format de ressource Windows. O.     Constantes typées / Variables initialisées1.           définition Les constantes typées, à la différences des vraies constantes, peuvent contenir des valeurs de type tableau, enregistrement, p Dans l'état par défaut du compilateur {$J+}, il est même possible d'affecter de nouvelles valeurs à des constantes typées : elles se comportent alors essentiellement comme des variables initialisées. Mais si la directive de compilation {$J–} est active, il n'est pas possible à l'exécution de modifier la valeur des constantes typées ; en effet ce sont alors des variables en lecture seule. Déclarez une constante typée de la manière suivante : const identificateur: type = valeur où identificateur est un identificateur valide, type est un type quelconque (sauf un type fichier ou variant) et valeur est une expression de type type.                2.           exemples const Max: Integer = 100;  const Chiffres: array[0..9] of Char = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'); type TCube = array[0..1, 0..1, 0..1] of Integer; const Labyrinthe : TCube = (((0, 1), (2, 3)), ((4, 5), (6,7))); crée un tableau appelé Labyrinthe ou : Labyrinthe[0,0,0] = 0 Labyrinthe[1,0,0] = 4 Labyrinthe[0,0,1] = 1 Labyrinthe[1,0,1] = 5 Labyrinthe[0,1,0] = 2 Labyrinthe[1,1,0] = 6 Labyrinthe[0,1,1] = 3 Labyrinthe[1,1,1] = 7 type    M: TMois;  TPoint = record    A: 1900..1999;    X, Y: Single;  end; end; const  TVecteur = array[0..1] of TPoint;  Origine: TPoint = (X: 0.0; Y: 0.0);  TMois = (Jan, Fev, Mar, Avr, Mai, Jun, Jul, Aou,  Ligne: TVecteur = ((X: -3.1; Y: 1.5), (X: 5.8; Y: Sep, Oct, Nov, Dec); 3.0));  TDate = record  UnJour: TDate = (J: 2; M: Dec; A: 1960);    J: 1..31; La syntaxe du transtypage est : IdentificateurType(expression) Le transtypage de variable peut apparaître des deux côtés d'une affectation.                2.           exempleBoolean(0) // vaut FALSE Color(2) // la 3éme couleur si color est un type énuméré I := Integer('A'); // affecte 65 à la variable I Char(I) Boolean(Compteur) TUnTypeDefini(MaVariable) var MonCar: char; Shortint(MonCar) := 122; // affecte le caractère z (ASCII 122) à MonCar. V. Les routinesA.     ProcédureÂ1.           définitionDéclaration des procédures Procedure <nom_proc>( <liste des Paramètres Formels avec leur type>) ; <Déclaration des objets et des outils de la procédure  Structure identique à la déclaration des objets et des outils du programme > Begin<Instructions du corps de la procédure > End ; 2.           exempleprocedure stop; begin  writeln(‘Appuyez sur entrée’) ;  readln end;   stop;  // Appel de la procédure stop définie dans la zone des déclarations. B.     Fonctions1.           définitionDéclaration des fonctions Function<nom_fonc>(<liste des P.F. avec leur type>) : <type du résultat> ; <Déclaration des objets et des outils Structure identique à la déclaration des objets et des outils du programme > Begin<Instructions Corps de la fonction> result := <le résultat de la fonction> End ; 2.           exemplefunction f(x : real) : real; Begin  result := x*x+2;  //  on aurait pu écrire f := x*x +2 Mais on préférera utiliser la variable locale implicite result (impossible en turbo pascal) End; Var  y : real; y := f(3); Le paramètre peut avoir une valeur avant l’appel, sa valeur peut être modifiée dans la procédure, la modification n’est pas transmise au retour. 2.           exempleprocedure essai (x,y : byte); Delphi et Kilix         42          D. Mailliet begin  y := x // y prend la valeur de xend; Var  a,b : byte: a:= 3; b:= 2; essai (a,b); // a et b conservent leurs valeurs                D.    Paramètre Résultat               1.           définitionOn précède le nom du paramètre du mot out. Le paramètre ne doit pas avoir une valeur avant l’appel, sa valeur doit être donnée dans la procédure, la modification est transmise au retour.                2.           exempleprocedure essai (x:byte; out y : byte); begin  y := x // y prend la valeur de xend; Var  a,b : byte: a:= 3; b:= 2; essai (a,b); // a et b valent 3 mais la valeur initiale de b ( 2 ) n’a pas été transmise à y!                E.     Paramètre Donnée/résultat               1.           définitionIl s’agit d’un passage de paramètres par adresse. On précède le nom du paramètre du mot var. Le paramètre peut avoir une valeur avant l’appel, sa valeur peut être modifiée dans la procédure, la modification est transmise au retour.                2.           exempleprocedure essai (x:byte; var y : byte); begin  y := x // y prend la valeur de xend; Var  a,b : byte: a:= 3; b:= 2; essai (a,b); // a et b valent 3 et la valeur initiale de b ( 2 ) a été transmise à y!                F.      Paramètre Donnée Constante               1.           définitionOn précède le nom du paramètre du mot Const. 2.           exempleprocedure essai (x:byte; Const y : byte); begin  y := x // provoquera une erreur : il est impossible de modifier la valeur d’un paramètre constantend; G.     Paramètres facultatifs ou initialisés1.           définitionIl est possible de définir des routines (procédures et fonctions) avec n paramètres formels et de les utiliser avec p(<n) paramètres effectifs. Les n-p sont utilisés avec une valeur par défaut!; C’est par exemple le cas de la fonction prédéfinies inc qui s’utilise avec 1 ou 2 paramètres : inc(i) équivaut à i:=i+1 alors que inc(i,4) équivaut à i:=i+4 . Il faut remarquer que l’utilisation de inc évite le double calcul d’adresse de i et le code généré est donc plus efficace. Pour définir la valeur par défaut d’un paramètre, il suffit de faire suivre le type du paramètre par = suivi de sa valeur par défaut 2.           exempleSi la procédure inc n’était pas prédéfinie en delphi, on pourrait l’écrire comme ceci : procedure incr (var n : byte;increment : byte = 1); Begin n:= n+ incrément End; Remarque : bien entendu, la routine prédéfinie est plus performante et a surtout l’avantage d’admettre les types scalaires. H.     Paramètres sans type1.           définitionDans le corps d'une procédure ou d'une fonction, les paramètres sans type sont incompatibles avec tous les types. Pour agir sur un paramètre sans type, vous devez le transtyper. En général, le compilateur ne peut vérifier si les opérations effectuées sur les paramètres sans type sont légales. 2.           exemplesfunction Egal(var Source, Dest; Taille: Integer): Boolean; type  TOctets = array[0..MaxInt - 1] of Byte; // définition d’un type permettant le transtypagevar  N: Integer; begin  N := 0; while (N < Taille) and (TOctets(Dest)[N] = TOctets(Source)[N]) do    Inc(N); end; type  TVecteur = array[1..10] of Integer;  TPoint = record    X, Y: Integer; end; var  Vec1, Vec2: TVecteur;  N: Integer;  P: TPoint;  Egal(Vec1, Vec2, SizeOf(TVecteur))      // compare Vec1 et Vec2  Egal(Vec1, Vec2, SizeOf(Integer) * N)   // compare les N premiers éléments de Vec1 et Vec2  Egal(Vec1[1], Vec1[6], SizeOf(Integer) * 5) // compare les 5 premiers éléments aux 5 derniers éléments de Vec1  Egal(Vec1[1], P, 4)                             // compare Vec1[1] à P.X et Vec1[2] à P.Y Exemple 2 procedure permute(var a,b;taille:word); var c : pointer; begin  getmem(c,taille);  move(a,c^,taille);  move(b,a,taille);   // a:=b déclanche une erreur!  move(c^,b,taille);  freemem(c,taille) end; var ch1,ch2 : string[20]; x,y:real; BEGIN  ch1:='bonjour';  ch2:='salut';  x:=3;y:=5.9; writeln(ch1,ch2,x,y);  permute(x,y,sizeof(real));  permute(ch1,ch2,21); writeln(ch1,ch2,x,y); END.                I.       Paramètres tableau ouvert               1.           définitionLes paramètres tableau ouvert permettent de transmettre des tableaux de tailles différentes à la même routine. Pour définir une routine ayant un paramètre tableau ouvert, utilisez la syntaxe arrayoftype (au lieu de array[X..Y] oftype) dans la déclaration du paramètre                2.           Exemplefunction Somme(const A: arrayof Real): Real; var  I: Integer;  S: Real; begin  S := 0; for I := 0 to High(A) do S := S + A[I];  Somme := S; end; procedure FaireQuelquechose(A: arrayofconst); déclare une procédure appelée FaireQuelquechose qui peut agir sur des tableaux de données hétérogènes. La construction arrayofconst est équivalente à arrayof TVarRec. TVarRec, déclaré dans l'unité System, représente un enregistrement avec une partie variable qui peut contenir des valeurs de type entier, booléen, caractère, réel, chaîne, pointeur, classe, référence de classe, interface et variant. Le champ VType de TVarRec indique le type de chaque élément du tableau. Certains types sont transmis comme pointeur et non comme valeur ; en particulier les chaînes longues sont transmises comme Pointer et doivent être transtypées en string. 2.           ExempleÂL'exemple suivant utilise un paramètre tableau ouvert variant dans une fonction qui crée une représentation sous forme de chaîne de chaque élément transmis et concatène le résultat dans une seule chaîne. Les routines de manipulation de chaînes utilisées dans cette function sont définies dans l'unité SysUtils. function MakeStr(const Args: arrayofconst): string; const  BoolChars: array[Boolean] of Char = ('F', 'T'); var  I: Integer; begin  Result := ''; for I := 0 to High(Args) dowith Args[I] docase VType of        vtInteger:   Result := Result + IntToStr(VInteger);        vtBoolean:   Result := Result + BoolChars[VBoolean];        vtChar:      Result := Result + VChar;        vtExtended:  Result := Result + FloatToStr(VExtended^);        vtString:    Result := Result + VString^;        vtPChar:     Result := Result + VPChar; MakeStr(['test', 100, ' ', True, 3.14159, Tform]) ; // renvoie la chaîne "test100 T3.14159TForm". K.     Appel de procédure et de fonctions1.           définitionL’appel (utilisation) d’une procédure s’effectue comme pour toute instruction en indiquant le nom de la procédure Par défaut, Sauf directive de compilation, il est possible d’ignorer le résultat d’une fonction. C’est le cas de fausses procédures :les fonctions à effet de bord et qui donne un compte rendu booléen (ou autre) 2.           ExempleÂfunction exemple : boolean; begin // le corps de la procédure  résult := true; // la procédure s’est bien dérouléeend; var tst : boolean;  tst := exemple ; // utilisation normale d’un prédicat .. ..exemple ;// il est possible d’utiliser la fonction comme une procédure si l’on ne souhaite pas tenir compte du « compte-rendu » Exemples : procedure P1 (ch : string[20]); // erreur de syntaxeprocedure P2 (ch : Array[1..20] of byte); // erreur de syntaxeprocedure P3 (ch : string); // pas d’erreur de syntaxeprocedure P4 (ch : Arrayof byte); // pas d’erreur de syntaxe Type  Tch20 = string[20;  Ttab = Array[1..20] of byte; procedure P1 (ch : Tch20); // pas d’erreur de syntaxeprocedure P2 (ch : Ttab); // pas d’erreur de syntaxe Exemple pratique : Var t : array[1..2] of byte; som : byte; function Somme(const A: arrayof Real): Real; var  I: Integer;  S: Real; begin  S := 0; for I := 0 to High(A) do S := S + A[I];  Somme := S; end; t[1] := 5;t[2] := 11;  som := somme(t);  som := somme([3,8,9,6]);                L.     Retour sur le type procédure ou fonction               1.           définitionComme en LISP ou en Scheme, les routines sont des types comme les autres et peuvent donc être affectés ou passés en paramètres. End; function fois( m : integer; n : integer):integer; Begin result:= m*n End; type Toper = function (x : integer; y : integer):integer;    Ttab = array[1..5] of byte; function somprod(tb : Ttab; oper : Toper):integer; var i:integer; Begin result:=oper(1,1);   for i:=low(tb) to high(tb) do result:=oper(result,tb[i]);  somprod:= result; End; function som(tb: Ttab):integer; Begin result:=somprod(tb,plus)-1 End;   t:Ttab=(3,6,7,2,3); function prod(tb: Ttab):integer; BeginBEGIN  result:=somprod(tb,fois)  writeln(som(t)); End;  writeln(prod(t));   readln ConstEND. 3.           ExerciceExercice sur les paramètres de type fonction qui peut être traité même sans comprendre le fonctionnement de l’algorithme qui lui pourra être étudié après le paragraphe : « Structure de contrôle» Soit le programme: program QSort;      if i <= j thenbegin {$apptype console}         y := a[i]; a[i] := a[j]; a[j] := y; const        i := i + 1; j := j - 1;  Max = 1000;      end; until i > j; typeif l < j then Sort(l, j);  List = array[] of Integer;    if i < r then Sort(i, r); End{Sort}; var  Data: List; Begin{QuickSort};  I: Integer;  Sort(Bas,Haut); End{QuickSort}; procedure QuickSort(var A: List; Bas, Haut: Integer); BEGIN{QSort} Write('Generation de 1000 nombres aléatoires '); procedure Sort(l, r: Integer);  Randomize; varfor i := 1 to Max do Data[i] := Random(30000);    i, j, x, y: integer;  Writeln; Write('Tri de ces nombres ');  Begin QuickSort(Data, 1, Max);    i := l; j := r; x := a[(l+r) DIV 2];  Writeln; repeatfor i := 1 to 1000 doWrite(Data[i]:8); while a[i] < x do i := i + 1; readln;      while x < a[j] do j := j - 1; END. { QUICKSORT trie les éléments d'un tableau A d'indices entre Bas et Haut (bornes inclues) et ce de façon récursive. L'algorithme consiste à choisir un élément (appelé pivot) de la liste et de placer avant lui, tous ceux qui sont plus petits et après tous ceux qui sont plus grands. Cet élément se retrouvera donc à sa place. On recommence avec le sous-tableau devant cet élément et le sous tableau après. On peut choisir au hasard le pivot (premier, dernier, aléatoirement ) mais une optimisation consiste à utiliser la méthode ci-dessous} Il est simple de transformer la procédure QUICKSORT en lui ajoutant un paramètre fonction qui est en fait une relation d’ordre que l’on utilisera à la place de <. VI. Structure de contrôleA.     La séquence d’instructions et l’instruction composéeLes instructions sont exécutées les unes à la suite des autres en séquence. Elles sont séparées par des points-virgules. Pour obtenir une instruction composée de plusieurs instructions, il faut les encadrer d’un begin et d’un end (à la manière d’un parenthèsage en mathématiques) ce qui est utile pour les structures de test ou de boucles qui ne réalisent qu’une instruction simple ou composée.                B.     L’instruction Si               1.           définitionL'instruction si a deux formes : ifthen et ifthenelse. La syntaxe de l'instruction ifthen est : if expression then instruction où expression renvoie une valeur booléenne. Si expression vaut True, alors instruction est exécutée ; sinon elle ne l'est pas. Par exemple :  if J <> 0 then Resultat := I/J; La syntaxe de l'instruction ifthenelse est : if expression then instruction1 else instruction2 où expression renvoie une valeur booléenne. Si expression vaut True, alors instruction1 est exécutée ; sinon instruction2 est exécutée. Par exemple : if J = 0 then  Exit else Les clauses then et else contiennent une seule instruction chacune, mais ce peut être une instruction structurée.Par exemple : if J <> 0 thenbegin  Resultat := I/J;  Compteur := Compteur + 1; endelseif Compteur = Fin then  Arret := True else  Exit; Remarquez qu'il n'y a jamais de point-virgule entre la clause then et le mot else. Vous pouvez placer un point-virgule après une instruction if pour la séparer de l'instruction suivante du bloc mais les clauses then et else ne nécessitent rien d'autre qu'un espace ou un passage à la ligne entre elles. Le fait de placer un point-virgule immédiatement avant le else (dans une instruction if) est une erreur de programmation courante. Un problème particulier se présente quand des instructions if sont imbriquées. Le problème se pose car certaines instructions if ont une clause else alors que d'autres ne l'ont pas, mais la syntaxe des deux variétés de l'instruction est pour le reste la même. Dans une série de conditions imbriquées où il y a moins de clauses else que d'instructions if, il n'est pas toujours évident de savoir à quel if une clause else est rattachée. Soit une instruction de la forme if expression1 thenif expression2 then instruction1 else instruction2; Il y a deux manières d'analyser cette instruction : if expression1 then [ if expression2 then instruction1 else instruction2 ]; if expression1 then [ if expression2 then instruction1 ] else instruction2; Le compilateur analyse toujours de la première manière. C'est-à -dire que dans du véritable code, l'instruction :  est équivalent à :
|