Constantes déclarées
Remonter à Types de données, variables et constantes - Index
Différentes constructions du langage sont désignées par le terme "constantes". Il y a d'une part les constantes numériques (des nombres) comme 17 et des constantes chaîne (appelées également chaînes de caractères ou littéraux chaîne) comme 'Hello world!'. Chaque type énuméré définit des constantes qui représentent les valeurs de ce type. Il y a également des constantes prédéfinies comme True, False et nil. Enfin, il y a des constantes qui, comme les variables, sont créées individuellement par déclaration.
Les constantes déclarées sont soit de vraies constantes, soit des constantes typées. Ces deux sortes de constantes sont apparemment similaires, mais elles obéissent à des règles différentes et s'emploient pour des usages différents.
Sommaire
Vraies constantes
Une vraie constante est un identificateur déclaré dont la valeur ne peut changer. Par exemple :
const MaxValue = 237;
déclare une constante appelée MaxValue qui renvoie l'entier 237. La syntaxe de déclaration d'une vraie constante est :
const identifier = constantExpression
où identifier est un identificateur valide et constantExpression est une expression qui peut être évaluée par le compilateur sans exécuter votre programme.
Si constantExpression renvoie une valeur ordinale, vous pouvez spécifier le type de la constante déclarée en utilisant un transtypage de valeur. Par exemple :
const MyNumber = Int64(17);
déclare une constante appelée MyNumber, de type Int64, qui renvoie l'entier 17. Sinon, le type de la constante déclarée est le type du constantExpression.
- Si constantExpression est une chaîne de caractères, la constante déclarée est compatible avec tout type de chaîne. Si la chaîne de caractères est de longueur 1, elle est également compatible avec tout type de caractère.
- Si constantExpression est un réel, son type est Extended. Si c'est un entier, son type est donné par le tableau suivant.
Types de constantes entières
| Etendue de la constante (hexadécimale) | Etendue de la constante (décimale) | Type | Alias |
|---|---|---|---|
0 $FF |
0 255 |
Byte |
UInt8 |
0 $FFFF |
0 65535 |
Word |
UInt16 |
0 $FFFFFFFF |
0 4294967295 |
Cardinal |
UInt32, FixedUInt |
0 $FFFFFFFFFFFFFFFF |
0 18446744073709551615 |
UInt64 |
|
-$80 $7F |
-128 127 |
ShortInt |
Int8 |
-$8000 $7FFF |
-32768 32767 |
SmallInt |
Int16 |
-$80000000 $7FFFFFFF |
-2147483648 2147483647 |
Integer |
Int32, FixedInt |
-$8000000000000000 $7FFFFFFFFFFFFFFF |
-9223372036854775808 9223372036854775807 |
Int64 |
Type entier natif sur 32 bits
| Etendue de la constante (hexadécimale) | Etendue de la constante (décimale) | Type | Type équivalent |
|---|---|---|---|
-$80000000 $7FFFFFFF |
-2147483648 2147483647 |
NativeInt |
Integer |
0 $FFFFFFFF |
0 4294967295 |
NativeUInt |
Cardinal |
Type entier natif sur 64 bits
| Etendue de la constante (hexadécimale) | Etendue de la constante (décimale) | Type | Type équivalent |
|---|---|---|---|
-$8000000000000000 $7FFFFFFFFFFFFFFF |
-9223372036854775808 9223372036854775807 |
NativeInt |
Int64 |
0 $FFFFFFFFFFFFFFFF |
0 18446744073709551615 |
NativeUInt |
UInt64 |
Type entier sur les plates-formes 32 bits et Windows 64 bits
Les plates-formes 32 bits incluent Windows 32 bits, OSX32, iOS 32 bits et Android.
| Etendue de la constante (hexadécimale) | Etendue de la constante (décimale) | Type | Type équivalent |
|---|---|---|---|
-$80000000 $7FFFFFFF |
-2147483648 2147483647 |
LongInt |
Integer |
0 $FFFFFFFF |
0 4294967295 |
LongWord |
Cardinal |
Type entier sur les plates-formes 64 bits
Les plates-formes 64 bits incluent iOS 64 bits.
| Etendue de la constante (hexadécimale) | Etendue de la constante (décimale) | Type | Type équivalent |
|---|---|---|---|
-$8000000000000000 $7FFFFFFFFFFFFFFF |
-9223372036854775808 9223372036854775807 |
LongInt |
Int64 |
0 $FFFFFFFFFFFFFFFF |
0 18446744073709551615 |
LongWord |
UInt64 |
Voici quelques exemples de déclarations de constantes :
const
Min = 0;
Max = 100;
Center = (Max - Min) div 2;
Beta = Chr(225);
NumChars = Ord('Z') - Ord('A') + 1;
Message = 'Out of memory';
ErrStr = ' Error: ' + Message + '. ';
ErrPos = 80 - Length(ErrStr) div 2;
Ln10 = 2.302585092994045684;
Ln10R = 1 / Ln10;
Numeric = ['0'..'9'];
Alpha = ['A'..'Z', 'a'..'z'];
AlphaNum = Alpha + Numeric;
Expressions constantes
Une expression constante est une expression que le compilateur peut évaluer sans exécuter le programme dans lequel se trouve la déclaration. Les expressions constantes incluent les nombres, les chaînes de caractères, les vraies constantes, les valeurs des types énumérés, les constantes spéciales True, False et nil et toutes les expressions construites exclusivement en utilisant ces éléments avec des opérateurs, des conversions de type et des constructeurs d'ensemble. Les expressions constantes ne peuvent pas inclure des variables, des pointeurs ou des appels de fonction, à l'exception des appels aux fonctions prédéfinies suivantes :
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Cette définition d'une expression constante intervient à plusieurs endroits dans la spécification de la syntaxe Delphi. Les expressions constantes sont nécessaires à l'initialisation des variables globales, à la définition des types sous-intervalle, à l'affectation de rangs aux valeurs des types énumérés, à la spécification des valeurs de paramètres par défaut, à l'écriture des instructions case et à la déclaration de vraies constantes et de constantes typées.
Voici des exemples d'expressions constantes :
100
'A'
256 - 1
(2.5 + 1) / (2.5 - 1)
'Embarcadero' + ' ' + 'Developer'
Chr(32)
Ord('Z') - Ord('A') + 1
Chaînes de ressources
Les chaînes de ressources sont stockées comme des ressources et liées à l'exécutable ou à la bibliothèque afin de pouvoir être modifiées sans qu'il soit nécessaire de recompiler le programme.
Les chaînes de ressources sont déclarées comme les autres vraies constantes, à cette différence que le mot const est remplacé par resourcestring. L'expression à droite du symbole = doit être une expression constante qui renvoie une valeur chaîne. Par exemple :
resourcestring CreateError = 'Cannot create file %s'; OpenError = 'Cannot open file %s'; LineTooLong = 'Line too long'; ProductName = 'Embarcadero Rocks'; SomeResourceString = SomeTrueConstant;
Constantes typées
Les constantes typées, à la différence des vraies constantes, peuvent contenir des valeurs de type tableau, enregistrement, procédure ou pointeur. Les constantes typées ne peuvent pas intervenir dans des expressions constantes.
Déclarez une constante typée comme suit :
const identifier: type = value
où identifier est un identificateur valide, type est un type quelconque (sauf un type fichier ou variant) et value est une expression de type. Par exemple :
const Max: Integer = 100;
Le plus souvent, value doit être une expression constante ; mais si type est un type tableau, enregistrement, procédure ou pointeur, des règles spéciales s'appliquent.
Constantes tableau
Pour déclarer une constante tableau, placez entre parenthèses à la fin de la déclaration les valeurs des éléments du tableau, séparées par des virgules. Ces valeurs doivent être représentées par des expressions constantes. Par exemple :
const Digits: array[0..9] of Char =
('0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
déclare une constante typée appelée Digits qui contient un tableau de caractères.
Les tableaux de caractères d'index de base zéro représentent souvent des chaînes terminées par null. Pour cette raison, les constantes chaîne peuvent être utilisées pour initialiser des tableaux de caractères. Ainsi, la déclaration précédente peut se formuler plus simplement par :
const Digits: array[0..9] of Char = '0123456789';
Pour définir une constante tableau à plusieurs dimensions, placez séparément entre parenthèses les valeurs de chaque dimension, séparez les dimensions par des virgules. Par exemple :
type TCube = array[0..1, 0..1, 0..1] of Integer; const Maze: TCube = (((0, 1), (2, 3)), ((4, 5), (6,7)));
crée un tableau appelé Maze où :
Maze[0,0,0] = 0 Maze[0,0,1] = 1 Maze[0,1,0] = 2 Maze[0,1,1] = 3 Maze[1,0,0] = 4 Maze[1,0,1] = 5 Maze[1,1,0] = 6 Maze[1,1,1] = 7
A aucun niveau, les constantes tableau ne peuvent contenir des valeurs de type fichier.
Constantes enregistrement
Pour déclarer une constante enregistrement, spécifiez la valeur de chaque champ - comme nomChamp: valeur, avec les affectations de champs séparées par des points-virgules - entre parenthèses à la fin de la déclaration. Les valeurs doivent être représentées par des expressions constantes. Les champs doivent être listés dans l'ordre selon lequel ils apparaissent dans la déclaration du type enregistrement. Si un champ sélecteur existe, une valeur doit lui être spécifiée. Si l'enregistrement a une partie variant, seul le variant sélectionné par le champ sélecteur peut comporter des valeurs assignées.
Exemples :
type
TPoint = record
X, Y: Single;
end;
TVector = array[0..1] of TPoint;
TMonth = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
TDate = record
D: 1..31;
M: TMonth;
Y: 1900..1999;
end;
const
Origin: TPoint = (X: 0.0; Y: 0.0);
Line: TVector = ((X: -3.1; Y: 1.5), (X: 5.8; Y: 3.0));
SomeDay: TDate = (D: 2; M: Dec; Y: 1960);
A aucun niveau, les constantes enregistrement ne peuvent contenir des valeurs de type fichier.
Constantes procédurales
Pour déclarer une constante procédurale, spécifiez le nom d'une fonction ou d'une procédure compatible avec le type déclaré de la constante. Par exemple,
function Calc(X, Y: Integer): Integer; begin ... end; type TFunction = function(X, Y: Integer): Integer; const MyFunction: TFunction = Calc;
Etant donné ces déclarations, vous pouvez utiliser la constante procédurale MyFunction dans un appel de fonction :
I := MyFunction(5, 7)
Vous pouvez également assigner la valeur nil à une constante procédurale.
Constantes pointeur
Quand vous déclarez une constante pointeur, vous devez l'initialiser avec une valeur qui peut être résolue au moins sous la forme d'une adresse relative à la compilation. Il y a trois manières de procéder : avec l'opérateur @, avec nil et (si la constante est de type PChar ou PWideChar) avec un littéral chaîne. Si, par exemple, I est une variable globale de type Integer, vous pouvez déclarer une constante comme suit :
const PI: ^Integer = @I;
Le compilateur peut résoudre cette expression car les variables globales font partie du segment de code. Tout comme les fonctions et les constantes globales :
const PF: Pointer = @MyFunction;
Les littéraux chaîne étant alloués comme des constantes globales, vous pouvez initialiser une constante PChar avec un littéral chaîne :
const WarningStr: PChar = 'Warning!';
Constantes typées accessibles en écriture
Delphi permet la modification des constantes typées si vous définissez la directive ($J+} du compilateur ou Constantes typées affectables (Delphi) {$WRITEABLECONST ON}.
Avec $J+ défini, vous pouvez utiliser des instructions d'affectation pour changer la valeur des constantes typées si elles étaient des variables initialisées. Par exemple :
{$J+}
const
foo: Integer = 12;
begin
foo := 14;
end.
Différences entre les constantes typées accessibles en écriture et les variables initialisées :
- Les constantes typées accessibles en écriture peuvent survenir à la fois globalement et localement dans les procédures, les fonctions et les méthodes.
- Les variables initialisées sont seulement disponibles en tant que déclarations globales.
- Les variables initialisées provoquent une erreur de compilation lors d'une tentative au sein des procédures ou des méthodes.