Licence CC BY-NC-SA

Variables I : Typage et affectation

Publié :

Nous avons dors et déjà réalisé notre premier programme. Mais chacun comprend vite les limites de notre programme "Hello". À dire vrai, un tel programme n'apporte absolument rien. Ce qui serait intéressant, ce serait que l'utilisateur de notre programme puisse entrer des informations que l'ordinateur lui demanderait. Par exemple :

1
Quel âge avez-vous ? _

Et là nous pourrions entrer 25, 37 ou 71. Le programme pourrait ensuite se charger d'enregistrer cette information dans un fichier, de nous avertir si nous sommes considérés comme majeur dans l'état du Minnesota ou encore de nous donner notre âge en 2050… Autant d'applications que nous ne pourrons pas réaliser si l'âge que l'utilisateur indiquera n'est pas enregistré dans une zone de la mémoire.

Et c'est là que les variables interviennent ! Attention, ce chapitre n'est peut-être pas exaltant mais il est absolument nécessaire à la compréhension des prochains.

Déclaration de variables

Nous allons reprendre l'exemple de l'introduction. Nous voulons indiquer un âge à notre programme. Nous aurons donc besoin d'un espace mémoire capable de stocker un nombre entier. Il faudrait effectuer une demande d'allocation d'une zone mémoire et retenir l'adresse mémoire qui nous a été attribuée et la taille de la zone allouée.

Euh… c'était pas marqué Niveau facile ? o_O

Pas d'inquiétude. Tout cela, c'est ce qu'il aurait fallu faire (entre autre) si nous n'avions pas utilisé un langage comme Ada. C'est ce qu'on appelle un langage de haut niveau, c'est-à-dire que l'on n'aura pas besoin de se casser la tête pour faire tout cela. Il suffira de dire « Je veux de la mémoire !».

Toutefois, l'ordinateur a tout de même besoin de connaître la place mémoire dont vous aurez besoin et cela dépend du type d'information que l'on souhaite y enregistrer. Ici, nous voulons enregistrer un nombre entier que nous appelons age. Le mot age est le nom de notre variable, c'est-à-dire l'endroit de la mémoire où seront enregistrées nos informations. Pour faire tout cela, il faut déclarer notre variable (comme on le ferait à la douane, cela permet de savoir qui vous êtes et comment vous retrouver). Une déclaration se fait toujours de la façon suivante :

NOM_DE_LA_VARIABLE : TYPE ;

Il est possible de déclarer plusieurs variables d'un coup de la manière suivante :

NOM_DE_LA_VARIABLE1 , NOM_DE_LA_VARIABLE2 : TYPE ;

Il est aussi possible, aussitôt la variable déclarée, de lui affecter une valeur à l'aide du symbole « := ». On écrira alors :

NOM_DE_LA_VARIABLE : TYPE := VALEUR ;

Où dois-je faire cette déclaration ? En préfecture ? :(

Vous vous souvenez notre premier programme ? Je vous avais parlé d'une zone réservée aux déclarations (entre is et begin). Et bien c'est ici que nous déclarerons notre variable.

1
2
3
4
5
6
Procedure VotreAge is
   NOM_DE_LA_VARIABLE1 : TYPE1 := VALEUR ; --zone réservée aux déclarations
   NOM_DE_LA_VARIABLE2 : TYPE2 ; 
begin
   Put("Quel age avez-vous ?") ; 
end ;

Bien, il est temps de rentrer dans le vif du sujet : comment déclarer notre variable âge ?

Différents types

Les types Integer et Natural

Définition

Le type Integer est réservé aux nombres entiers relatifs. Pour ceux qui ne se souviendraient pas de leur cours de mathématiques, un entier est un nombre «qui n'a pas de chiffres après la virgule à part 0». Relatif signifie que ces entiers peuvent être positifs (avec un signe +) ou négatifs (avec un signe -).

Le type Natural est réservé aux nombres entiers naturels (c'est-à-dire positifs ou nul). Il est donc impossible, si vous déclarez votre variable comme un Natural, que celle-ci soit négative (ou alors vous planterez votre programme). Pour être plus précis, c'est un sous-type du type Integer. Quelle importance ? Eh bien, cela signifie que l'on pourra «mélanger» les natural et les Integer sans risquer le plantage : nous pourrons les additionner entre eux, les soustraire, les multiplier… ce qui n'est pas possible avec d'autres types. La seule restriction est que notre natural ne devienne pas négatif.

Valeurs possibles

Si N est une variable de type Integer, elle peut prendre les valeurs suivantes : 0 ; 1 ; 2 ; 3 ; 4… 2 147 483 647 -1 ; -2 ; -3… - 2 147 483 648

On remarquera qu'il y a moins de positifs que de négatifs. Cela tient à une raison toute simple, c'est que 0 est compté comme un positif et pas comme un négatif. Comme le nombre d'octets nécessaires à l'enregistrement d'un nombre est limité (ici 31 bits pour la partie numérique et 1 bit pour le signe soit 32 bits = 4 octets), cela implique que l'on peut aller «moins loin dans les positifs que dans les négatifs».

Si N est une variable de type Natural, elle peut prendre les valeurs suivantes : 0 ; 1 ; 2 ; 3 ... 2 147 483 647

On remarque qu'il ne s'agit là que d'une restriction du type Integer. Comme je vous l'ai dit, Natural est un sous-type de Integer (noté subtype en Ada). Il n'y a donc pas davantage de Natural que d'Integer positifs ou nuls.

Il existe également un type Positive, semblable aux Natural mais pour lequel 0 est exclu.

Exemple

Nous souhaiterions créer un programme qui affiche votre âge. Au début de notre code, nous devrons donc écrire :

1
2
3
4
Procedure VotreAge is
   age : Integer := 27; 
begin 
...

Ou bien, sans affecter de valeur :

1
2
3
4
Procedure VotreAge is
   age : Integer ; 
begin 
...

Si nous voulons pouvoir afficher des Integer ou des Natural, il faudra ajouter Ada.Integer_Text_IO dans la listes des packages. Ce package contient une instruction Put() prévue spécifiquement pour les nombres entiers. Attention, il existe donc deux instructions Put() différentes : une pour le texte et une pour les entiers ! Une dans le package Ada.Text_IO et une dans Ada.Integer_Text_IO. Réalisons maintenant ledit programme et voyons le résultat :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
WITH Ada.Text_IO ;            USE Ada.Text_IO
WITH Ada.Integer_Text_IO ;    USE Ada.Integer_Text_IO ;

PROCEDURE VotreAge IS
   age : Integer := 27 ; 
BEGIN
   Put("Vous avez ") ; 
   Put(age) ; 
   Put(" ans.") ; 
END VotreAge ;
1
Vous avez        27 ans.

Pourquoi tout cet espace avant 27 ? :o

Par défaut, l'instruction Ada.Integer_Text_IO.Put() (c'est son nom complet) réserve toujours la même place pour afficher des entiers, qu'ils soient petits ou grands. Mais il est possible de spécifier la taille de cet emplacement. Pour cela, il y a possibilité d'ajouter des « options » à notre instruction Put() (on parle plus exactement de paramètres). Juste après age, il vous suffit d'écrire une virgule suivie de « Width => ### ». Vous remplacerez les dièses par le nombre de chiffres à afficher. Ce paramètre Width est un mot anglais qui signifie « Largeur ». Par exemple :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
WITH Ada.Text_IO ;            USE Ada.Text_IO
WITH Ada.Integer_Text_IO ;    USE Ada.Integer_Text_IO ;

PROCEDURE VotreAge IS
   age : Integer := 27 ; 
BEGIN
   Put("Vous avez ") ; 
   Put(age, Width => 0) ; 
   Put(" ans.") ; 
END VotreAge ;

En inscrivant « Width => 0 », on indique que l'on ne veut afficher aucun chiffre. Mais le langage Ada étant bien conçu, il affichera tout de même les chiffres réellement utiles, mais pas un de plus ! Ce qui nous donnera :

1
Vous avez 27 ans.

Le type Float

Définition

Le type float est chargé de représenter les nombres décimaux. Dans les faits, il n'en représente en fait qu'une partie (comme les Integer ne couvrent pas tous les nombres entiers).

Autant Natural = Naturel ; Integer = Entier, ça semblait évident, autant là : Float = Décimal !?! Je vois mal la traduction.

Retenez qu'en réalité il ne s'agit pas de décimaux mais de nombre dits à «virgule flottante». Nous n'entrerons pas dans le détail pour l'instant, mais lorsque l'ordinateur enregistre un nombre en «virgule flottante», il enregistre le signe, un nombre entier (les chiffres de notre nombre) plus un autre nombre qui indiquera l'emplacement de la virgule. Plus de détails seront donnés dans la quatrième partie.

Valeurs possibles

Si X est une variable de type float, elle peut prendre les valeurs suivantes : 0.0 ; 1.0 ; 2.0… 3,40282E38 (un nombre avec 39 chiffres) -1.0 ; -2.0… -3,40282E38 (un nombre avec 39 chiffres) 1.5 ; - 2.07 ; 3.141592

Vous remarquerez deux choses : tout d'abord 1, 2, 3… sont notés (et doivent être notés) 1.0, 2.0, 3.0… Ensuite, le nombre Pi n'existe pas même s'il existe le nombre 3.141592 (une valeur approchée). Le type float ne contient donc pas les réels mais des décimaux (indication pour les matheux. :) )

Exemple

Voilà ce que donnerait le début d'un programme demandant votre taille et votre poids :

1
2
3
4
5
Procedure TaillePoids is
   Taille : Float := 1.85 ; 
   Poids : Float := 63.0 ; 
begin 
...

Ou bien, sans affecter de valeur et en déclarant les deux variables en même temps :

1
2
3
4
Procedure TaillePoids is
   Taille, Poids : Float ; 
begin 
...

Et si vous souhaitez afficher des variables de type Float, il faudra ajouter Ada.Float_Text_IO dans la listes des packages. Une instruction Put() spécifique aux Float y est enregistrée. Prenez l'exemple suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
WITH Ada.Text_IO ;                USE Ada.Text_IO ;
WITH Ada.Float_Text_IO ;          USE Ada.Float_Text_IO ;

Procedure TaillePoids is
   Taille : Float := 1.85 ; 
   Poids : Float := 63.0 ; 
begin 
   Put("Votre taille est de ") ; --On affiche du texte (package Ada.Text_IO)
   Put(Taille) ;                 --On affiche un Float (package Ada.Float_Text_IO)
   New_line ; 
   Put("Votre poids est de ") ;  --On affiche du texte (package Ada.Text_IO)
   Put(Poids) ;                  --On affiche un Float (package Ada.Float_Text_IO)
   New_line ; 
End TaillePoids ;

Ce programme est censé afficher une taille (1m85) et un poids (63kg). Mais contrairement à toute attente, voici le résultat :

1
2
Votre taille est de 1.85000E+00
Votre poids est de 6.30000E+01

Qu'est-ce que c'est que ce charabia ? C'est à moi de remettre les chiffres dans l'orde ?

En fait, les nombres à virgule flottante sont enregistrés dans l'ordinateur en écriture scientifique, c'est à dire sous la forme $1,85 = 1,85 \times 10^0$ et $63 = 6,3 \times 10^1$ (plus de détail seront donnés lors du troisième chapitre sur les variables). Le E majuscule remplace ici la multiplication par une puissance de 10. Je me doute que vous préféreriez vous passer de cette écriture scientifique ainsi que de tous les 0 inutiles après la virgule. Pour cela, il suffit d'utiliser deux paramètres, Exp et Aft. Exp est le diminutif d'exposant (ou puissance si vous préférez) ; il suffit d'indiquer 0 pour que celui-ci ne soit pas affiché. Aft est l'abréviation du mot anglais « After », qui signifie « Après » ; celui-ci permet de préciser le nombre minimum de chiffres désirés après la virgule. Si vous indiquez 0, Ada n'affichera de chiffres après la virgule que si nécessaire. Modifions donc le code précédent et observons le résultat :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
WITH Ada.Text_IO ;                USE Ada.Text_IO ;
WITH Ada.Float_Text_IO ;          USE Ada.Float_Text_IO ;

Procedure TaillePoids is
   Taille : Float := 1.85 ; 
   Poids : Float := 63.0 ; 
begin 
   Put("Votre taille est de ") ;
   Put(Taille, Exp => 0, Aft => 0) ; 
   New_line ; 
   Put("Votre poids est de ") ;
   Put(Poids, Exp => 0, Aft => 0) ; 
   New_line ; 
End TaillePoids ;
1
2
Votre taille est de 1.85
Votre poids est de 63

Un paramètre Fore existe également pour Ada.Float_Text_IO.Put(), l'instruction Put() pour les nombres à virgule flottante. C'est le diminutif du mot anglais « Before » qui signifie « Avant ». Ce paramètre indique la place nécessaire pour afficher les chiffres avant la virgule. Un équivalent du paramètre Width pour les entiers, en quelques sortes.

Le type Character

Définition

Le type Character est réservé pour les caractères, c'est-à-dire les lettres. Toutefois, les espaces et les tabulations constituent aussi des caractères de même que le retour à la ligne, la fin de fichier… qui sont des caractères non imprimables. Une variable de type Character ne peut pas contenir une phrase mais un seul caractère.

Valeurs possibles

Si C est une variable du type Character, elle peut prendre les valeurs suivantes : 'a', 'b', 'c', 'z', 'A', 'B', 'C', 'Z', '#', ' ', '%'

Les lettres doivent être entourées par deux apostrophes, l'espace y-compris. De plus, 'a' et 'A' sont deux types Character différents.

Les lettres accentuées (é, à, è…) ne sont pas prises en charge. Ce sont les symboles anglo-saxons qui priment par défaut !

En réalité, les characters ont les valeurs suivantes : 0, 1, 2… 255. Les ordinateurs ne gèrent pas les lettres, mais les chiffres oui ! À chacun de ces nombres est associé un caractère. Dans certains langages, il est donc possible d'écrire 'a'+1 pour obtenir 'b'. Mais le langage Ada, qui a un typage fort (certains diront excessif), empêche ce genre d'écriture : une lettre plus un nombre, c'est une aberration en Ada. :colere: Ne vous inquiétez pas, nous verrons plus tard les opérations possibles sur les Character.

Exemple

Si nous voulons pouvoir utiliser les Character, il suffit d'avoir écrit Ada.Text_IO dans la listes des packages :

1
2
With Ada.Text_IO ; 
Use Ada.Text_IO ;

Et voilà pour le début d'un programme qui demanderait votre initiale :

1
2
3
4
Procedure Initiales is
   Ini : Character := 'K' ;  --Comme Kaji9 :-)
begin 
...

Affectation

Maintenant que l'on sait déclarer les principaux types de variables, voyons comment leur attribuer une valeur (on dit qu'on leur affecte une valeur). En effet, nous avons réquisitionné une zone de la mémoire de notre ordinateur mais il n'y a encore rien d'écrit dedans. Pour cela, revenons à notre programme VotreAge :

1
2
3
4
5
6
7
with Ada.Text_IO, Ada.Integer_Text_IO ; 
use Ada.Text_IO, Ada.Integer_Text_IO ; 

Procedure VotreAge is
   Age : integer ; 
Begin
   …

Il y a deux personnes qui peuvent affecter une valeur à la variable Age : vous (le programmeur) ou l'utilisateur (peut-être vous aussi, mais pas dans le même rôle).

Affectation par le programmeur (ou le programme)

On va utiliser le symbole « := » vu auparavant, mais cette fois, après le Begin.

1
2
3
4
5
6
7
8
with Ada.Text_IO, Ada.Integer_Text_IO ; 
use Ada.Text_IO, Ada.Integer_Text_IO ; 

Procedure VotreAge is
   Age : integer ;    --On déclare notre variable Age, mais elle n'a aucune valeur
Begin
   Age := 27 ;        --On affecte une valeur à la variable Age
End VotreAge ;

Ce programme se contentera d'affecter 27 à une variable Age.

Affectation par l'utilisateur

Nous savons comment poser une question à l'utilisateur avec l'instruction Put(). Pour récupérer sa réponse, on utilisera l'instruction Get().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
with Ada.Text_IO, Ada.Integer_Text_IO ; 
use Ada.Text_IO, Ada.Integer_Text_IO ; 

Procedure VotreAge is
   Age : integer ; 
Begin
   Put("Quel age avez-vous ?") ;      -- on est poli, on demande l'âge.
   Get(Age) ;                         -- Puis, on saisit la réponse de l'utilisateur
   Skip_line ;                        -- ???
   Put("Ah, vous avez ") ; Put(Age) ; -- on fait une phrase affichant la réponse
End VotreAge ;

C'est pas trop compliqué. Sauf que, c'est quoi ce Skip_line ?

L'instruction Skip_line

Skip_line est une instruction que je vous conseille fortement d'écrire après chaque utilisation de l'instruction Get(). Pour comprendre son utilité, reprenons l'exemple du programme TaillePoids :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
with Ada.Text_IO, Ada.Float_Text_IO ; 
use Ada.Text_IO, Ada.Float_Text_IO ; 

Procedure TaillePoids is
   Taille, Poids : float ; 
Begin
   Put("Quelle est votre taille ?") ;
   Get(Taille) ;
   Put("Vous mesurez ") ; 
   Put(Taille) ; 
   Put(" m.") ; 

   Put("Quel est votre poids ?") ;
   Get(Poids) ;

   Put("Vous pesez ") ; 
   Put(Poids) ; 
   Put(" kg.") ; 

End TaillePoids ;

Puis voyons ce qu'il se passe dans la console.

1
2
3
4
Quelle est votre taille ? 1.8R
Vous mesurez 1.8 m. 
Quel est votre poids ?
raised ADA.IO_EXCEPTIONS.DATA_ERROR : a-tiinio.adb:89 instantiated at a-inteio.ads:18

Notre utilisateur a tapé 1.8R au lieu de 1.85 (erreur de frappe). Logiquement, le programme plante. Mais regardons en détail ce qu'il s'est passé. La taille enregistrée est 1.8, le R n'a pas été pris en compte. Alors pourquoi le programme ne nous laisse-t-il pas entrer une nouvelle taille ? Pourquoi détecte-t-il une erreur alors que nous n'avons entré aucun poids ? Et qui plus est : pourquoi ne la détecte-t-il pas plus tôt ?

En fait, en tapant 1.8R nous avons envoyé dans le buffer (la mémoire tampon) 1.8 puis R puis le «Entrée» (qui constitue également un caractère). L'instruction Get(Taille) s'est emparée de 1.8, mais le R est resté en mémoire tampon puisqu'à l'évidence, il ne faisait pas partie du nombre demandé. Par conséquent, l'instruction Get(Poids) a regardé dans le buffer ce qu'il y avait à récupérer : la lettre R que vous aviez tapé par erreur ! L'instruction Get(Poids) s'est donc emparée du R qui est un character et non un Float. D'où l'erreur.

Et Skip_line dans tout ça ? o_O

Et bien l'instruction Skip_line aurait évité cette erreur, car Get(Taille) aurait saisit 1.8 pour la taille (comme tout à l'heure) et Skip_line aurait ensuite vidé la mémoire tampon : plus de R ou de touche "entrée" en mémoire. Nous aurions ainsi pu saisir notre poids tranquillement.

Attention ! Skip_line n'est pas fait pour gérer des erreurs. Il vide seulement la mémoire tampon (appelée buffer), mais pensez à l'écrire après chaque instruction Get() !

Voici le code, corrigé avec Skip_line :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
with Ada.Text_IO, Ada.Float_Text_IO ; 
use Ada.Text_IO, Ada.Float_Text_IO ; 

Procedure TaillePoids is
   Taille, Poids : float ; 
Begin
   Put("Quelle est votre taille ?") ;
   Get(Taille) ; Skip_line ;
   Put("Vous mesurez ") ; 
   Put(Taille) ; 
   Put(" m.") ; 

   Put("Quel est votre poids ?") ;
   Get(Poids) ; Skip_line ; 
   Put("Vous pesez ") ; 
   Put(Poids) ; 
   Put(" kg.") ; 

End TaillePoids ;

Compléments

Cette dernière partie est plus technique. Si vous voulez éviter les confusions, je vous conseille de relire ce qui précède et de faire des exemples (c'est en forgeant que l'on devient forgeron ^^ ). Toutefois, je vous invite à revenir lire ce qui suit, aussitôt que vous maîtriserez les notions de types car les constantes et les attributs (surtout les attributs) nous serons forts utiles par la suite.

Constantes

Une variable peut… varier. Étonnant non ? :p Ce n'est pas parce que vous l'avez initialisée à 15 qu'elle ne peut pas être modifiée plus tard pour valoir, par exemple, 18, bien au contraire. C'est d'ailleurs là tout leur intérêt.

1
2
3
N := 10 ;     --la variable N prend la valeur 10
N:= 13 ;      --Puis la valeur 13
N:= 102 ;     --Et enfin la valeur 102 !

Mais il est parfois intéressant de fixer leur valeur une fois pour toute. La variable ne varie alors plus, elle devient une constante et doit être déclarée de la manière suivante :

1
MaVariable : Constant Integer := 15 ;

Nous avons ainsi une variable MaVariable qui vaudra toujours 15. Tentez seulement de modifier cette valeur et vous entraînerez un plantage de votre programme (ou plutôt, votre compilateur refusera de compiler votre code).

Mais à quoi servent les constantes ?

Quelques exemples simples. Une variable peut contenir le titre de votre nouveau jeu ou les dialogues des personnages. Mieux vaudrait que le compilateur vous prévienne si ces variables sont malencontreusement modifiées. Autre exemple :

1
PI : Constant Float := 3.1415926535 ;

Chacun comprend que si la valeur de ma variable PI est modifiée, tous mes calculs d'aire de disque, de périmètre de cercle ou de volume de boule… seront faux. Donc PAS TOUCHE À MA CONSTANTE ! ! ! :lol:

Attributs

Comment obtenir le plus petit et le plus grand Integer ? Comment savoir quel est le 93ème character ? Grâce aux attributs, bien sûr. Ce sont des sortes d'instructions qui s'appliquent aux types.

Avant d'en voir quelques uns, voici un petit rappel de vos cours d'anglais : Repeat after me. «It is Susan's dog» signifie «le chien de Susan». Ainsi, le petit mot " 's" exprime l'idée d'appartenance et il faut penser à inverser l'ordre des noms par rapport au français. Pourquoi ce rappel ? Eh bien parce que les attributs s'utilisent de la même manière :

1
2
3
4
N := integer'first ;      --N sera le premier des integer
M := integer'last ;       --M sera le dernier des integer
C := character'val(93) ;  --C sera la 93ème valeur des character
P := character'pos('f') ; --P aura pour valeur la position du character 'f'

N, M et P doivent être déclarés comme des Integer, alors que C est un character !

Nous reverrons plus abondamment les attributs dans les chapitres suivants. Commencez déjà par vous faire la main sur ces quatre là : quel est le plus petit float ? Le plus grand ? Quelle est la position de 'a' et du 'A' ?

Bloc de déclaration

Lorsque vous déclarez une variable ou une constante, cela se fait toujours au sein de la zone réservée aux déclarations : entre les mots clés IS et BEGIN. Comme nous l'avons dit, c'est à ce moment que votre programme va demander à l'ordinateur s'il peut lui emprunter de la mémoire.

Mais quand notre programme rend-il la mémoire empruntée ?

La mémoire est libérée une fois le programme rendu à l'instruction « END Bidule ; » (où Bidule est bien sûr le nom de votre programme). Et jusqu'à ce moment là, deux variables ne pourront porter le même nom.

Comment je fais si j'ai besoin d'une variable supplémentaire en cour de route ? Et si une variable ne me sert plus à rien au bout de 2 ou 3 ligne ?

La règle de base reste la même : il faut tout déclarer dès le départ et la mémoire réquisitionnée ne sera rendue qu'à la fin du programme. C'est une obligation en Ada et vous verrez, si vous vous essayez à d'autres langages, que c'est une bonne pratique qui structure clairement votre code et évite bon nombre de problèmes. Toutefois, il peut arriver (nous nous en rendrons compte avec les tableaux) que nous ne puissions déclarer une variable dès le départ. Ou bien, une variable peut tout à fait n'avoir qu'un rôle minime à jouer et il est alors intelligent de la détruire une fois inutile afin de dégager de la mémoire. Ada a prévu cette éventualité en proposant des blocs de déclaration.

Pour ouvrir un bloc de déclaration, vous devez utiliser le mot clé DECLARE. Vous pourrez ensuite déclarer vos variables supplémentaires. Une fois les déclarations terminées, vous indiquerez la reprise d'activité par le mot BEGIN. Les variables supplémentaires seront finalement détruites par l'ajout d'un nouveau END. Un exemple pour mieux comprendre :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
PROCEDURE Mon_Programme IS
BEGIN

   DECLARE
      Ma_Variable_Supplementaire : Integer ; 
   BEGIN
      --Instructions quelconques faisant intervenir Ma_Variable_Supplementaire
   END ; --Fin du bloc de déclaration

END Mon_Programme ;

Pour plus de clarté, il est également possible de nommer ce bloc de déclaration de la même façon que l'on déclare une variable :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
PROCEDURE Mon_Programme IS
BEGIN

   Bloc_Declaration : DECLARE
      Ma_Variable_Supplementaire : Integer ; 
   BEGIN
      --Instructions quelconques faisant intervenir Ma_Variable_Supplementaire
   END Bloc_Declaration ; --Fin du bloc de déclaration

END Mon_Programme ;

La variable supplémentaire est ainsi créée à la ligne 5 et pourra être utilisée entre les lignes 6 et 8, mais pas au-delà. Elle sera détruite dès que le programme arrivera à l'instruction « END Bloc_Declaration ; ». Il est donc interdit que la variable supplémentaire porte le même nom que les variables de départ, mais il est possible de créer deux variables de même nom si elles sont des blocs de déclaration distincts :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
PROCEDURE Mon_Programme IS
BEGIN

   Bloc_Numero1 : DECLARE
      X : Float; 
   BEGIN
      --Instructions quelconques faisant intervenir X
   END Bloc_Numero1 ; 

   Bloc_Numero2 : DECLARE
      X : Float; 
   BEGIN
      --Instructions quelconques faisant intervenir X
   END Bloc_Numero2 ; 

END Mon_Programme ;

On comprend sur l'exemple précédent que la première variable X, créée à la ligne 5, meurt à la ligne 8. Il est donc possible d'en créer une nouvelle à la ligne 11 et portant le même nom. Si le bloc de déclaration ne vous sera pas utile pour l'instant (on peut souvent s'en passer en organisant mieux son code), il nous servira tout de même très bientôt.

Nous savons maintenant déclarer une variable et lui affecter une valeur. Nous avons vu également quelques types de variables. Nous serons amenés par la suite à voir d'autres types plus complexes (tableaux, chaînes de caractères, classes, pointeurs…). Avant cela, nous devrons voir un second chapitre sur les variables. C'est en effet intéressant de les avoir enregistrées en mémoire, mais il serait bien plus intéressant de pouvoir les modifier à l'aide de quelques formules mathématiques simples.


En résumé :

  • Pour enregistrer vos résultats, vous devez déclarer des variables qui correspondent à des emplacements en mémoire. La déclaration se fait entre les mots clés IS et BEGIN.
  • Toute variable déclarée doit avoir un type bien précis. Nous avons vu 3 grandes familles de types : les entiers (Integer ou Natural), les flottants qui correspondent aux nombres décimaux (Float) et les caractères (Character).
  • L'assignation d'une valeur à une variable peut se faire de deux façons : soit en laissant le soin à l'utilisateur de choisir soit en codant cette valeur en utilisant l'opération d'affectation (« := »). Les deux méthodes ne sont pas exclusives et vous pouvez bien sûr mixez les deux.
  • Si certaines variables ne devraient jamais être modifiées, déclarez-les plutôt comme des constantes avec le terme CONSTANT. En cas d'erreur de votre part, le compilateur vous l'indiquera, évitant ainsi le plantage de votre programme.