Expressions (Delphi)
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
Sommaire
- 1 Expressions
- 2 Opérateurs
- 2.1 Opérateurs arithmétiques
- 2.2 Opérateurs booléens
- 2.3 Evaluation booléenne optimisée ou complète
- 2.4 Opérateurs logiques (bit-à-bit)
- 2.5 Opérateurs de chaînes
- 2.6 Opérateurs de pointeurs
- 2.7 Opérateurs d'ensembles
- 2.8 Opérateurs relationnels
- 2.9 Opérateurs de classes et d'interfaces
- 2.10 L'opérateur @
- 2.11 Règles de priorité des opérateurs
- 3 Appels de fonctions
- 4 Constructeurs d'ensembles
- 5 Index
- 6 Transtypages
- 7 Voir aussi
Expressions
Une expression est une construction qui renvoie une valeur. Le tableau suivant présente des exemples d'expressions Delphi :
|
variable |
|
adresse de la variable X |
|
constante entière |
|
variable |
|
appel de fonction |
|
produit de X par Y |
|
quotient de Z par (1 - Z) |
|
Booléen |
|
Booléen |
|
négation d'un booléen |
|
ensemble |
|
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 |
|
- |
soustraction |
entier, réel |
entier, réel |
|
* |
multiplication |
entier, réel |
entier, réel |
|
/ |
division réelle |
entier, réel |
réel |
|
div |
division entière |
entier |
entier |
|
mod |
reste |
entier |
entier |
|
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 |
|
- |
négation du signe |
entier, réel |
entier, réel |
|
Les règles suivantes s'appliquent aux opérateurs arithmétiques :
- La valeur de
x / y
est de type Extended, indépendamment du type dex
et dey
. 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 dex / 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 formex / y
,x div y
oux 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 |
|
and |
conjonction |
Booléen |
Booléen |
|
or |
disjonction |
Booléen |
Booléen |
|
xor |
disjonction exclusive |
Booléen |
Booléen |
|
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 |
|
and |
et bit-à-bit |
entier |
entier |
|
or |
or bit-à-bit |
entier |
entier |
|
xor |
ou exclusif bit-à-bit |
entier |
entier |
|
shl |
décalage à gauche bit-à-bit |
entier |
entier |
|
shr |
décalage à droite bit-à-bit |
entier |
entier |
|
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
etx shr y
décalent la valeur dex
vers la gauche ou la droite dey
bits, ce qui revient (six
est un entier non signé) à multiplier ou à diviserx
par2^y
; le résultat est du même type quex
. Par exemple, siN
contient la valeur01101
(13 en décimal), alorsN shl 1
renvoie11010
(26 en décimal). Notez que la valeur dey
est interprétée comme le modulo de la taille du type dex
. Ainsi, par exemple, six
est un integer,x shl 40
est interprété commex 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 |
|
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
- Les opérateurs relationnels <, >, <= et >= acceptent des opérandes de type PAnsiChar et PWideChar (voir Opérateurs relationnels). Les opérateurs suivants acceptent également des pointeurs comme opérandes. Pour de plus amples informations sur les pointeurs, voir Pointeurs et types pointeur (Delphi) dans A propos des types de données (Delphi)..
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 |
|
- |
soustraction de pointeurs |
pointeur de caractère, entier |
pointeur de caractère, entier |
|
^ |
déréférencement de pointeur |
pointeur |
type de base du pointeur |
|
= |
égalité |
pointeur |
Booléen |
|
<> |
inégalité |
pointeur |
Booléen |
|
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 etP
un pointeur de caractère, alorsP + I
ajouteI
à l'adresse spécifiée parP
; c'est-à-dire que le résultat est un pointeur sur l'adresseI
caractères aprèsP
. L'expressionI + P
est équivalente àP + I
.)P - I
soustraitI
de l'adresse spécifiée parP
; c'est-à-dire que le résultat est un pointeur sur l'adresseI
caractères avantP
. Cela est vrai pour les pointeurs PAnsiChar ; pour les pointeurs PWideChar,P + I
ajouteI * SizeOf(WideChar)
àP
. - Si
P
etQ
sont tous les deux des pointeurs de caractère,P - Q
calcule la différence entre l'adresse spécifiée parP
(l'adresse la plus haute) et l'adresse spécifiée parQ
(l'adresse la plus basse) ; c'est-à-dire que le résultat est un entier qui indique le nombre de caractères séparantP
etQ
.
- 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 |
|
- |
différence |
ensemble |
ensemble |
|
* |
intersection |
ensemble |
ensemble |
|
<= |
sous-ensemble |
ensemble |
Booléen |
|
>= |
sur-ensemble |
ensemble |
Booléen |
|
= |
égalité |
ensemble |
Booléen |
|
<> |
inégalité |
ensemble |
Booléen |
|
in |
appartenance |
scalaire, ensemble |
Booléen |
|
Les règles suivantes s'appliquent aux opérateurs +, - et * :
- Le scalaire
O
appartient àX + Y
si et seulement siO
est dansX
ou dansY
(ou dans les deux).O
appartient àX - Y
si et seulement siO
est dansX
mais pas dansY
.O
appartient àX * Y
si et seulement siO
est à la fois dansX
et dansY
. - Le résultat d'une opération +, - ou * est de type
set of A..B
oùA
est la plus petite valeur scalaire de l'ensemble résultant etB
la plus grande.
Les règles suivantes s'appliquent aux opérateurs <=, >=, =, <> et in :
X <= Y
vaut True si chaque membre deX
est un membre deY
;Z >= W
est équivalent àW <= Z
.U = V
vaut True siU
etV
contiennent exactement les mêmes membres ; sinon,U <> V
vaut True.- Pour un scalaire
O
et un ensembleS
,O in S
vaut True uniquement siO
est membre deS
.
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 |
|
<> |
inégalité |
simple, classe, référence de classe, interface, chaîne, chaîne compactée |
Booléen |
|
< |
inférieur à |
simple, chaîne, chaîne compactée, PChar |
Booléen |
|
> |
supérieur à |
simple, chaîne, chaîne compactée, PChar |
Booléen |
|
<= |
inférieur ou égal à |
simple, chaîne, chaîne compactée, PChar |
Booléen |
|
>= |
supérieur ou égal à |
simple, chaîne, chaîne compactée, PChar |
Booléen |
|
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 longueurn
. - 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 siC
etD
pointent sur la même instance d'objet, sinonC <> D
vaut True. Avec des opérandes de type référence de classe,C = D
vaut True siC
etD
désignent la même classe ; sinonC <> 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 deX
. Des règles spéciales s'appliquent quandX
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 deX
(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 deF
.@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
deTMyClass
. 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é |
---|---|
@ |
première (maximale) |
* |
deuxième |
+ |
troisième |
= |
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.