Noms

Noms, attachement, porté, vérification de type
Plan:
• Noms, variables
• Attachement
• Porté
• Constantes
• Initialisation des variables
• Vérification de type
• Compatibilité de type
CSI 3525, Noms etc., page 1
Noms et variables
Points à discuter:
• Qu’est-ce qui nécessite un nom?
• Un variable, en tant que six-tuplet
CSI 3525, Noms etc., page 2
Noms
• Un nom est un descripteur pour une entité
dans un programme. On réfère aux entités
par leur nom, quand on veut les créer, les
utiliser, les modifier et les détruire.
• Déclaration, usage, durée de vie et porté des
noms: ces propriétés sont importantes pour
les langages de programmation.
CSI 3525, Noms etc., page 3
Pourquoi a-t’on besoin de noms?
• constantes, variables,
• opérateurs,
• étiquettes « label »,
• types,
• procédures, fonctions,
• modules, programmes,
• fichiers, disques,
• commandes, items d’un menu,
• ordinateurs, réseaux, utilisateurs (login).
CSI 3525, Noms etc., page 4
Noms et Identificateurs
• Un nom est dénoté par un identificateur.
•
En générale, les identificateurs sont formes de
lettres, chiffres et traits de soulignement
« underscore ». Prolog, Perl et Scheme
permettent plus.
• Une discussion de la forme des identificateurs:
manuel, Section 5.2.
CSI 3525, Noms etc., page 5
• Les mots clefs (e.g. for, if, int, new…) servent de
balises syntaxique dans un programme. Considérez:
if ( C ) S1 else S2
• En fait, ce n’est qu’un triplet: C - S1 - S2, qui aurait
aussi bien pu être défini comme:
If C then S1 else S2 end if;
ou
{C -> S1 ; S2}
en autant que le compilateur et les programmeurs
comprennent tous deux son sens profond.
• De même,
while ( C ) S
ou
while C do S
est essentiellement un paire: C - S.
CSI 3525, Noms etc., page 6
• D’un autre coté, les mots clefs déterminent le style
d’un langage.
• Ils permettent de rendre un programme lisible.
• Il serait très facile de substituer les mots clefs d’un
langage: ça serait une modification triviale de
l’analyseur lexical, par exemple, de lui faire
reconnaître:
si C alors S1 sinon S2 fin si;
Au lieu de
if C then S1 else S2 end if;
CSI 3525, Noms etc., page 7
Variables
• Une variable, dans un langage impératif, est un six-tuplet:
‹nom, adresse, valeur, type, durée de vie, porté›
•
Par exemple:
int x;
on décide le nom et le type de x.
• L’endroit ou la déclaration se trouve dans un programme
détermine où et combien longtemps x est disponible (porté,
durée de vie). Son adresse est déterminée lors de
l’exécution. Finalement, l’utilisation de x dans une
instruction décidera de sa valeur.
CSI 3525, Noms etc., page 8
• Un problème pour plusieurs langages de programmation:
un même nom peut être utilisé dans différents contextes, et
dénoter différentes entités:
void a(){
int b;
...
}
void b(){;
int a;
...
}
• Différent types, adresses et valeurs peuvent être associés aux
différentes occurrences du nom. Chaque occurrence a une
différente durée de vie (quand et pour combien longtemps estelle créée, et une différente porté (où peut-elle être utilisée).
CSI 3525, Noms etc., page 9
Valeur d’une variable
• Le concept de valeur est plus générale:
l-value (l pour « left ») et r-value (r pour « right »)
représentent la source et la destination d’une assignation.
exemple:
x = y;
• La l-value est l’adresse de x, et la r-value est la valeur de
y. Ceci devient compliqué pour les éléments de tableaux
dénoté par des indexes devant être évaluée:
T[i*2+1] = y;
• Cet index adresse dépend de la valeur courante de i.
CSI 3525, Noms etc., page 10
Attachement « binding »
• Points:
• Une présentation informelle
• Attachement en différent temps
• Attachement d’une variable
• Porté
CSI 3525, Noms etc., page 11
Attachement
• L’attachement n’est pas formellement défini. Intuitivement, on
associe (ou attache) un attribut à un objet. Les attributs peuvent
être des noms, types, valeurs.
• L’attachement peut se faire à différent moments. On considère
normalement trois périodes:
• À la compilation (en fait, à la traduction, parce que
l’attachement se fait dans les compilateurs et les
interpréteurs);
• Au chargement (Lorsque le code objet est préparé pour
l’exécution, quand le code nécessaire aux instructions
prédéfinies du langage ou aux librairies utilisées est obtenu);
• À l’exécution (Lors de l’exécution du programme).
CSI 3525, Noms etc., page 12
Attachement Statique et Dynamique
• On distingue aussi deux types d’attachement selon
sa durée:
• Attachement statique est permanent, pour la
durée du programme;
• Attachement dynamique effectif durant certaines
parties de l’exécution seulement.
CSI 3525, Noms etc., page 13
Assigner des propriétés aux variables
• variable  nom
• À la compilation
– Décrit dans les déclarations
• variable  adresse
• Au chargement et à l’exécution (e.g. C),
• à l’exécution (e.g. Smalltalk)
– Habituellement fait implicitement
• variable  type
• À la compilation (e.g. Java),
• à l’exécution (e.g. Scheme)
– décrit dans la déclaration
CSI 3525, Noms etc., page 14
• variable  valeur
• à l’exécution,
• Au chargement (initialisation)
– Spécifié dans les instructions, surtout les
assignations
• variable  durée
• à la compilation
– Décrit dans la déclaration
• variable  porté
• à la compilation
– Exprimé par l’emplacement des déclarations
CSI 3525, Noms etc., page 15
Durée de vie
• L’attribution de la mémoire pour un objet se fait au
chargement. Deux classes de variables peuvent être
distinguées:
• Variables statique
• Variables dynamiques
CSI 3525, Noms etc., page 16
Variables statiques
• L’attribution se fait une seul fois, avant le début du
programme.
• Fortran IV est un langage important ou c’est la seul
façon d’attribuer la mémoire aux objets.
• Ceci est désuet, trop rigide, mais conceptuellement
simple et peux coûteux. Ceci rend la récursivité
impossible.
CSI 3525, Noms etc., page 17
Variables dynamiques
• L’attribution se fait après le début du programme, lors
de son exécution.
• Deux possibilités d’attribution dynamique:
• Attribution et libération Explicite, c’est à dire que le
programmeur doit le faire. C’est ce qui est fait
quand on utilise des pointeurs. Par exemple, en
Pascal on attribue avec new(p), et libère avec
dispose(p). En C on utilise malloc().
• Attribution implicite (quand on entré dans un bloc)
et libération implicite (quand on en sort).
CSI 3525, Noms etc., page 18
Porté
• Blocs et structures de bloc
• Blocs anonymes
• Diagrammes d’imbrication
• Graphes d’appels
• Porté dynamique
CSI 3525, Noms etc., page 19
Blocs
• On regroupe des déclarations et des instructions pour:
- regrouper les étapes d’une même activité (e.g.,les étapes
d’un algorithme de trie),
- assurer une interprétation correcte des noms.
• Les Noms sont attaches à divers éléments d’un programme.
On fait référence à ces noms dans des instructions.
• La porté d’un nom N signifie l’ensemble des endroits dans
un programme où N dénote le même objet.
CSI 3525, Noms etc., page 20
• Les blocs peuvent être imbriqués. Les noms
introduit dans un bloc sont appelé
attachements locaux. Un nom qui est utilisée,
sans avoir été déclaré dans un même bloc,
doit avoir été déclaré dans un bloc englobant
ce bloc .
• L’imbrication des blocs est possible en
Pascal, Ada et (sous certaines formes) en C.
Elle n’est pas permise en Fortran.
• Un programme, une procédure ou une
fonction consiste en une entête et un bloc
nommé. Par rapport aux blocs anonymes
disponible en Algol 60, Algol 68, PL/I, Ada et
C – mais pas en Pascal.
CSI 3525, Noms etc., page 21
Blocs anonymes
• Un bloc anonyme est comme une procédure définie
(sans nom) et appelé immédiatement et une seule
fois.
• De tels blocs sont utiles quand un calcul est
nécessaire une seule fois, et des variables auxiliaires
sont nécessaires pour ce calcul. On ne veut pas
déclarer ces variables à l’extérieur du bloc (une
procédure aurait pu être utilisé pour parvenir au
même résultat)
CSI 3525, Noms etc., page 22
Diagrammes d’imbrication
En C:
P
X
A
C
A
Y
B
B
SB
SA
C
SP
SC
Z
Z
main P(){
int X;
void A(){
char Y;
void B(){
float Z;
SB }
SA }
void C(){
int Z;
SC }
SP }
CSI 3525, Noms etc., page 23
Graphes d’appels
P
A
C
B
• Montre quel unités du programme peuvent appeler quel autres unités. Les
flèches pointant vers l’unité d’où elles proviennent montrent la possibilité de
récursivité.
CSI 3525, Noms etc., page 24
Visibilité, l’environnement de référence
P
A
B
SA
SB


P.X,
P.X,
P.A.Y,
P.A.Y


P.X,
P.X
P.C.Z
P.A.B.Z
C
SP
SC
P.X signifie "variable X déclarée dans P".
CSI 3525, Noms etc., page 25
• Trous dans la porté (variables cachées): le même nom est utiliser dans
un bloc et dans un bloc imbriqué à l’intérieur de celui-ci.
P
SP
X
Y
A
B
A
X
Z
SA
B
Y
Z
SB
• Les variables visible dans SP : P.X, P.Y
• Les variables visible dans SA : P.A.X, P.Y, P.A.Z
• Les variables visible dans SB : P.X, P.B.Y, P.B.Z
• Donc, P.X est visible partout dans P sauf dans SA, où P.A.X la cache en
devenant elle même visible.
• Et, P.Y est visible partout dans P sauf dans SB, où P.B.Y la cache en
devenant elle même visible.
• Il n’y a pas de trous dans la porté de P.A.Z ou P.B.Z car elles ont des
régions de visibilité disjointes.
CSI 3525, Noms etc., page 26
Genres de porté
• Jusqu’ici on a parlé de porté statique (ou porté
lexicale). Celle-ci permet de déterminer l’usage des
variables de façon statique, avant l’exécution.
• La Porté Dynamique est une alternative aux
avantages qui ne sont pas claire. L’idée est de
chercher le nom dans une chaîne des procédures qui
sont appelé, en commencent par le programme
principale. Cette chaîne est construite selon les
règles de visibilités, mais en ignorant l’imbrication
des procédures.
CSI 3525, Noms etc., page 27
Exemple de porté
main P(){
int X;
void A(){
X = X + 1;
print(X);
}
void B(){
int X;
X = 17;
A();
}
X = 23;
B();
}
• Le programme appel B, puis B
appel A. Quand A utilise X,
Lequel des X est-ce?
• Avec la porté statique, c’est le X
de P, le bloc dans lequel A est
imbriquée. Le résultat est 24.
• Avec la porté dynamique (où la
recherche est faite dans la
chaîne d’appels), c’est le X de B,
le bloc le plus récemment appelé
contenant une déclaration de X.
Le résultat est 18.
CSI 3525, Noms etc., page 28
Porté dynamique
• La règle de porté dynamique a été utilisée dans APL,
SNOBOL-4 et le Lisp classique. Elle est peu utilisée
aujourd’hui. Même Common Lisp, une version plus
récente de Lisp a adopter la porté statique.
• La règle de porté dynamique est plus facile à
implémenter, mais:
• Il est impossible de savoir, à la compilation, à
quel objet réfèrent les variables, donc la
vérification des types est impossible.
• Les variables internes ne sont plus protégées.
Dans l’exemple, X est locale dans B, mais peut
être accédé à partir de A.
CSI 3525, Noms etc., page 29
Constantes et Initialisation de variables
• Les points importants peuvent être trouvé dans le
manuel aux sections 5.11-5.12.
CSI 3525, Noms etc., page 30
Vérification des Type
• Points
• Opérations et opérandes
• Typage fort
• Conversion et conversion implicite
CSI 3525, Noms etc., page 31
Types d’opérations
• Sauf certaines exceptions, les opérations d’un langage de
programmation nécessitent des opérandes (paramètres) bien défini, et
d’un type spécifique.
• Exemples d’opérations
• Booléennes (comparaison, et, ou, etc),
• Arithmétiques (+, -, *, /, sin, tan, exp etc.),
• De chaînes de caractères (concaténation, sous-chaînes etc.),
• Assignations (une opération avec deux opérandes),
• La transmission d’un paramètre à une procédure.
CSI 3525, Noms etc., page 32
Vérification de type
• La vérification de type assure que lorsqu’un
opérateur est utilisé, il reçoit des paramètres d’un
type qu’il peut traiter. La vérification de type peut être
faite à la compilation ou à l’exécution.
• Une erreur de type se produit lorsqu’un paramètre de
type inapproprié est passé à une opération. Ceci peut
également être signalé à la compilation ou à
l’exécution.
CSI 3525, Noms etc., page 33
Typage fort
Un langage de programmation utilise le typage fort quand toutes
les erreurs de type peuvent être découverte à la compilation.
Ceci n’est pas facile, même dans un langage très stricte tel que
Pascal.
Le problème: les sous-types des types énumérés.
type
day = (mo,tu,we,th,fr,sa,su);
workday = (mo,tu,we,th,fr);
var x : day; y : workday;
{...}
y := x; {???}
Il y a aussi les enregistrements qui ont des variantes. (dont des
exemples seront présentés plus tard).
CSI 3525, Noms etc., page 34
Typage fort (2)
• Une définition moins stricte du typage fort: toutes les
erreurs de types peuvent être détectés, et
préférablement à la compilation.
• Il est intéressant de noter qu’aucun langage
populaire inclus le typage fort parfait. Il y a toujours
des petites exceptions. Java a peu de telles
d’exceptions.
CSI 3525, Noms etc., page 35
Mais…
• Le typage stricte des opérandes est élégant et désirable, quoi
que possiblement peu pratique. Que faire quand deux
opérandes possible ont un sens compatible?
• Example:
var
x : real; n: integer;
{...} n := 2; {...}
x := n * 3.14;
• Cette multiplication sera rejetée par un compilateur stricte. Il
faudrait utiliser une conversion « type casting ».
x := float(n) * 3.14;
CSI 3525, Noms etc., page 36
Forçage de type
• On peut aussi utiliser une conversion implicite: le
changement automatique de la forme d’une
opérande avec un type légèrement inapproprié.
• Pour l’exemple précédant, la valeur de n peut être
représentée comme un float, et cette nouvelle valeur
peut être utilisé pour la multiplication.
• C et Perl sont des exemples de langages ou la
conversion implicite est utilisé de façon exagérée.
CSI 3525, Noms etc., page 37