Variables

01 - Introduction 04 - Déclaration
02 - Nom des variables 05 - Affectation
03 - Type des variables 06 - Initialisation

01

Introduction

En Informatique, une variable est un nom qui renvoie à une position de mémoire. Une variable pourrait par exemple s'appeler « nombre_de_portes » et contenir un nombre. Tout comme en mathématiques, une variable représente donc une certaine valeur, qui peut être un nombre, une chaîne de caractères ...

Une variable a plusieurs caractéristiques, dont les plus importantes sont le nom et le type.

02

Nom des variables

Chaque variable possède un nom qui sert à l'identifier dans le code source. En Delphi, un nom de variable admissible commence par une lettre ou le blanc souligné « _ » (anglais : underscore) et peut être suivi d'une suite de symboles qui peuvent être des lettres, des chiffres ou le blanc souligné « _ ».

Exemples de noms admissibles:

Exemples de noms inadmissibles:

Afin de rendre le code source plus facile à lire et à comprendre, on essaie toujours de choisir des noms de variables qui donnent une indication sur l'usage envisagé de la variable.

Exemple
weekly_pay = hours_worked * pay_rate;

{ est plus compréhensible que }

a = b * c;

Pour améliorer l'apparence esthétique et professionnelle du code source, on utilise souvent une convention de nommage, qui est un ensemble de règles destinées à choisir la séquence de caractères à utiliser pour les noms de variables. En général, il s'agit de promouvoir un style de programmation clair et lisible à l'aide d'une approche structurée. Comme Delphi n'admit par exemple pas d'espace dans les noms de variables, il faut trouver un moyen pour écrire des noms de variables composés de plusieurs mots. Les deux approches les plus connues sont l'approche delimiter-separated words et letter-case-separated words.

L'approche delimiter-separated words délimite chaque mot par un caractère spécial, comme par exemple le blanc souligné « _ » ou le trait d'union « - ».

Exemples de noms de variables avec l'approche delimiter-separated words:

L'approche Letter-case-separated words (ou CamelCase) indique le début de chaque nouveau mot par une lettre majuscule.

Exemples :

Delphi ne distingue pas entre lettres masjuscules et minuscules. Les noms des variables « nom », « Nom » et « NOM » renvoient donc tous à la même variable!

03

Type des variables

Chaque variable possède un type qui sert à définir les valeurs admissibles qu'une variable peut prendre. Par exemple le type « integer » indique que cette variable peut seulement contenir des nombres entiers relatifs, alors qu'une variable du type « string » peut contenir des chaînes de caractères.

TypeValeur
integer nombre entier relatif
real nombre décimal
boolean true ou false
char un caractère
string une chaîne de caractères

Integer

Le type « integer » sert à stocker des nombres entiers relatifs. En Delphi, il a généralement une taille de quatre bytes dans la mémoire et peut donc prendre les valeurs allant de -231 à 231-1, ce qui correspond à l'intervalle [-2.147.483.648; 2.147.483.647].

Explications supplémentaires

Les nombres entiers relatifs sont stockés sous forme binaire dans quatre bytes, ce qui correspond à 4*8 = 32 bits. Comme le nombre peut être positif ou négatif, il nous faut un bit pour stocker la valeur du signe, laissant 31 bits pour la valeur du nombre. Avec 31 bits, on peut en effet générer tous les nombres allant de -231 à 231-1.

Real

Le type « real » sert à stocker des nombres décimaux. Cependant, il demande plus d'attention : vu que l'écriture décimale d'un nombre peut nécessiter une infinité de chiffres décimaux, une représentation fidèle ne peut pas être garantie dans l'ordinateur.

En Delphi, un nombre de type « real » est représenté par un nombre en virgule flottante (anglais : « floating point »). C'est une notation scientifique où la mantisse peut avoir jusqu'à 15 chiffres décimaux significatifs et où l'exposant est compris entre -324 et +308.

En Delphi, on utilise un point « . » pour séparer la partie entière de la partie décimale.

Exemples de nombres décimales:

Attention: Les nombres en virgule flottante sont toujours des approximations et ne doivent jamais être utilisés pour des calculs financiers où l'exactitude du résultat doit être garantie. De plus, les nombres en virgule flottante ne peuvent pas être comparés facilement : il est tout à fait possible que le nombre 5 est approximé une fois par 4.99999 et une fois par 5.00001.

Exemple: Si on additionne 10000 fois 0.0001, le résultat en Delphi est 1.00009999999991 et non 1.0 !

L'article Why Computers suck at maths est une lecture facile et intéressante et explique très bien pourquoi les ordinateurs ont de tels problèmes avec les nombres décimales.

Boolean

Le type « boolean » admet seulement deux valeurs : true et false. Ce type est utilisé pour représenter l'état de vérité, par exemple d'une condition. Une expression comme a<5 aura comme valeur true si a est effectivement inférieur à 5 et false dans le cas contraire.

Char

Le type « char » sert à stocker un seul caractère. En Delphi, on utilise l'apostrophe « ' » pour entourer le caractère. Les caractères permis sont ceux de la norme ASCII, qui est une norme de codage de caractères qui définit 128 caractères numérotés de 0 à 127.

Les 95 caractères ASCII affichables sont:

ascii.png

String

Le type « string » sert à stocker des chaînes de caractères. En Delphi, on utilise l'apostrophe « ' » pour entourer la chaîne de caractères. Si la chaîne contient elle-même une apostrophe, alors il faut en mettre deux de suite, sinon Delphi pense que cette apostrophe termine la chaîne. Ainsi l'expression « l'ordinateur » s'écrit 'l''ordinateur' en Delphi.

Il n'y a pas de restriction sur la taille d'une chaîne de caractères.

04

Déclaration

Pour pouvoir utiliser une variable, il faut spécifier le nom et le type de la variable au compilateur. Ce processus s'appelle la déclaration d'une variable.

Toutes les déclarations se font dans un endroit spécifique, qui est précédé du mot-clé var. Chaque déclaration doit respecter la structure suivante :

  1. le nom de la variable
  2. un double-point « : »
  3. type de la variable
  4. un point-virgule « ; »
Exemples de déclarations de variables
var
    nombreDePersonnes : integer;
    vitesseHorizontale : real;
    nomDuDirecteur : string;
    nombreAnneesBissextiles : integer;
    masculin : boolean;
    sexe : char;

Veuillez noter que les déclarations des variables ci-dessus sont indentées par rapport au mot-clé var. Ceci facilite énormément la lecture et la compréhension du code source.

Comme une variable doit toujours être déclarée avant la première utilisation, les déclarations doivent se trouver avant le bloc principal begin ... end;

Exemple de la structure d'un programme
program example;

var
    { déclarations des variables }

begin
    { instructions du bloc principal }
end.

Il est parfois utile de déclarer plusieurs variables du même type. Pour cela, il existe une notation simplifiée dans laquelle plusieurs noms de variables sont séparés par des virgules.

Exemples de la notation simplifiée
var
    nombreDePersonnes, nombreDeFemmes, nombreDeHommes : integer;
    nomSoeur, nomFrere, nomMere, nomPere : string;

05

Affectation

Le terme affectation désigne l'opération par laquelle on attribue une valeur à une variable. Chaque affectation doit respecter la structure suivante :

  1. le nom de la variable
  2. l'opérateur d'affectation, noté « := »
  3. une expression évaluable
  4. un point-virgule « ; »
Exemples d'affectations
nombreDePersonnes := 2 * 5;
vitesseHorizontale := 1.85;
nomDuDirecteur := 'Salentiny';
nombreAnneesBissextiles := 24;
masculin := true;
sexe := 'f';

Lorsque l'évaluateur du code source rencontre une opération d'affectation, il commence par l'expression à droite de l'opérateur « := ». Si l'expression contient des variables, elles sont remplacées par leurs valeurs respectives. Ensuite, l'évaluateur affecte le résultat de l'expression à la variable dont le nom se trouve à gauche de l'opérateur « := ».

Exemples d'expressions
vitesseVerticale := -9.8 * 7.0;
nomCompletDuDirecteur := 'Jos ' + nomDuDirecteur;
maturite := (age >= 18);
volumeCylindre := pi * rayon * rayon * hauteur;

En Informatique, il est même possible d'utiliser dans l'expression de droite la variable, à laquelle on veut affecter la valeur.

Exemples
i := i + 1;
nombre := nombre * 3;
nombre := -nombre;

Pour qu'une affectation soit possible, il faut que le résultat de l'expression de droite existe et soit du même type que la variable. Une des rares exceptions est le type integer, qui peut aussi être affecté à une variable de type real ; le contraire n'est pourtant pas possible.

Exemples d'affectations invalides
var
    nombre : integer;
    nombreDecimal : real;
    lettre : char;

begin
    nombre := 3.5;          { affectation invalide : différence de type }
    nombre := 10 / 2;       { affectation invalide : l'opérateur « / » rend toujours le type real }
    nombreDecimal := '3.5'; { affectation invalide : différence de type }
    lettre := 'bonjour';    { affectation invalide : différence de type }
end.

06

Initialisation

Lorsqu'une variable est déclarée, l'espace nécessaire est réservée dans la mémoire de l'ordinateur. La gestion de la mémoire est un des rôles d'un système d'exploitation.

Voici une représentation possible de la mémoire, contenant deux variables de type integer avec les valeurs respectives « -375 » et « 23 », une variable de type string avec la valeur « test » et une variable de type boolean avec la valeur « true » :

memoire.png

Lorsque les variables ne sont plus utilisées, par exemple après fermeture d'un programme, les espaces mémoires sont libérés et peuvent désormais être réservés par d'autres programmes. Cependant, les espaces mémoires sont rarement effacés; ceci nécessiterait trop de temps!

Après la déclaration de la variable, celle-ci contient donc déjà une valeur, même si on n'a pas encore affectée explicitement une valeur à cette variable. Comme cette valeur est complètement aléatoire, l'utilisation de cette variable dans une expression peut mener à des résultats inattendus, qui seront vraisemblablement faux.

Il faut donc veiller à toujours affecter une valeur à une variable avant la première utilisation. Cette première affectation s'appelle l'initialisation de la variable.

Il n'est pourtant pas nécessaire d'initialiser chaque variable avec une valeur fixe, cette valeur peut aussi provenir d'une saisie au clavier, du résultat d'une fonction, d'un nombre aléatoire ...

Exemples d'utilisations de variables non-initialisées
{
 Le programme suivant affiche la valeur d'une variable de type integer qui n'est pas initialisée:
}

program exemple;

var
  nombre : integer;

begin
  writeln(nombre);
  readln;
end.

{
 Cinq exécutions de ce programme affichent successivement:
 2147332096
 2147323904
 2147299328
 2147348480
 2147303424
}
Sign In