Expressions (Object Pascal)

De Appmethod Topics
Aller à : navigation, rechercher

Remonter à Eléments syntaxiques fondamentaux - Index

Cette rubrique décrit les règles de la syntaxe des expressions Object Pascal.

Cette présentation aborde les sujets suivants :

  • Expressions Object Pascal valides
  • Opérateurs
  • Appels de fonctions
  • Constructeurs d'ensembles
  • Index
  • Transtypages

Expressions

Une expression est une construction qui renvoie une valeur. Le tableau suivant présente des exemples d'expressions Object Pascal :

X

variable

@X

adresse de la variable X

15

constante entière

InterestRate

variable

Calc(X, Y)

appel de fonction

X * Y

produit de X par Y

Z / (1 - Z)

quotient de Z par (1 - Z)

X = 1.5

booléen

C in Range1

booléen

not Done

négation d'un booléen

['a', 'b', 'c']

ensemble

Char(48)

transtypage de valeur


Les expressions les plus simples sont les variables et les constantes (décrites dans Types de données, variables et constantes). Les expressions complexes sont construites à partir d'expressions plus simples utilisant des opérateurs, appels de fonction, constructeurs d'ensemble, index et transtypages.

Opérateurs

Les opérateurs agissent comme des fonctions prédéfinies faisant partie du langage Object Pascal. Ainsi, l'expression (X + Y) est construite à partir des variables X et Y (appelées des opérandes) et avec l'opérateur + ; quand X et Y représentent des entiers ou des réels, (X + Y) renvoie leur somme. Les opérateurs sont @, not, ^, *, /, div, mod, and, shl, shr, as, +, -, or, xor, =, >, <, <>, <=, >=, in et is.

Les opérateurs @, not et ^ sont des opérateurs unaires (n'utilisant qu'un seul opérande). Tous les autres opérateurs sont binaires (ils utilisent deux opérandes), à l'exception de + et - qui peuvent être unaires ou binaires. Un opérateur unaire précède toujours son opérande (par exemple -B) à l'exception de ^ qui suit son opérande (par exemple, P^). Un opérateur binaire est placé entre ses opérandes (par exemple, A = 7).

Certains opérateurs se comportent différemment selon le type des données transmises. Ainsi, not effectue une négation bit-à-bit sur un opérande entier et une négation logique sur un opérande booléen. De tels opérateurs apparaissent ci-dessous sous plusieurs catégories.

A l'exception de ^, is et in, tous les opérateurs acceptent des opérandes de type Variant, voir Types variants.

Les sections suivantes supposent une certaine connaissance des types de données Object Pascal. Pour de plus amples informations, voir Types de données, variables et constantes.

Pour de plus amples informations sur la priorité des opérateurs dans les expressions complexes, voir Règles de priorité des opérateurs, plus loin dans cette rubrique.

Opérateurs arithmétiques

Les opérateurs arithmétiques suivants attendent des opérandes réels ou entiers : +, -, *, /, div et mod.

Opérateurs arithmétiques binaires :

Opérateur Opération Types des opérandes 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


Opérateurs arithmétiques unaires :

Opérateur Opération Type de l'opérande Type du résultat Exemple

+

identité du signe

entier, réel

entier, réel

+7

-

négation du signe

entier, réel

entier, réel

-X


Les règles suivantes s'appliquent aux opérateurs arithmétiques :

  • La valeur de x / y est de type Extended, indépendamment du type de x et y. Pour les autres opérateurs arithmétiques, 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 sous-intervalle d'un type entier, il est traité comme étant de ce type entier.
  • La valeur de x div y est la valeur de x / y arrondie dans la direction de zéro à l'entier le plus proche.
  • 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.

Opérateurs booléens

Les opérateurs booléens not, and, or et xor prennent des opérandes de tout type booléen et renvoient une valeur de type booléen.

Opérateurs booléens :

Opérateur Opération Types des opérandes Type du résultat Exemple

not

négation

Booléen

Booléen

not (C in MySet)

and

conjonction

Booléen

Booléen

Done and (Total >0)

or

disjonction

Booléen

Booléen

A or B

xor

disjonction exclusive

Booléen

Booléen

A xor B

Ces opérations sont régies par les règles standard de la logique booléenne. Par exemple, une expression de la forme x and y vaut True si et seulement si x et y valent tous les deux True.

Evaluation booléenne optimisée ou complète

Le compilateur supporte deux modes d'évaluation des opérateurs and et or : l'évaluation complète et l'évaluation optimisée (partielle). Evaluation complète signifie que chaque opérande d'une conjonction ou d'une disjonction est évalué même si le résultat de l'expression entière est déjà déterminé. Evaluation optimisée signifie que l'évaluation se fait strictement de gauche à droite et s'arrête dès que le résultat de l'expression entière est connu. Par exemple, si l'expression A and B est évaluée en mode optimisé alors que A vaut False, le compilateur n'évalue pas B ; il sait que la valeur de l'expression entière est False dès que A est évalué.

L'évaluation optimisée est généralement préférable car elle garantit une durée d'exécution minimale et le plus souvent une taille de code minimale. L'évaluation complète est pratique lorsqu'un opérande est une fonction ayant des effets secondaires jouant un rôle dans l'exécution du programme.

L'évaluation optimisée permet également l'utilisation de constructions qui pourraient autrement entraîner des opérations d'exécution illégales. Par exemple, le code suivant parcourt la chaîne S, jusqu'à la première virgule.

while (I <= Length(S)) and (S[I] <> ',') do
begin
 ...
 Inc(I);
end;

Si jamais S ne contient pas de virgule, la dernière itération incrémente I à une valeur supérieure à la longueur de S. Lors du dernier test de la condition du while, une évaluation complète entraîne une tentative de lecture de S[I], ce qui provoque une erreur d'exécution. Avec une évaluation optimisée, la deuxième partie de la condition du while, (S[I] <> ','), n'est pas évaluée quand la première partie est fausse.

Utilisez la directive de compilation $B pour contrôler le mode d'évaluation. L'état par défaut est {$B}, qui active l'évaluation optimisée. Pour activer localement l'évaluation complète, ajoutez la directive {$B+} à votre code. Vous pouvez également passer en évaluation complète pour un projet en sélectionnant Evaluation booléenne complète dans la page Compilation du dialogue Options de projet (toutes les unités source doivent être recompilées).

Remarque : Si un opérande quelconque fait appel à un variant, le compilateur effectue toujours une évaluation complète (même dans l'état {$B}).

Opérateurs logiques (bit-à-bit)

Les opérateurs logiques suivants effectuent des manipulations bit-à-bit sur des opérandes entiers. Si, par exemple, la valeur stockée dans X est (au format binaire) 001101 et si la valeur stockée dans Y est 100001, l'instruction

Z := X or Y;

assigne la valeur 101101 à Z.

Opérateurs logiques (bit-à-bit) :

Opérateur Opération Types des opérandes Type du résultat Exemple

not

négation bit-à-bit

entier

entier

not X

and

et bit-à-bit

entier

entier

X and Y

or

or bit-à-bit

entier

entier

X or Y

xor

ou exclusif bit-à-bit

entier

entier

X xor Y

shl

décalage à gauche bit-à-bit

entier

entier

X shl 2

shr

décalage à droite bit-à-bit

entier

entier

Y shr I

Les règles suivantes s'appliquent aux opérateurs bit-à-bit :

  • Le résultat d'une opération not est de même type que l'opérande.
  • Si les opérandes d'une opération and, or ou xor sont tous les deux des entiers, le résultat est du plus petit type entier prédéfini qui inclut toutes les valeurs possibles des deux types.
  • Les opérations x shl y et x shr y décalent la valeur de x vers la gauche ou la droite de y bits, ce qui est (si x est un entier non signé) équivalent à la multiplication ou la division de x par 2^y; le résultat étant du même type que x. Par exemple, si N contient la valeur 01101 (13 en décimal), alors N shl 1 renvoie 11010 (26 en décimal). Notez que la valeur de y est interprétée comme le modulo de la taille du type de x. Ainsi, par exemple, si x est un integer, x shl 40 est interprété comme x shl 8 car un integer a pour taille 32 bits et 40 mod 32 correspond à 8.

Exemple

Si x est un entier négatif, les opérations shl et shr sont clairement exposées dans l'exemple suivant :

 var
   x: integer;
   y: string;
 
 ...
 begin
   x := -20;
   x := x shr 1;
   //As the number is shifted to the right by 1 bit, the sign bit's value replaced is with 0 (all negative numbers have the sign bit set to 1).
   y := IntToHex(x, 8);
   writeln(y);
   //Therefore, x is positive.
   //Decimal value: 2147483638
   //Hexadecimal value: 7FFFFFF6
   //Binary value: 0111 1111 1111 1111 1111 1111 1111 0110
 end.

Opérateurs de chaînes

Les opérateurs relationnels =, <>, <, >, <=, et >= acceptent tous des opérandes de chaînes (voir Opérateurs relationnels plus loin dans cette section). L'opérateur + concatène deux chaînes.

Opérateurs de chaînes :

Opérateur Opération Types des opérandes Type du résultat Exemple

+

concaténation

chaîne, chaîne compactée, caractère

chaîne

S + '.'


Les règles suivantes s'appliquent à la concaténation de 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 (UnicodeString, AnsiString ou WideString).
  • 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.

Opérateurs de pointeurs

Opérateurs pointeur-caractère :

Opérateur Opération Types des opérandes Type du résultat Exemple

+

addition de pointeurs

pointeur caractère, entier

pointeur caractère

P + I

-

soustraction de pointeurs

pointeur caractère, entier

pointeur caractère, entier

P - Q

^

déréférencement de pointeur

pointeur

type de base du pointeur

P^

=

égalité

pointeur

Booléen

P = Q

<>

inégalité

pointeur

Booléen

P <>Q


L'opérateur ^ déréférence un pointeur. Son opérande peut être un pointeur de type quelconque sauf le Pointer générique, qui doit être transtypé avant d'être déréférencé.

P = Q vaut True si P et Q pointent sur la même adresse ; sinon, P <> Q vaut True.

Vous pouvez utiliser les opérateurs + et - pour incrémenter et décrémenter le décalage d'un pointeur caractère. Vous pouvez également utiliser - pour calculer la différence entre les décalages de deux pointeurs caractère. Les règles suivantes s'appliquent :

  • Si I est un entier et P un pointeur caractère, P + I ajoute alors I à l'adresse donnée par P ; c'est-à-dire que l'opération renvoie un pointeur à l'adresse I caractères après P. (L'expression I + P est équivalente à P + I.) P - I soustrait I de l'adresse donnée par P ; c'est-à-dire que l'opération renvoie un pointeur à l'adresse I caractères avant P. Cela est vrai pour les pointeurs PAnsiChar ; pour les pointeurs PWideChar, P + I ajoute I * SizeOf(WideChar) à P.
  • Si P et Q sont tous les deux des pointeurs caractère, P - Q calcule alors la différence entre l'adresse donnée par P (l'adresse la plus haute) et l'adresse donnée par Q (l'adresse la plus basse) ; c'est-à-dire que l'opération renvoie un entier indiquant le nombre de caractères entre P et Q.
L'opération P + Q n'est pas définie.

Opérateurs d'ensembles

Les opérateurs suivants acceptent des ensembles comme opérandes :

Opérateurs d'ensembles :

Opérateur Opération Types des opérandes Type du résultat Exemple

+

union

ensemble

ensemble

Set1 + Set2

-

différence

ensemble

ensemble

S - T

*

intersection

ensemble

ensemble

S * T

<=

sous-ensemble

ensemble

Booléen

Q <= MySet

>=

sur-ensemble

ensemble

Booléen

S1 >= S2

=

égalité

ensemble

Booléen

S2 = MySet

<>

inégalité

ensemble

Booléen

MySet <> S1

in

appartenance

ordinal, ensemble

Booléen

A in Set1


Les règles suivantes s'appliquent aux opérateurs +, - et * :

  • Un ordinal O est dans X + Y si et seulement si O est dans X ou dans Y (ou dans les deux). O est dans X - Y si et seulement si O est dans X mais pas dans Y. O est dans X * Y si et seulement si O est à la fois dans X et Y.
  • Le résultat d'une opération +, - ou * est de type set of A..B, où A est la plus petite valeur ordinale de l'ensemble résultant et B la plus grande.

Les règles suivantes s'appliquent à <=, >=, =, <> et in :

  • X <= Y vaut True uniquement si chaque membre de X est un membre de Y ; Z >= W est équivalent à W <= Z. U = V vaut True uniquement si U et V contiennent exactement les mêmes membres ; sinon, U <> V vaut True.
  • Pour un ordinal O et un ensemble S, O in S vaut True uniquement si O est membre de S.

Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour comparer deux opérandes. Les opérateurs =, <>, <= et >= s'appliquent également aux ensembles.

Opérateurs relationnels :

Opérateur Opération Types des opérandes Type du résultat Exemple

=

égalité

simple, classe, référence de classe, interface, chaîne, chaîne compactée

Booléen

I = Max

<>

inégalité

simple, classe, référence de classe, interface, chaîne, chaîne compactée

Booléen

X <> Y

<

inférieur à

simple, chaîne, chaîne compactée, PChar

Booléen

X < Y

>

supérieur à

simple, chaîne, chaîne compactée, PChar

Booléen

Len > 0

<=

inférieur ou égal à

simple, chaîne, chaîne compactée, PChar

Booléen

Cnt <= I

>=

supérieur ou égal à

simple, chaîne, chaîne compactée, PChar

Booléen

I >= 1


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 relationnels :

  • Les opérandes doivent être de types compatibles, sauf pour un réel et un entier qui peuvent être comparés.
  • Les chaînes sont comparées en fonction des valeurs ordinales représentant les caractères formant la chaîne. Les types caractère sont traités comme des chaînes de longueur 1.
  • Deux chaînes compactées doivent avoir le même nombre de composants pour pouvoir être comparées. Quand une chaîne compactée ayant n composants est comparée à une chaîne, la chaîne compactée est traitée comme une chaîne de longueur n.
  • Utilisez les opérateurs <, >, <= et >= pour comparer des opérandes PAnsiChar (et PWideChar) uniquement si les deux pointeurs désignent le même tableau de caractères.
  • Les opérateurs = et <> acceptent des opérandes de type classe ou référence de classe. Avec des opérandes de type classe, = et <> sont évalués en utilisant les règles s'appliquant aux pointeurs : C = D vaut True uniquement si C et D pointent sur le même objet d'instance ; sinon C <> D vaut True. Avec des opérandes de type référence de classe, C = D vaut True uniquement si C et D désignent la même classe ; sinon C <> D vaut True. Cela n’effectue pas la comparaison des données stockées dans les classes. Pour de plus amples informations sur les classes, voir Classes et objets.

Opérateurs de classes et d'interfaces

Les opérateurs as et is prennent des classes et des objets d'instances comme opérandes ; as opère également sur les interfaces. Pour de plus amples informations, voir Classes et objets, Interfaces d'objets et Références d'interfaces.

Les opérateurs relationnels = et <> opèrent également sur les classes.

L'opérateur @

L'opérateur @ renvoie l'adresse d'une variable, d'une fonction, d'une procédure ou d'une méthode ; @ construit un pointeur sur son opérande. Pour de plus amples informations sur les pointeurs, voir "Pointeurs et types pointeur" dans Types de données, variables et constantes. Les règles suivantes s'appliquent à @.

  • Si X est une variable, @X renvoie l'adresse de X. (Des règles spéciales s'appliquent quand X est une variable procédurale ; voir "Types procéduraux dans les instructions et les expressions" dans Types de données, variables et constantes.) @X est de type Pointer si la directive de compilation par défaut {$T} est en vigueur. Dans l'état {$T+}, @X est de type ^T, où T est le type de X (cette distinction est importante pour la compatibilité d'affectation, voir Compatibilité d'affectation).
  • Si F est une routine (une fonction ou une procédure), @F renvoie le point d'entrée de F. @F est toujours de type Pointer.
  • Quand @ est appliqué à une méthode définie dans une classe, l'identificateur de la méthode doit être qualifié par le nom de la classe. Par exemple,
@TMyClass.DoSomething
pointe sur la méthode DoSomething de TMyClass. Pour de plus amples informations sur les classes et les méthodes, voir Classes et objets.

Remarque : Lors de l'utilisation de l'opérateur @, il n'est pas possible de prendre l'adresse d'une méthode d'interface, car l'adresse n'est pas connue à la compilation et elle ne peut pas être extraite à l'exécution.

Priorité des opérateurs

Dans les expressions complexes, les règles de priorité déterminent l'ordre dans lequel les opérations sont effectuées.

Priorité des opérateurs

Opérateurs Priorité

@
not

première (maximale)

*
/
div
mod
and
shl
shr
as

deuxième

+
-
or
xor

troisième

=
<>
<
>
<=
>=
in
is

quatrième (minimale)


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. Ainsi, l'expression :

X + Y * Z

multiplie Y par Z puis ajoute X au résultat ; * est évaluée en premier car sa priorité est supérieure à celle de +. Mais :

X - Y + Z

commence par soustraire Y de X puis ajoute Z au résultat : - et + ayant la même priorité, l'opération de gauche est effectuée en premier.

Vous pouvez utiliser des parenthèses pour redéfinir ces règles de priorité. Une expression entre parenthèses est tout d'abord évaluée puis traitée comme un seul opérande. Par exemple :

(X + Y) * Z

multiplie Z par la somme de X et Y.

Les parenthèses sont parfois nécessaires dans des situations où, au premier regard elles ne semblent pas utiles. Par exemple, soit l'expression :

X = Y or X = Z

L'interprétation voulue est manifestement :

(X = Y) or (X = Z)

Néanmoins, sans parenthèses, le compilateur respecte les règles de priorité des opérateurs et l'interprète comme :

(X = (Y or X)) = Z

ce qui provoque une erreur de compilation sauf si Z est un booléen.

Les parenthèses rendent souvent le code plus simple à écrire et à lire même quand elles sont, techniquement parlant, inutiles. Ainsi le premier exemple peut également s'écrire :

X + (Y * Z)

Ici, les parenthèses ne sont pas nécessaires pour le compilateur, mais elles épargnent au programmeur et au lecteur la nécessité de réfléchir à la priorité des opérateurs.

Appels de fonctions

Comme les fonctions renvoient une valeur, les appels de fonctions sont des expressions. Si, par exemple, vous avez défini une fonction appelée Calc qui attend deux arguments entiers et renvoie un entier, l'appel de fonction Calc(24,47) est alors une expression entière. Si I et J sont des variables entières, alors I + Calc(J,8) est également une expression entière. Voici quelques exemples d'appels de fonctions :

Sum(A, 63)
Maximum(147, J)
Sin(X + Y)
Eof(F)
Volume(Radius, Height)
GetValue
TSomeObject.SomeMethod(I,J);

Pour de plus amples informations sur les fonctions, voir Procédures et fonctions.

Constructeurs d'ensembles

Un constructeur d'ensemble désigne une valeur de type ensemble. Par exemple :

[5, 6, 7, 8]

désigne l'ensemble dont les membres sont 5, 6, 7 et 8. Le constructeur d'ensemble :

[ 5..8 ]

désigne le même ensemble.

La syntaxe d'un constructeur d'ensemble est :

[ élément1, ..., élémentn ]

où chaque élément est une expression désignant un ordinal ayant le type de base de l'ensemble ou une paire de telles expressions avec deux points (..) entre chacune. Quand un élément est de la forme x..y, c'est un abrégé pour tous les ordinaux compris dans l'intervalle allant de x à y, incluant y ; mais si x est supérieur à y, alors x..y ne désigne rien et l'ensemble [x..y] est l'ensemble vide. Le constructeur d'ensemble [ ] désigne l'ensemble vide alors que [x] désigne l'ensemble dont le seul membre est la valeur de x.

Exemples de constructeurs d'ensembles :


[red, green, MyColor]
[1, 5, 10..K mod 12, 23]
['A'..'Z', 'a'..'z', Chr(Digit + 48)]

Pour de plus amples informations sur les ensembles, voir Types structurés dans Types de données, variables et constantes.

Index

Les chaînes de caractères, les tableaux et propriétés tableau, les pointeurs sur des chaînes ou des tableaux peuvent être indexés. Si, par exemple, FileName est une variable chaîne, l'expression FileName[3] renvoie le troisième caractère de la chaîne désignée par FileName, alors que FileName[I + 1] renvoie le caractère suivant immédiatement celui indexé par I. Pour de plus amples informations sur les chaînes, voir Types de données, variables et constantes. Pour de plus amples informations sur les tableaux et les propriétés tableau, voir Tableaux dans Types de données, variables et constantes et "Propriétés tableau" dans la page Propriétés.

Transtypages

Il est parfois utile de traiter une expression ayant un type donné comme si elle était d'un type différent. Le transtypage permet de le faire en modifiant, temporairement, le type d'une expression. Par exemple, Integer('A') transtype le caractère A en entier.

La syntaxe du transtypage est :

typeIdentifier(expression)

Si l'expression est une variable, le résultat est appelé un transtypage de variable ; sinon le résultat est un transtypage de valeur. Si la syntaxe est la même, des règles différentes s'appliquent à ces deux sortes de transtypages.

Transtypages de valeurs

Dans un transtypage de valeur, l'identificateur de type et l'expression de transtypage doivent être tous les deux de type pointeur ou ordinal. Exemples de transtypages de valeurs :


Integer('A')
Char(48)
Boolean(0)
Color(2)
Longint(@Buffer)

La valeur résultante est obtenue en convertissant l'expression entre parenthèses. Cela peut nécessiter une réduction ou une extension si la taille du type spécifié diffère de celle de l'expression. Le signe de l'expression est toujours conservé.

L'instruction :

I := Integer('A');

assigne la valeur de Integer('A'), c'est-à-dire 65, à la variable I.

Un transtypage de valeur ne peut être suivi par un qualificateur et ne peut apparaître dans la partie gauche d'une instruction d'affectation.

Transtypages de variables

Il est possible de convertir toute variable vers un type quelconque, à partir du moment où la taille est la même et que vous ne mélangez pas des entiers et des réels. (Pour convertir des types numériques, utilisez les fonctions standard comme Int et Trunc.) Exemples de transtypages de variables :

Char(I)
Boolean(Count)
TSomeDefinedType(MyVariable)

Les transtypages de variables peuvent apparaître des deux côtés d'une instruction d'affectation. Ainsi :

var MyChar: char;
  ...
  Shortint(MyChar) := 122;

assigne le caractère z (ASCII 122) à MyChar.

Il est possible de convertir des variables en un type procédural. Par exemple, soit les déclarations :

type Func = function(X: Integer): Integer;
var
  F: Func;
  P: Pointer;
  N: Integer;

les affectations suivantes sont possibles :

F := Func(P);     { Assign procedural value in P to F }
Func(P) := F;     { Assign procedural value in F to P }
@F := P;          { Assign pointer value in P to F }
P := @F;          { Assign pointer value in F to P }
N := F(N);        { Call function via F }
N := Func(P)(N);  { Call function via P }

Il est possible de faire suivre les transtypages de variables par des qualificateurs, comme illustré dans l'exemple suivant :

type
  TByteRec = record
     Lo, Hi: Byte;
  end;
  TWordRec = record
     Low, High: Word;
  end;
  PByte = ^Byte;

var
  B: Byte;
  W: Word;
  L: Longint;
  P: Pointer;

begin
  W := $1234;
  B := TByteRec(W).Lo;
  TByteRec(W).Hi := 0;
  L := $1234567;
  W := TWordRec(L).Low;
  B := TByteRec(TWordRec(L).Low).Hi;
  B := PByte(L)^;
end;

Dans cet exemple, TByteRec est utilisé pour accéder aux octets de poids faible et de poids fort d'un mot et TWordRec pour accéder aux mots de poids faible et de poids fort d'un entier long. Vous pouvez utiliser les fonctions prédéfinies Lo et Hi pour obtenir le même résultat, mais un transtypage de variable présente l'avantage de pouvoir s'utiliser sur la partie gauche d'une instruction d'affectation.

Pour de plus amples informations sur le transtypage de pointeurs, voir Pointeurs et types pointeur (Object Pascal). Pour de plus amples informations sur le transtypage des types classe et interface, voir "L'opérateur as" dans Références de classes et Références d'interfaces.

Voir aussi