Section courante

A propos

Section administrative du site

Variables et constantes typées

Une variable est un identificateur marquant une valeur pouvant changer.

Déclaration de variable

Une déclaration de variable est une liste d'identificateurs désignant de nouvelles variables et leurs types.

Le type spécifié pour la(les) variable(s) peut être un identificateur de type précédemment déclaré dans une partie de déclaration de type dans le même bloc, dans un bloc englobant ou dans une unité; il peut également s'agir d'une nouvelle définition de type. Lorsqu'un identificateur est spécifié dans la liste d'identificateurs d'une déclaration de variable, cet identificateur est un identificateur de variable pour le bloc dans lequel la déclaration se produit. La variable peut alors être référencée dans tout le bloc, à moins que l'identifiant ne soit redéclaré dans un bloc fermé. La redéclaration crée une nouvelle variable en utilisant le même identifiant, sans affecter la valeur de la variable d'origine. Voici un exemple de partie de déclaration de variable :

Var
A,B,C:Real;
I,J,K:Integer;
Chiffre:0..9;
Couleur:Color;
Fait,Erreur:Boolean;
Operateur:[Plus,Minus,Heures]; HUE1,HUE2;Set of Color;
Aujourdhui:Date;
Resultats:ListeDeMesure;
P1,P2:Personne;
Matrice:Array[1..10,1..10]of Real;

Les variables déclarées en dehors des procédures et des fonctions sont appelées variables globales et résident dans le segment de données. Les variables déclarées dans les procédures et les fonctions sont appelées variables locales et résident dans le segment de pile.

Le segment de données

La taille maximale du segment de données est de 65 520 octets. Lorsqu'un programme est lié (cela se produit automatiquement à la fin de la compilation d'un programme), les variables globales de toutes les unités utilisées par le programme, ainsi que les propres variables globales du programme, sont placées dans le segment de données. Si vous avez besoin de plus de 65 520 octets de données globales, vous devez allouer les structures plus grandes en tant que variables dynamiques.

Le système de pile

La taille du segment de pile est définie via une directive de compilation $M - elle peut être comprise entre 1 024 et 65 520 octets. La taille de segment de pile par défaut est de 16 384 octets. Chaque fois qu'une procédure ou une fonction est activée (appelée), elle alloue un ensemble de variables locales sur la pile. À la sortie, les variables locales sont supprimées. A tout moment lors de l'exécution d'un programme, la taille totale des variables locales allouées par les procédures et fonctions actives ne peut pas dépasser la taille du segment de pile. La directive du compilateur $S est utilisée pour inclure des vérifications de dépassement de capacité de pile dans le code. Dans l'état par défaut {$S+}, du code est généré pour vérifier le débordement de pile au début de chaque procédure et fonction. Dans l'état {$S-}, aucune vérification de ce type n'est effectuée. Un débordement de pile peut provoquer un plantage du système, donc ne désactivez pas les vérifications de pile à moins d'être absolument sûr qu'un débordement ne se produira jamais.

Variables absolues

Les variables peuvent être déclarées comme résidant à des adresses mémoire spécifiques et sont alors appelées variables absolues. La déclaration de ces variables doit inclure une clause absolue suivant le type :

La liste d'identificateurs de la déclaration de variable ne peut spécifier qu'un seul identificateur lorsqu'une clause absolue est présente. La première forme de la clause absolue spécifie le segment et le déplacement (appelé Offset en anglais) auxquels la variable doit résider :

Var ModeVideo:Byte absolute $0040:$0049;

La première constante spécifie la base du segment et la seconde spécifie le déplacement (appelé Offset en anglais) dans ce segment. Les deux constantes doivent être comprises entre $0000 et $FFFF (0 à 65 535). Le deuxième format de la clause absolue est utilisée pour déclarer une variable au-dessus d'une autre variable, ce qui signifie qu'elle déclare une variable résidant à la même adresse mémoire qu'une autre variable :

Var
Chaine:String[32];
StrLen:Byte Absolute Chaine;
LongueurDeChaine:Byte Absolute Chaine;

Cette déclaration spécifie que la variable StrLen et LongueurDeChaine doivent commencer à la même adresse que la variable Chaine, et comme le premier octet d'une variable chaîne contient la longueur dynamique de la chaîne de caractères, StrLen contiendra la longueur de Chaine.

Références variables

Une référence de variable permet d'indiquer l'un des éléments suivants :

Voici la syntaxe d'une référence de variable :

La syntaxe d'une référence de variable autorise une expression calculant une valeur de type pointeur. L'expression doit être suivie d'un qualificatif déréférençant la valeur du pointeur (ou indexe la valeur du pointeur si la syntaxe étendue est activée avec la directive {$X+}) pour produire une référence de variable réelle.

Qualificateurs

Une référence de variable peut contenir zéro ou plusieurs qualificateurs modifiant la signification de la référence de variable.

Un identificateur de tableau sans qualificateur, par exemple, fait référence au tableau entier :

Resultats

Un identificateur de tableau suivi d'un index désigne une composante spécifique du tableau - dans ce cas, une variable structurée :

Resultats[Courant + 1]

Avec un composante étant un enregistrement ou un objet, l'index peut être suivi d'un désignateur de champ. Ici, l'accès variable signifie un champ spécifique dans une composante de tableau spécifique :

Resultats[Courant + 1].Donnees

L'indicateur de champ dans un champ de pointeur peut être suivi du symbole de pointeur (^) pour différencier le champ de pointeur de la variable dynamique vers laquelle il pointe :

Resultats[Courant + 1].Donnees^

Si la variable pointée est un tableau, des index peuvent être ajoutés pour désigner les composantes de ce tableau :

Resultats[Courant + 1].Donnees^[J]

Tableaux, chaînes et index

Une composante spécifique d'une variable de tableau est désigné par une référence de variable faisant référence à la variable de tableau, suivie d'un index spécifiant la composante. Un caractère spécifique dans une variable chaîne de caractères est désigné par une référence de variable faisant référence à la variable chaîne de caractères, suivie d'un index spécifiant la position du caractère.

Les expressions d'index sélectionnent des composantes dans chaque dimension correspondante du tableau. Le nombre d'expressions ne peut pas dépasser le nombre de types d'index dans la déclaration de tableau. En outre, le type de chaque expression doit être compatible avec l'affectation avec le type d'index correspondant. Lors de l'indexation d'un tableau multidimensionnel, plusieurs index ou plusieurs expressions dans un index peuvent être utilisés de manière interchangeable. Par exemple :

Matrice[I][J]

est le même chose que

Matrice[I,J]

Vous pouvez indexer une variable chaîne de caractères avec une seule expression d'index, dont la valeur doit être comprise entre 0..N, où N est la taille déclarée de la chaîne de caractères. Elle accède à un caractère de la valeur de chaîne de caractères, avec le type Char donné à cette valeur de caractère. Le premier caractère d'une variable de chaîne de caractères (à l'index 0) contient la longueur dynamique de la chaîne de caractères; autrement dit, Length(S) est identique à Ord(S[0]). Si une valeur est affectée à l'attribut de longueur, le compilateur ne vérifie pas si cette valeur est inférieure à la taille déclarée de la chaîne de caractères. Il est possible d'indexer une chaîne de caractères au-delà de sa longueur dynamique actuelle. Les caractères lus sont aléatoires et les affectations au-delà de la longueur actuelle n'affectent pas la valeur réelle de la variable chaîne de caractères. Lorsque la syntaxe étendue est activée (à l'aide de la directive du compilateur {$X+}), une valeur de type PChar peut être indexée avec une seule expression d'index de type de données Word. L'expression d'index spécifie un déplacement à ajouter au pointeur de caractère avant qu'il ne soit déréférencé pour produire une référence de variable de type de données Char.

Enregistrements et désignateurs de champ

Un champ spécifique d'une variable d'enregistrement est désigné par une référence de variable faisant référence à la variable d'enregistrement, suivie d'un désignateur de champ spécifiant le champ.

Voici des exemples d'indicateur de champ :

Aujourdhui.Annee
Resultats[1].Compteur
Resultats[1].Quand.Mois

Dans une instruction avec une instruction With, un indicateur de champ n'a pas à être précédé d'une référence de variable à son enregistrement contenant.

Désignateurs de composantes d'objets

Le format d'un identificateur de composante d'objet est le même que celui d'un identificateur de champ d'enregistrement; c'est-à-dire qu'il se compose d'une instance (une référence de variable), suivie d'un point et d'un identificateur de composante. Un désignateur de composante désignant une méthode est appelé un désignateur de méthode. Une instruction with peut être appliquée à une instance d'un type d'objet. Dans ce cas, l'instance et la période peuvent être omises lors du référencement des composantes du type d'objet. L'instance et le point peuvent également être omis dans n'importe quel bloc de méthode, et lorsqu'ils le sont, l'effet est le même que si Self et un point étaient écrits avant la référence de la composante.

Pointeurs et variables dynamiques

La valeur d'une variable de pointeur est soit NIL, soit l'adresse d'une variable dynamique. La variable dynamique pointée par une variable de pointeur est référencée en écrivant le symbole de pointeur (^) après la variable de pointeur. Vous créez des variables dynamiques et leurs valeurs de pointeur avec les procédures New et GetMem. Vous pouvez utiliser l'opérateur @ (adresse de) et la fonction Ptr pour créer des valeurs de pointeur étant traitées comme des pointeurs vers des variables dynamiques. Le NIL ne pointe vers aucune variable. Les résultats ne sont pas définis si vous accédez à une variable dynamique lorsque la valeur du pointeur est nulle ou non définie. Voici des exemples de références à des variables dynamiques :

P1^
P1^.Sibling^
Resultats[1].Donnees^

Castre de type variable

Une référence de variable d'un type peut être transformée en une référence de variable d'un autre type via un transtypage de variable.

Lorsqu'un transtypage de variable est appliqué à une référence de variable, la référence de variable est traitée comme une instance du type spécifié par l'identificateur de type. La taille de la variable (le nombre d'octets occupés par la variable) doit être la même que la taille du type désigné par l'identificateur de type. Un transtypage de variable peut être suivi d'un ou plusieurs qualificateurs, comme le permet le type spécifié.



Dernière mise à jour : Dimanche, le 15 novembre 2020