Expressions (Delphi)

De RAD Studio
Aller à : navigation, rechercher

Remonter à Eléments syntaxiques fondamentaux - Index


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

Cette présentation aborde les sujets suivants :

  • Expressions Delphi 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 Delphi :

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 A propos des types de données (Delphi)). Les expressions complexes sont construites à partir d’expressions plus simples utilisant des opérateurs, appels de fonction, constructeurs d'ensemble, indices et transtypages.

Opérateurs

Les opérateurs agissent comme des fonctions prédéfinies faisant partie du langage Delphi. 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 peut suivre 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 pour un opérande entier et une négation logique pour un opérande booléen. De tels opérateurs apparaissent dans plusieurs des catégories indiquées plus bas.

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 Delphi, voir About Data Types (Delphi).

Pour davantage d'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, qui prennent des opérandes réels ou entiers, comprennent +, -, *, /, div et mod.

Opérateurs arithmétiques unaires :

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 de 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 arrondi vers le bas à 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 renvoie une valeur de type Boolean.

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 et 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 gère 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ée 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. Ainsi, quand 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 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 minimum et le plus souvent une taille de code minimum. L'évaluation complète est parfois commode quand 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 provoquer des erreurs à l'exécution. 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 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 condition (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+} dans votre code. Vous pouvez également passer en évaluation complète pour un projet en sélectionnant Evaluation booléenne complète dans le 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 revient (si x est un entier non signé) à multiplier ou à diviser x par 2^y ; le résultat est 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 explicité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 chaîne (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 de pointeurs de caractères :

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

+

addition de pointeurs

pointeur de caractère, entier

pointeur de caractère

P + I

-

soustraction de pointeurs

pointeur de caractère, entier

pointeur de 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 un pointeur générique (Pointer) 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 ou décrémenter le décalage d'un pointeur de caractère. Vous pouvez également utiliser - pour calculer la différence de décalage entre deux pointeurs de caractère. Les règles suivantes s'appliquent :

  • Si I est un entier et P un pointeur de caractère, alors P + I ajoute I à l'adresse spécifiée par P ; c'est-à-dire que le résultat est un pointeur sur l'adresse I caractères après P. L'expression I + P est équivalente à P + I.) P - I soustrait I de l'adresse spécifiée par P ; c'est-à-dire que le résultat est un pointeur sur 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 de caractère, P - Q calcule la différence entre l'adresse spécifiée par P (l'adresse la plus haute) et l'adresse spécifiée par Q (l'adresse la plus basse) ; c'est-à-dire que le résultat est un entier qui indique le nombre de caractères séparant 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

scalaire, ensemble

Booléen

A in Set1


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

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

Les règles suivantes s'appliquent aux opérateurs <=, >=, =, <> et in :

  • X <= Y vaut True si chaque membre de X est un membre de Y ; Z >= W est équivalent à W <= Z. U = V vaut True si U et V contiennent exactement les mêmes membres ; sinon, U <> V vaut True.
  • Pour un scalaire 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 is 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.
  • Les chaînes sont comparées en fonction des valeurs scalaires 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 la même instance d'objet, sinon C <> D vaut True. Avec des opérandes de type référence de classe, C = D vaut True 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 instances d'objet comme opérandes ; as accepte également des 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 A propos des types de données (Delphi). Les règles suivantes s'appliquent à l'opérateur @.

  • Si X est une variable, @X renvoie l'adresse de X. Des règles spéciales s'appliquent quand X est une variable de type procédure ; voir "Types procédure dans les instructions et les expressions" dans A propos des types de données (Delphi). @X est de type Pointer si la directive de compilation par défaut {$T} est active. Dans l'état {$T+}, @X est de type ^T, où T est le type de X (cette distinction est importante pour la compatibilité d’assignation, voir Compatibilité pour l'assignation).
  • 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,
         L'opération P + Q n'est pas définie.
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 qu'elle ne peut être extraite à l'exécution.

Règles de priorité des opérateurs

Dans des 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 : 

@TMyClass.DoSomething

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 à 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) * 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 or X)) = 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 fonction sont des expressions. Si, par exemple, vous avez défini une fonction appelée Calc qui attend deux arguments entiers et qui renvoie un entier, l'appel de fonction Calc(24,47) est 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 : 

X + (Y * Z)

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 : 

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

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

[5, 6, 7, 8]

désigne le même ensemble.

La syntaxe d'un constructeur d'ensemble est :

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

où chaque élément est soit une expression désignant un scalaire ayant le type de base de l'ensemble ou une paire de telles expressions avec deux points (..) entre. Quand un élément est de la forme x..y, c'est un abrégé pour tous les scalaires compris dans l'intervalle allant de x à y, y compris y ; mais si x est supérieur à y, alors x..y, l'ensemble [x..y], ne désigne rien et 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 : 

[ 5..8 ]

Pour de plus amples informations sur les ensembles, voir Types structurés dans A propos des types de données (Delphi).

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 indicé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 NomFichier, alors que NomFichier[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 de tableaux, 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 un entier.

La syntaxe du transtypage est : 

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

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 à transtyper doivent être tous les deux de type pointeur ou scalaire. Exemples de transtypages de valeurs : 

typeIdentifier(expression)

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 : 

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

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'assignation.

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 : 

I := Integer('A');

Le transtypage de variable peut apparaître des deux côtés d'une assignation. Par conséquent : 

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

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

Il est possible de convertir des variables dans un type procédure. Par exemple, soit ces déclarations : 

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

les assignations suivantes sont possibles : 

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

Il est possible de faire suivre un transtypage de variable par un qualificateur, comme dans l'exemple suivant : 

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 }

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 dans la partie gauche d'une assignation.

Pour plus d’informations sur le transtypage des pointeurs, voir Pointeurs et types pointeur (Delphi). 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

Récupérée de « https://docwiki.embarcadero.com/RADStudio/Athens/f/index.php?title=Expressions_(Delphi)&oldid=215519 »