Constantes déclarées

De Appmethod Topics
Aller à : navigation, rechercher

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

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, 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é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


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 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 à partir de ces éléments avec des opérateurs, des transtypages 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 :

Abs

High

Low

Pred

Succ

Chr

Length

Odd

Round

Swap

Hi

Lo

Ord

SizeOf

Trunc


Cette définition d'une expression constante est utilisée à plusieurs endroits dans la spécification de la syntaxe Object Pascal. 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 des valeurs de paramètres par défaut, 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' + ' ' + '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 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 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'index de base zéro représentent souvent des chaînes terminées par null, les constantes chaîne 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 des valeurs de type fichier.

Constantes enregistrement

Pour déclarer une constante tableau, spécifiez la valeur de chaque champ - comme fieldName: valeur, avec les affectations de champs séparées par des 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 aussi 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

Object Pascal permet la modification des constantes typées si vous définissez la directive ($J+} du compilateur ou des constantes typées accessibles en écriture (Object Pascal) {$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.

Voir aussi