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înes (appelées également chaînes de caractères ou littéraux chaîne) comme 'Bonjour chez vous !'. Chaque type énuméré définit des constantes qui représentent les valeurs de ce type. Il y a aussi 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 des déclarations.
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 le programme.
Si constantExpression renvoie une valeur scalaire, 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 du type de 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écimal) | Etendue de la constante (décimal) | Type | Alias |
|---|---|---|---|
|
0..$FF |
0..255 |
Byte |
UInt8 |
|
0..$FFFF |
0..65535 |
Word |
UInt16 |
|
0..$FFFFFFFF |
0..4294967295 |
Cardinal |
UInt32, LongWord |
|
0..$FFFFFFFFFFFFFFFF |
0..18446744073709551615 |
UInt64 |
|
|
-$80..$7F |
-128..127 |
ShortInt |
Int8 |
|
-$8000..$7FFF |
-32768..32767 |
SmallInt |
Int16 |
|
-$80000000..$7FFFFFFF |
-2147483648..2147483647 |
Integer |
Int32, LongInt |
|
-$8000000000000000..$7FFFFFFFFFFFFFFF |
-9223372036854775808..9223372036854775807 |
Int64 |
Type entier natif sur 32 bits :
| Etendue de la constante (hexadécimal) | Etendue de la constante (décimal) | 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écimal) | Etendue de la constante (décimal) | Type | Type équivalent |
|---|---|---|---|
|
-$8000000000000000..$7FFFFFFFFFFFFFFF |
-9223372036854775808..9223372036854775807 |
NativeInt |
Int64 |
|
0..$FFFFFFFFFFFFFFFF |
0..18446744073709551615 |
NativeUInt |
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 = 'Mémoire insuffisante';
ErrStr = ' Erreur: ' + 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 sont : 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 contenir de variables, de pointeurs ou d'appels de fonction, sauf les fonctions prédéfinies suivantes :
|
Abs |
High |
Low |
Pred |
Succ |
|
Chr |
Length |
Odd |
Round |
Swap |
|
Hi |
Lo |
Ord |
SizeOf |
Trunc |
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 de types intervalle, l'affectation de rang aux valeurs des types énumérés, la spécification de la valeur par défaut de paramètres, l'écriture d'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' + ' ' + 'Développeur'
Chr(32)
Ord('Z') - Ord('A') + 1
Chaînes de ressources
Les chaînes de ressource sont stockées comme des ressources et liées à l'exécutable ou la bibliothèque afin de pouvoir les modifier sans avoir besoin de recompiler le programme.
Les chaînes de ressource sont déclarées comme les 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 = 'Impossible de créer le fichier %s'; OpenError = 'Impossible d'ouvrir le fichier %s'; LineTooLong = 'Ligne trop longue'; ProductName = 'Embarcadero Rocks'; SomeResourceString = SomeTrueConstant;
Constantes typées
Les constantes typées, à la différences des vraies constantes, peuvent contenir des valeurs de type tableau, enregistrement, procédure ou pointeur. Les constantes typées ne peuvent intervenir dans des expressions constantes.
Déclarez une constante typée de la manière suivante :
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 qui sont 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'indice de base zéro représentent souvent des chaînes à zéro terminal, les constantes chaînes peuvent donc ê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 de valeurs de type fichier.
Constantes enregistrement
Pour déclarer une constante enregistrement, spécifiez la valeur des champs, en séparant les affectations de champ (de la forme fieldName: value) 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 énumérés dans l'ordre de leur déclaration dans la déclaration du type enregistrement. S'il existe, la valeur du champ sélecteur doit être spécifiée ; si l'enregistrement a une partie variable, il faut assigner des valeurs uniquement à la variante sélectionnée par le champ sélecteur.
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);
Ligne : 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 de valeur de type fichier.
Constantes procédure
Pour déclarer une constante procédure, 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édure MyFunction dans un appel de fonction :
I := MyFunction(5, 7)
Vous pouvez également affecter la valeur nil à une constante procédure.
Constantes pointeur
Quand vous déclarez une constante pointeur, vous devez l'initialiser avec une valeur qui peut être résolue à la compilation (au moins sous la forme d'une adresse relative). Il y a trois manières de procéder pour ce faire : 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 de la forme
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;
Comme les littéraux chaîne sont alloués comme des constantes globales, vous pouvez initialiser une constante PChar avec un littéral chaîne :
const WarningStr: PChar = 'Attention!';
Constantes typées accessibles en écriture
Delphi permet la modification des constantes typées si vous définissez la directive ($J+} du compilateur ou {$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.