Noms, attachement, porté, vérification de type

CSI 3525, Noms etc., page 1

Noms, attachement, porté, vérification de type

• Noms, variables

• Attachement

• Porté

• Constantes

• Initialisation des variables

• Vérification de type

• Compatibilité de type

Plan:


Noms et variables

Points à discuter:

• Qu’est-ce qui nécessite un nom?

• Un variable, en tant que six-tuplet


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.


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


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.


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


• 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;


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.


• 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 est-elle créée, et une différente porté (où peut-elle être utilisée).


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.


Attachement « binding »

• Points:

• Une présentation informelle

• Attachement en différent temps

• Attachement d’une variable

• Porté


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


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.


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


• 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


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


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.


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


Porté

• Blocs et structures de bloc

• Blocs anonymes

• Diagrammes d’imbrication

• Graphes d’appels

• Porté dynamique


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.


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


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)


Diagrammes d’imbrication

En C:

main P(){ int X; void A(){ char Y; void B(){ float Z; SB } SA } void C(){ int Z; SC }SP }

P XAC

SA

A YB

B

SB

Z

C

SC

Z

SP


Graphes d’appels

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

P

B

A C


Visibilité, l’environnement de référence

PA

BSB P.X, P.A.Y, P.A.B.Z

SA P.X, P.A.Y

CSC P.X, P.C.Z

SP P.X

P.X signifie "variable X déclarée dans P".


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

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

PXYAB

A XZ

SASP

B YZ

SB


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.


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.


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.


Constantes et Initialisation de variables

• Les points importants peuvent être trouvé dans le manuel aux sections 5.11-5.12.


Vérification des Type

• Points

• Opérations et opérandes

• Typage fort

• Conversion et conversion implicite


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.


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.


Typage fortUn 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).


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.


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;


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.

Documents

Noms, attachement, porté, vérification de type