7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
1/161
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
2/161
LES LANGAGES OBJETSPrincipes de base,techniques de programmation
Michel Beaudouin-Lafon
Armand Colin 1992
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
3/161
Table des matires
Chapitre 1 - INTRODUCTION .................................. ............1
1.1 Le champ des langages................ ...............................1
1.2 Historique...................................................................8
1.3 Plan du livre ..................................... ........................12
Chapitre 2 - PRINCIPES DE BASE......................................13
2.1 Classes et instances....................................................14
2.2 Mthodes et envoi de message ............................... ...172.3 Lhritage ................................................................18
2.4 Lhritage multiple...................................................22
2.5 Le polymorphisme ...................................................24
2.6 Les mtaclasses.................................. .......................28
Chapitre 3 - LANGAGES OBJETS TYPS.......................31
3.1 Classes, objets, mthodes...........................................33
3.2 Hritage....................................................................39
3.3 Hritage multiple................ ......................................44
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
4/161
3.4 Liaison dynamique...................................................483.5 Rgles de visibilit ................................... .................52
3.6 Mcanismes spcifiques..................... .......................56
3.7 Conclusion ...............................................................60
Chapitre 4 - SMALLTALK ET SES DRIVS....................61
4.1 Tout est objet............................................................64
4.2 Classes, instances, messages.......................................65
4.3 Hritage....................................................................69
4.4 Les structures de contrle ....................................... ..74
4.5 Mtaclasses............................... ................................81
4.6 Les drivs de Smalltalk............................................87
4.7 Conclusion ...............................................................92
Chapitre 5 - PROTOTYPES ET ACTEURS..........................93
5.1 Langages de prototypes............................................93
5.2 Langages dacteurs.................................................104
Chapitre 6 - PROGRAMMER AVEC DES OBJETS ..... ..... .117
6.1 Identifier les classes ........................................ ........118
6.2 Dfinir les mthodes.......................... .....................125
6.3 Rutiliser les classes ........................................ ........132
6.4 Exemple : les Tours de Hanoi........ .........................136
6.5 Conclusion .............................................................140
Bibliographie.....................................................................141
Index.................................................................................145
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
5/161
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
6/161
Avant-propos
Ce livre a pour objectif de prsenter les langages objets et laprogrammation par objets d'une manire gnrale et nanmoinsprcise. Le nombre de langages objets existant aujourd'hui etleur diversit interdisent une tude exhaustive dans un ouvragede cette taille. C'est pourquoi l'on s'est attach identifier unnombre rduit de concepts de base, partags par de nombreuxlangages, et illustrer ces concepts par des exemples concrets. Ilne s'agit donc pas d'apprendre programmer avec un langage objets (d'autres ouvrages, spcialiss, s'y emploient), mais dematriser les principes de ces langages et les techniques de la
programmation par objets.Ce livre s'adresse des lecteurs ayant une exprience de la
programmation avec des langages classiques comme Pascal etLisp, ou tout au moins une connaissance des principes de ceslangages. Il s'adresse donc tout particulirement des tudiantsde second et troisime cycle d'Informatique, ou d'autresdisciplines dans lesquelles la formation l'Informatique abordeles langages de programmation volus. Ce livre s'adressegalement aux lves des coles d'ingnieurs, aux chercheurs,aux enseignants, et plus gnralement tous ceux qui veulentcomprendre les langages objets.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
7/161
Plusieurs annes d'enseignement des langages objets auD.E.S.S. Systme et Communication Homme-Machine del'Universit de Paris-Sud, et des confrences au Certificat C4d'Informatique Applique de cette mme Universit, m'ontconduit la prsentation des langages objets adopte dans celivre : dans les deux cas, le faible volume horaire interdit toutapprentissage d'un langage particulier et invite uneprsentation synthtique. Il en rsulte une grille d'analyse deslangages objets, largement maille d'exemples, dontl'ambition est de permettre au lecteur d'aborder la program-mation avec un langage objets avec une vision claire et sainede l'univers de ces langages.
Plusieurs personnes ont contribu rendre ce livre plus clairet, je l'espre, facile d'accs : Thomas Baudel, Jean Chassain,Stphane Chatty, Marc Durocher, Solange Karsenty ont relu desversions prliminaires de cet ouvrage et apport des commen-taires constructifs ; les membres du groupe Interfaces Homme-Machine du Laboratoire de Recherche en Informatique, par leurexprience quotidienne de la programmation par objets, ontpermis tout la fois de mettre en vidence les ralits pratiquesde l'utilisation des langages objets et de mettre l'preuve uncertain nombre d'ides prsentes dans ce livre. Marie-ClaudeGaudel a galement contribu clarifier les notions lies autypage dans les langages de programmation en gnral et dansles langages objets en particulier. Enfin, mon frre Emmanuela ralis l'ensemble des figures de cet ouvrage, et je lui en suisinfiniment reconnaissant.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
8/161
Chapitre 1
INTRODUCTION
Les langages objets sont apparus depuis quelques annescomme un nouveau mode de programmation. Pourtant laprogrammation par objets date du milieu des annes 60 avecSimula, un langage cr par Ole Dahl et Kristen Nygaard enNorvge et destin programmer des simulations de processusphysiques. Bien que de nombreux travaux de recherche aient
eu lieu depuis cette poque, lessor des langages objets estbeaucoup plus rcent. Ce livre essaie de montrer que leslangages objets ne sont pas une mode passagre, et que laprogrammation par objets est une approche gnrale de laprogrammation qui offre de nombreux avantages.
1.1 LE CHAMP DES LANGAGES
Situer les langages objets dans le vaste champ des langagesde programmation nest pas chose facile tant le terme dobjetrecouvre de concepts diffrents selon les contextes. Nousprsentons ici plusieurs classifications des langages et situons les
langages objets dans ces diffrentes dimensions.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
9/161
2 Les langages objets
Classification selon le mode de programmation
Cette classification prsente les principaux modles deprogrammation qui sont utiliss aujourdhui, cest--dire lesprincipaux modles par lesquels on peut exprimer un calcul.
La programmation imprative, la plus ancienne, correspondaux langages dans lesquels lalgorithme de calcul est dcritexplicitement, laide dinstructions telles que laffectation, letest, les branchements, etc. Pour sexcuter, cet algorithmencessite des donnes, stockes dans des variables auxquellesle programme accde et quil peut modifier. La formule deNiklaus Wirth dcrit parfaitement cette catgorie de langages :
programme = algorithme + structure de donnes.
On classe dans cette catgorie les langages dassemblage,Fortran, Algol, Pascal, C, Ada. Cette catgorie de langages estla plus ancienne car elle correspond naturellement au modledarchitecture des machines qui est la base des ordinateurs :le modle de Von Neumann.
La programmation fonctionnelle adopte une approchebeaucoup plus mathmatique de la programmation. Fondesur des travaux assez anciens sur le lambda-calcul etpopularise par le langage Lisp, la programmationfonctionnelle supprime la notion de variable, et dcrit un
calcul par une fonction qui sapplique sur des donnesdentres et fournit comme rsultat les donnes en sortie. Defait, ce type de programmation est plus abstrait car il fautdcrire lalgorithme indpendamment des donnes. Il existepeu de langages purement fonctionnels ; beaucoup intro-duisent la notion de variable pour des raisons le plus souventpratiques, car labstraction complte des donnes conduitsouvent des programmes lourds crire. Parmi les langagesfonctionnels, il faut citer bien sr Lisp et ses multiplesincarnations (CommonLisp, Scheme, Le_Lisp, etc.), ainsi queML.
La programmation logique, ne dune approche galementlie aux mathmatiques, la logique formelle, est fonde sur la
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
10/161
Introduction 3
description dun programme sous forme de prdicats. Cesprdicats sont des rgles qui rgissent le problme dcrit ;lexcution du programme, grce linfrence logique,permet de dduire de nouvelles formules, ou de dterminer siune formule donne est vraie ou fausse partir des prdicatsdonns. Linfrence logique est tout fait similaire auxprincipes qui rgissent la dmonstration dun thormemathmatique laide daxiomes et de thormes connus. Leplus clbre des langages logiques est Prolog.
La programmation par objets est-elle une nouvelle catgoriedans cette classification ? Il est difficile de rpondre cettequestion. La programmation par objets est proche de la
programmation imprative : en effet, l o la programmationimprative met laccent sur la partie algorithmique de laformule de Wirth, la programmation par objets met laccent surla partie structure de donnes. Nanmoins, ceci nest passuffisant pour inclure la programmation par objets dans laprogrammation imprative, car lapproche des langages objetssapplique aussi bien au modle fonctionnel ou logique quaumodle impratif.
Classification selon le mode de calcul
Cette classification complte la prcdente en distinguant deux
modles dexcution dun calcul : Les langages squentiels correspondent une excution
squentielle de leurs instructions selon un ordre que lon peutdduire du programme. Ces langages sont aujourdhui lesplus rpandus, car ils correspondent larchitecture classiquedes ordinateurs dans lesquels on a une seule unit detraitement (modle de Von Neumann). Les langages objetssont pour la plupart squentiels.
Les langages parallles permettent au contraire plusieursinstructions de sexcuter simultanment dans un programme.Lessor de la programmation parallle est d la disponibilit
de machines architecture parallle. La programmation
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
11/161
4 Les langages objets
parallle ncessite des langages spcialiss car les langagesusuels ne fournissent pas les primitives de communication etde synchronisation indispensables. Or il savre que le modlegnral de la programmation par objets est facilementparalllisable. Une classe de langages objets, les langagesdacteurs, sont effectivement des langages parallles.
Classification selon le typage
Cette classification considre la notion de type qui, dans leslangages de programmation, est destine apporter une scuritau programmeur : en associant un type chaque expression
dun programme, on peut dterminer par une analyse statique,cest--dire en observant le texte du programme sans lexcuter,si le programme est correct du point de vue du systme detypes. Cela permet dassurer que le programme ne provoquerapas derreur lexcution en essayant, par exemple, dajouterun boolen un entier.
Dans un langage typage statique, on associe, par uneanalyse statique, un type chaque expression du programme.Cest le systme de types le plus sr, mais aussi le pluscontraignant. Pascal est lexemple typique dun langage typage statique.
Dans un langage fortement typ, lanalyse statique permet devrifier que lexcution du programme ne provoquera pasderreur de type, sans pour autant tre capable dassocier untype chaque expression. Ceci signifie que les types devrontventuellement tre calculs lexcution pour contrlercelle-ci. Les langages qui offrent le polymorphismeparamtrique (ou gnricit), comme ADA, sont fortementtyps. La plupart des langages objets typs sont fortementtyps, et notamment Simula, Modula3 et C++.
Dans un langage faiblement typ, on ne peut assurer, par laseule analyse statique, que lexcution dun programme neprovoquera pas derreur lie au systme de types. Il est donc
ncessaire de calculer et de contrler les types lexcution,
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
12/161
Introduction 5
ce qui justifie lappellation de langage typage dynamique.Parmi les langages objets, Eiffel est faiblement typ car unepartie du contrle de types doit tre ralise lexcution.
Dans un langage non typ, la notion de type nexiste pas, et ilne peut donc y avoir de contrle sur la validit du programmevis--vis des types. Ainsi, Lisp est un langage non typ, demme que le langage objets Smalltalk.
La notion de type apporte une scurit de programmationindispensable dans la ralisation de gros systmes. De plus,comme nous allons le voir, elle permet de rendre lexcutiondes programmes plus efficace. Cest donc une notion
importante, et lon peut constater que les langages objetscouvrent une grande partie de la classification ci-dessus. Cestce critre qui va nous servir structurer la suite de ce livre endistinguant dun ct les langages typs (fortement oufaiblement), dautre part les langages non typs. De nombreuxtravaux sont consacrs actuellement ltude des systmes detypes dans les langages objets car le concept dhritage, qui estlun des fondements des langages objets, ncessite dessystmes de types qui nentrent pas dans les cadres tudisjusqu prsent.
Classification selon le mode dexcution
Cette classification porte sur la faon dont lexcution duprogramme est ralise. Le mode dexcution nest pas proprement parler une caractristique dun langage, mais unecaractristique de limplmentation dun langage.
Les langages interprts permettent lutilisateur dentrer desexpressions du langage et de les faire excuterimmdiatement. Cette approche offre lavantage de pouvoirtester et modifier rapidement un programme au dtriment dela vitesse dexcution. Outre la vitesse dexcution, leslangages interprts ont gnralement pour inconvnientdtre moins srs, car de nombreux contrles smantiques
sont raliss au fur et mesure de linterprtation et non dans
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
13/161
6 Les langages objets
une phase prliminaire de compilation. Beaucoup de langages objets sont interprts, et tirent avantage de cette apparentefaiblesse pour donner une plus grande souplesse lexcutiondes programmes. Ainsi, une modification ponctuelle dunprogramme peut avoir des effets (contrls) sur lensemble delexcution, ce qui permet notamment de construire desenvironnements sophistiqus pour la mise au point desprogrammes.
Les langages compils ncessitent une phase de compilationavant de passer lexcution proprement dite dunprogramme. Le but de la compilation est essentiellement deproduire du code directement excutable par la machine, donc
plus efficace. Pour cela, le compilateur utilise en gnral lesinformations qui lui sont fournies par le systme de types dulangage. Cest ainsi que la plupart des langages typs sontcompils. De manire gnrale, les langages interprts sontplus nombreux que les langages compils car la ralisationdun compilateur est une tche complexe, surtout si lon veutengendrer du code machine efficace. Les langages objetsnchappent pas cette rgle, et il existe peu de langages objets compils.
Les langages semi-compils ont les caractristiques deslangages interprts mais, pour une meilleure efficacit, ilsutilisent un compilateur de manire invisible pour lutilisateur.Ce compilateur traduit tout ou partie du programme dans uncode intermdiaire ou directement en langage machine. Si lecompilateur engendre un code intermdiaire, cest uninterprteur de ce code qui ralisera lexcution duprogramme. Les langages objets considrs commeinterprts sont souvent semi-compils, comme Smalltalk ou lelangage de prototypes Self.
Classification selon la modularit
Cette dernire classification analyse la faon dont les langagespermettent au programmeur de raliser des modules et
dencapsuler les donnes. La modularit et lencapsulation
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
14/161
Introduction 7
assurent une plus grande scurit de programmation etfournissent la base de la rutilisation.
Absence de modularit : le programmeur doit, par desconventions de programmation et de nommage, prendre encharge la modularit. Cest notamment le cas de Pascal quioblige donner des noms diffrents toutes les variables,procdures et fonctions globales, et ne permet pas de cacherdes dfinitions autrement que par les rgles de visibilit(procdures imbriques), ce qui est insuffisant. Le langage Coffre une modularit selon le dcoupage du programme enfichiers, en permettant de dclarer des variables ou fonctionsprives un fichier. En revanche, il noffre pas la possibilit
dimbrication des procdures et fonctions.
Modularit explicite : certains langages offrent la notion demodule comme concept du langage, que lon peut composeravec dautres notions. Par exemple, en Ada, la notion de package permet dimplmenter un module, et se combineavec la gnricit pour autoriser la dfinition de modulesgnriques (paramtrs par des types).
Modularit implici te : les langages objets fournissent unemodularit que lon peut qualifier dimplicite dans la mesureo celle-ci ne fait pas appel des structures particulires dulangage. Au contraire, la notion de module est implicite etindissociable de celle de classe.
La programmation par objets est une forme de program-mation modulaire dans laquelle lunit de modularit estfortement lie aux structures de donnes du langage. Parcomparaison, le langage Ada offre une modularit beaucoupplus indpendante des structures de donnes et de traitement dulangage. La modularit est souvent considre comme un atoutimportant pour la rutilisation des programmes. De ce point devue, les langages objets permettent une rutilisation bien plusimportante que la plupart des autres langages.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
15/161
8 Les langages objets
La programmation par objets comme un style
De ce tour dhorizon, il faut conclure que la programmationpar objets est plus une approche gnrale de la programmationquun type facilement classable. De fait, on voit aujourdhui denombreuses extensions objets des langages existant : PascalObjet, Lisp Objet, Cobol Objet, etc. Si certaines de ces extensionsne sont pas toujours un succs, il est un fait que les principes dela programmation par objets sont applicables dans un grandnombre de contextes.
1.2 HISTORIQUE
La figure 1 prsente la gnalogie des principaux langages objets. On y distingue deux ples autour des langages Simula etSmalltalk.
La famille Simula
Le langage Simula est considr comme le prcurseur deslangages objets. Dvelopp dans les annes 60 pour traiter desproblmes de simulation de processus physiques (do sonnom), Simula a introduit la notion de classe et dobjet, la notionde mthode et de mthode virtuelle. Ces concepts restent la
base des langages objets typs et compils, comme on le verraen dtail dans le chapitre 3. Simula a t cr dans la ligne dulangage Algol, langage typ de lpoque dont Pascal sestgalement inspir.
Les langages de la famille Simula sont des langages impratifstyps et gnralement compils. Lintrt dun systme de typesest de permettre un plus grand nombre de contrles smantiqueslors de la compilation, et dviter ainsi des erreurs qui ne semanifesteraient qu lexcution. Typage et compilation sontdeux concepts indpendants : on peut imaginer des langagestyps interprts et des langages non typs compils. Cestnanmoins rarement le cas, car les informations dduites du
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
16/161
Introduction 9
Simula
1960
1970
1980
1990
Beta Eiffel
Objective-C ObjVlisp
CLOS
Flavors
Plasma
ACT1
ACT2
C++
malltalk
ObjectPascal
SelfModula3
Modula2
Algol Lisp
CPlannerPascal
ABCL /1
Figure 1 - Gnalogie des principaux langages objets
typage permettent de gnrer du code plus efficace, ce quiencourage compiler les langages typs.
Simula a inspir nombre de langages objets. Certains dentreeux sont maintenant largement plus connus et rpandus queSimula, comme C++ et Eiffel. Plusieurs langages ont t conusen ajoutant des concepts des langages objets un langageexistant. Ainsi, Classcal et son descendant Object Pascal ajoutentdes classes au langage Pascal, Modula3 est une rvision majeure
de Modula2 incluant des objets, C++ est construit partir de C.Une telle approche prsente avantages et inconvnients : il estcommode de prendre un langage existant aussi bien pour lesconcepteurs que pour les utilisateurs car cela vite de toutrinventer ou de tout rapprendre. Dun autre ct, certainsaspects du langage de base peuvent se rvler nfastes pourladjonction de mcanismes des langages objets.
La famille Smalltalk
Dans les annes 70, sous limpulsion dAlan Kay, ontcommenc aux laboratoires Xerox PARC des recherches qui ontconduit au langage Smalltalk, considr par beaucoup comme le
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
17/161
10 Les langages objets
prototype des langages objets. De fait, cest Smalltalk pluttque Simula qui est lorigine de la vague des langages objetsdepuis les annes 80.
Smalltalk sinspire de Simula pour les concepts de classes,dobjets et de mthodes, mais adopte une approche influencepar Lisp pour ce qui concerne limplmentation : Smalltalk estun langage semi-compil dans lequel tout est dcid lors delexcution. Comme dans Lisp, la souplesse due laspectinterprt de lexcution est largement exploite par le langage.
Dun point de vue conceptuel, Smalltalk introduit la notion demtaclasse qui nest pas prsente dans Simula. Cette notion
permet de donner une description mta-circulaire du langage detelle sorte que lon peut raliser assez simplement uninterprteur de Smalltalk en Smalltalk. Cet aspect mta-circulaire est galement prsent dans Lisp, et dans de nombreuxlangages interprts. Dans le cas de Smalltalk, les mtaclassessont accessibles lutilisateur de faon naturelle, et permettentde nombreuses facilits de programmation. Lintroduction dumodle mta-circulaire dans Smalltalk date de la premireversion du langage (Smalltalk-72). Les versions suivantes(Smalltalk-76 et Smalltalk-80) ont affin, amlior et enrichi cemodle. Dautres langages inspirs de Smalltalk sont alls plusloin dans cette direction, notamment ObjVLisp et Self.
La meilleure preuve de la puissance de Smalltalk estlensemble des programmes raliss en Smalltalk, et lintenseactivit de recherche autour du langage, de ses concepts ou deses langages drivs. Parmi les ralisations, il faut noterlenvironnement de programmation Smalltalk, ralis XeroxPARC et implment lui-mme en Smalltalk. Cet environ-nement, qui inclut un systme dexploitation, est le premierenvironnement graphique a avoir t largement diffus.
Smalltalk a inspir de nombreux langages de programmation.Alors que Smalltalk est un langage natif, la plupart des langagesquil a inspirs sont raliss au-dessus de Lisp. Il savre que
Lisp fournit une base au-dessus de laquelle il est facile de
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
18/161
Introduction 11
construire des mcanismes dobjets. On peut nanmoinsregretter que dans nombre de cas le langage sous-jacent resteaccessible, ce qui donne lutilisateur deux modes de program-mation largement incompatibles : le mode fonctionnel de Lispet le mode de programmation par objets. Certaines incarnationsde Lisp intgrent les notions dobjets de faon presque native,comme Le_Lisp et CLOS (CommonLisp Object System).
Autres familles, autres langages
Si les familles Simula et Smalltalk reprsentent une grandepartie des langages objets, il existe dautres langages
inclassables, dautres familles en cours de formation.Ainsi le langage Objective-C est un langage hybride qui
intgre le langage C avec un langage objets de type Smalltalk.Plutt quune intgration, on peut parler dune coexistenceentre ces deux aspects, car on passe explicitement dun univers lautre par des dlimiteurs syntaxiques. Les entits dun universpeuvent tre transmises lautre, mais elles sont alors des objetsopaques que lon ne peut manipuler. Lintrt de cetteapproche est de donner lutilisateur un environnementcompil et typ (composante C) et un environnement interprtnon typ (composante Smalltalk). Parmi les logiciels raliss enObjective-C, le plus connu est certainement Interface Builder,
lenvironnement de construction dapplications interactives dela machine NeXT.
Une autre famille est constitue par les langages deprototypes . Ces langages, au contraire des langages objetstraditionnels, ne sont pas fonds sur les notions de classes etdobjets, mais uniquement sur la notion de prototype. Unprototype peut avoir les caractristiques dune classe, ou dunobjet, ou bien des caractristiques intermdiaires entre les deux.Dune certaine faon, ces langages poussent le concept desobjets dans ses derniers retranchements et permettent dexplorerde nouveaux paradigmes de programmation.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
19/161
12 Les langages objets
Une dernire famille est constitue de langages paralllesappels langages dacteurs. Dans un programme crit avec untel langage, chaque objet, appel acteur, est un processus quisexcute de faon autonome, mettant et recevant des messagesdautres acteurs. Lorsquun acteur envoie un message unautre acteur, il peut continuer son activit, sans se soucier de cequil advient du message. Le paralllisme est donc introduit parune simple modification du mode de communication entre lesobjets. Compar aux modles de paralllisme mis en uvre dansdautres langages, comme les tches de Ada, la simplicit etllgance du modle des acteurs est surprenante. Cela fait deslangages dacteurs un moyen privilgi dexploration duparalllisme.
1.3 PLAN DU LIVRE
Ce livre a pour but de prsenter les principes fondamentauxdes langages objets et les principales techniques deprogrammation par objets. Il ne prtend pas apprendre programmer avec tel ou tel langage objets. cet effet, lesexemples sont donns dans un pseudo-langage la syntaxeproche de Pascal. Ceci a pour but une prsentation plushomogne des diffrents concepts.
Le prochain chapitre prsente les principes gnraux qui sont la base de la programmation par objets. Les trois chapitressuivants prsentent les grandes familles de langages objets : leslangages objets typs, cest--dire les langages de la famille deSimula (chapitre 3) ; les langages objets non typs, et enparticulier Smalltalk (chapitre 4) ; les langages de prototypes etles langages dacteurs (chapitre 5). Le dernier chapitre prsenteun certain nombre de techniques usuelles de la programmationpar objets et une bauche de mthodologie.
Une connaissance des principes de base des langages deprogrammation en gnral et de Pascal en particulier estsuppose dans lensemble de louvrage. Les chapitres 3 et 4
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
20/161
Introduction 13
sont indpendants. Les lecteurs qui prfrent Lisp Pascalpeuvent lire le chapitre 4 avant le chapitre 3.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
21/161
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
22/161
Chapitre 2
PRINCIPES DE BASE
Un langage objets utilise les notions de classe et dinstance,que lon peut comparer aux notions de type et de variable dunlangage tel que Pascal. La classe dcrit les caractristiquescommunes toutes ses instances, sous une forme similaire untype enregistrement ( record Pascal). Une classe dfinit doncun ensemble de champs. De plus, une classe dcrit un ensemble
de mthodes, qui sont les oprations ralisables sur les instancesde cette classe. Ainsi une classe est une entit autonome. Au lieudappliquer des procdures ou fonctions globales desvariables, on invoque les mthodes des instances. Cetteinvocation est souvent appele envoi de message. De fait, onpeut considrer que lon envoie un message une instance pourquelle effectue une opration, cest--dire pour quelledtermine la mthode invoquer.
On utilise souvent le terme dobjet la place dinstance. Leterme instance insiste sur lappartenance une classe : onparle dune instance dune classe donne. Le terme objet rfre de faon gnrale une entit du programme (qui peut
tre une instance, mais aussi un champ, une classe, etc.).
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
23/161
16 Les langages objets
Lien d'hritage
Lien d'instanciation
Objet
Classe
Champs
Mthodes
Classe de Base
Envoi de message
Figure 2 - Illustration des notions de base
Lhritage est la dernire notion de base des langages objets : une classe peut tre construite partir dune classeexistante, dont elle tend ou modifie la description. Cemcanisme de structuration est fondamental dans les langages objets ; il est dcrit dans la section 2.3 de ce chapitre.
La figure 2 dcrit ces quatre notions de base, et introduit lesconventions que nous utiliserons dans les autres figures.
2.1 CLASSES ET INSTANCESLa notion dobjet ou instance recouvre toute entit dun
programme crit dans un langage objets qui stocke un tat etrpond un ensemble de messages. Cette notion est compareravec la notion usuelle de variable : une variable stocke un tat,mais na pas la capacit par elle-mme deffectuer destraitements. On utilise pour cela dans les langages classiques dessous-programmes, fonctions ou procdures. Ceux-ci prennentdes variables en paramtre, peuvent les modifier et peuventretourner des valeurs.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
24/161
Principes de base 17
Dans un langage classique, on dfinirait par exemple un typePile et des procdures pour accder une pile ou la modifier :
Empiler, qui prend une pile et une valeur empiler ;
Dpiler, qui prend une pile ;
Sommet, qui prend une pile et retourne une valeur.
Cette sparation entre variables et procdures dans leslangages classiques est la source de nombreux problmes en cequi concerne lencapsulation : pour des raisons de scurit deprogrammation, on ne souhaite pas que nimporte quelleprocdure puisse accder au contenu de nimporte quellevariable. On est alors amen introduire la notion de module.Un module exporte des types, des variables et des procdures.De lextrieur, les types sont opaques : leur implmentationnest pas accessible. On ne peut donc manipuler les variables dece type que par lintermdiaire des procdures exportes par lemodule. lintrieur du module, limplmentation des types estdcrite, et est utilisable par les corps des procdures.
Ainsi, on peut encapsuler la notion de pile dans un module.Ce module exporte un type Pile, et les procdures Em pi le r,Dpiler et Sommet, dont limplmentation nest pas connue delextrieur. Par cette technique, un utilisateur du module nepourra pas modifier une pile autrement que par les procduresfournies par le module, ce qui assure lintgrit dune pile.
Le module constitue donc le moyen de regrouper types etprocdures, pour construire des types abstraits. Les langagesClu, Ada et ML, parmi dautres, offrent de telles possibilits.Dans les langages qui noffrent pas de modularit (Pascal, C,Lisp etc.), le programmeur doit faire preuve dune granderigueur pour reproduire artificiellement, cest--dire sans aidedu langage, lquivalent de modules.
Lapproche des langages objets consiste intgrer demblela notion de variable et de procdures associes dans la notiondobjet. Lencapsulation est donc fournie sans mcanisme
additionnel. De mme quune variable appartient un type dans
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
25/161
18 Les langages objets
Pile
pilesommet
EmpilerDpilerSommet
pilesommet O
Figure 3 - La classe Pile et une instance
un langage classique, dans un langage objets un objetappartient une classe. La classe est la fois un type et unmodule : elle contient une description de type, sous forme dechamps, ainsi quun ensemble de procdures associes ce type,appeles mthodes.
Dfinir une classe
On dfinira ainsi une classe Pile par :
un tat reprsentant la pile (tableau, liste, etc.), constitu dechamps. Pour une reprsentation par tableau, on aura ainsideux champs : le tableau lui-mme et lindice du sommetcourant.
la mthode Empiler, qui prend une valeur en paramtre.
la mthodeDpiler.
la mthode Sommet, qui retourne une valeur.
On cre des objets partir dune classe par le mcanismed instanciation. Le rsultat de linstanciation dune classe estun objet, appel instance de la classe (voir figure 3).Linstanciation est similaire la cration dune variable dun
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
26/161
Principes de base 19
type enregistrement. Linstance cre stocke un tat constitudune valeur pour chacun de ses champs. Les champs sont eux-mmes des objets. Un certain nombre de classes sont prdfiniesdans les langages, telles que la classe des entiers, des caractres,etc.
Lencapsulation, cest--dire laccs contrl aux objets, estassure naturellement par les classes. Bien que diffrant dunlangage lautre, comme nous le verrons, on peut considrerdans un premier temps que les champs sont privs alors que lesmthodes sont publ iques. Ceci signifie que les champs sontvisibles uniquement depuis le corps des mthodes de la classe,alors que les mthodes sont visibles de lextrieur. Nous allons
maintenant dcrire le mcanisme dinvocation des mthodes.
2.2 MTHODES ET ENVOI DE MESSAGE
Dans les langages objets, les objets stockent des valeurs, et lesmthodes permettent de manipuler les objets. Ceci estcomparable aux langages classiques, dans lesquels les variablesstockent des valeurs et les procdures et fonctions permettent demanipuler les variables. Mais, contrairement aux procdures etfonctions qui sont des entits globales du programme, lesmthodes appartiennent aux classes des objets. Au lieudappeler une procdure ou fonction globale, on invoque unemthode dun objet. Lexcution de la mthode est alorsralise dans le contexte de cet objet.
Linvocation dune mthode est souvent appele envoi demessage. On peut en effet considrer que lon envoie un objet,par exemple une pile, un message, par exemple empiler lavaleur 20 . Dans un langage classique, on appellerait laprocdure Empiler avec comme paramtres la pile elle-mme etla valeur 20.
Cette distinction est fondamentale. En effet, lenvoi demessage implique que cest le receveur (ici la pile) qui dcide
comment empiler la valeur 20, grce la mthode dtenue par
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
27/161
20 Les langages objets
sa classe. Au contraire, lappel de procdure des langagesclassiques implique que cest la procdure (ici Empi ler) quidcide quoi faire de ses arguments, dans ce cas la pile et lavaleur 20. En dautres termes, la programmation imprative oufonctionnelle privilgie le contrle (procdures et fonctions)alors que la programmation par objets privilgie les donnes (lesobjets), et dcentralise le contrle dans les objets.
Le corps dune mthode est excut dans le contexte delobjet receveur du message. On a donc directement etnaturellement accs aux champs et mthodes de lobjetreceveur. Cest en fait seulement dans le corps des mthodesque lon a accs aux parties prives de lobjet, cest--dire en
gnral ses champs (les langages diffrent sur la dfinition desparties prives).
La dfinition conjointe des champs et des mthodes dans lesclasses est la base du mcanisme dhritage, que nous allonsmaintenant dcrire.
2.3 LHRITAGE
La notion dhritage est propre aux langages objets. Ellepermet la dfinition de nouvelles classes partir de classesexistantes. Supposons que lon veuille programmer le jeu desTours de Hanoi. On dispose de trois tours ; sur la premire sontempils des disques de taille dcroissante. On veut dplacer cesdisques sur lune des deux autres tours en respectant les deuxrgles suivantes :
on ne peut dplacer quun disque la fois ;
on ne peut poser un disque sur un disque plus petit.
Le comportement dune tour est similaire celui dune pile :on peut empiler ou dpiler des disques. Cependant on ne peutempiler un disque que sil est de diamtre infrieur au sommetcourant de la tour.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
28/161
Principes de base 21
Si lon utilise un langage classique qui offre lencapsulation,on est confront lalternative suivante :
utiliser une pile pour reprsenter chaque tour, et sassurerque chaque appel de la procdure Empiler est prcd duntest vrifiant la validit de lempilement.
crer un nouveau module, qui exporte un type opaque Touret les procdures E m p i l e r , D p i l e r , et S o m m e t .Limplmentation de Tour est une pile ; la procdureEmpi ler ralise le contrle ncessaire avant dempiler undisque. Les procdures Dpiler et Sommet appellent leurshomologues de la pile.
Aucune de ces deux solutions nest satisfaisante. La premirene fournit pas dabstraction correspondant la notion de tour.La seconde est la seule acceptable du point de vue delabstraction mais prsente de multiples inconvnients :
Il faut crire des procdures inutiles : Dpiler du moduleTour ne fait quappeler Dpiler du module Pile ;
Si lon ajoute une fonction Profondeur dans le module Pile,elle ne sera accessible pour lutilisateur de Tour que si londfinit galement une fonction Profondeur dans le moduleTour comme on la fait pour Dpiler ;
Le problme est encore plus grave si lon dcide denleverla fonction Profondeur du module Pile : la fonctionProfondeur de Tour appelle maintenant une fonction quinexiste plus ;
Il nest pas possible daccder directement limplmentation de la pile dans le module Tour, cause delencapsulation. On ne peut pas ajouter la fonctionProfondeur dans Tour sans dfinir une fonction quivalentedans Pile.
Ce que lon cherche en ralit est la spcialisation dune pilepour en faire une tour, en crant un lien privilgi entre lesmodules Pile et Tour. Cest ce que permet lhritage par ladfinition dune classe Tour qui hrite de Pile.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
29/161
22 Les langages objets
Pile
pilesommet
EmpilerDpilerSommet
Tour
Empiler
Figure 4 - La classe Tour hrite de la classe Pile
Dfinir une classe par hritage
Lorsquune classe B hrite dune classe A, les instances de Bcontiennent les mmes champs que ceux de A, et les mthodesdeA sont galement disponibles dans B. De plus, la sous-classeB peut :
dfinir de nouveaux champs, qui sajoutent ceux de saclasse de baseA ;
dfinir de nouvelle mthodes, qui sajoutent celles hritesdeA ;
redfinir des mthodes de sa classe de baseA.
Enfin, les mthodes dfinies ou redfinies dans B ont accsaux champs et mthodes de B, mais aussi ceux de A.
Ces proprits montrent le lien privilgi qui unit B A. Enparticulier, si lon ajoute des champs et/ou des mthodes A, ilnest pas ncessaire de modifier B. Il en est de mme si lonretire des champs et/ou des mthodes de A, sauf bien sr silstaient utiliss dans les mthodes dfinies ou redfinies dans B.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
30/161
Principes de base 23
Dans notre exemple, on se bornera redfinir la mthodeEmpiler, pour faire le contrle de la taille des disques et appelerla mthode Empiler de Pile si lopration est valide (voir figure4). Dans ce cas, on dira que lon a spcialis la classe Pile car ona seulement redfini lune de ses mthodes. Si lon dfinissaitde nouvelles mthodes dans la classe Tour (par exempleinitialiser la tour avecNdisques de taille dcroissante), on auraitenrichi la classe Pile. Ce simple exemple montre dj quelhritage peut servir raliser deux oprations : laspcialisation et lenrichissement.
Larbre dhritage
Telle que nous lavons prsente, la notion dhritage induitune fort darbres de classes : une classe A reprsente par unnud dun arbre a pour sous-classes les classes reprsentes parses fils dans larbre. Les racines des arbres de la fort sont lesclasses qui nhritent pas dune autre classe.
Si C hrite de B etB hrite de A, on dira par extension que Chrite de A. On dira indiffremment :
B hrite deA
B est une sous-classe deA
B drive deA
B est une classe drive deA
A est une (la) superclasse deB
A est une (la) classe de base deB
Dans les deux dernires phrases, on emploie larticle dfinipour indiquer que A est lantcdent direct de B dans larbredhritage.
Certains langages imposent une classe de base unique pourtoutes les autres, appele souvent Objet. Dans ce cas, la relationdhritage dfinit un arbre et non une fort. Par abus delangage, on parle dans tous les cas de larbre dhritage.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
31/161
24 Les langages objets
2.4 LHRITAGE MULTIPLELhritage que nous avons dfini est dit hritage simple car
une classe a au plus une classe de base. Une gnralisation delhritage simple, lhritage multiple, consiste autoriser uneclasse hriter directement de plusieurs classes.
Ainsi si la classe B hrite deA1, A2, An, on a les propritssuivantes :
les champs des instances de B sont lunion des champs deA1, A2, An et des champs propres de B ;
les mthodes dfinies pour les instances de B sont lunion
des mthodes dfinies dans A1, A2, An et des mthodesdfinies dans B.B peut galement redfinir des mthodes deses classes de base.
Larbre ou la fort dhritage devient alors un graphe. Pourviter des dfinitions rcursives on interdit davoir des cyclesdans le graphe dhritage. En dautres termes, on interdit uneclasse dtre sa propre sous-classe, mme indirectement.
Cette extension, apparemment simple, cache en fait demultiples difficults, qui ont notamment trait aux problmes decollision de noms dans lensemble des champs et mthodeshrites. Certaines de ces difficults ne pourront tre
dveloppes que dans la description plus dtaille des chapitressuivants.
Une difficult intrinsque de lhritage multiple est la gestionde lhritage rpt dune classe donne : si B et Chritent deApar un hritage simple, et D hrite de B et de C, alors D hritedeux fois de A , par deux chemins D-B-A et D-C-A dans legraphe dhritage (figure 5). Faut-il pour autant quuneinstance de D contienne deux fois les champs dfinis dans A, oubien faut-il les partager ?
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
32/161
Principes de base 25
C
c
A
a
B
b
D
d
a (D.B.A)b (D.B)a (D.C.A)c (D.C)d (D)
a (D.B.A, D.C.A)b (D.B)c (D.C)d (D)
Figure 5 - Deux interprtations de lhritage multiple
Selon les situations, on souhaitera lune ou lautre solution,comme le montrent les deux exemples suivants.
Soit A la classe des engins moteur, qui contient commechamps les caractristiques du moteur. Soit B la classe desautomobiles et C la classe des grues. D est donc la classe desgrues automobiles. Les deux interprtations de lhritagemultiple sont possibles : si lon hrite deux fois de la classe desengins moteur, la grue automotrice a deux moteurs : lun poursa partie automobile, lautre pour sa partie grue. Si lon hriteune seule fois de lengin moteur, on a un seul moteur qui sert la fois dplacer le vhicule et manuvrer la grue.
Soit maintenant A la classe des objets mobiles, contenant leschamps position et vitesse. Soit B la classe des bateaux, quicontient par exemple un champ pour le tonnage, et soit C laclasse des objets propulss par le vent, qui contient un champ
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
33/161
26 Les langages objets
pour la surface de la voile. D est alors la classe des bateaux voile. Une instance de D a bien entendu une seule position etune seule vitesse, et dans ce cas il faut partager les champs de Ahrits par diffrents chemins.
Lhritage multiple noffre pas de rponse satisfaisante ceproblme. La premire interprtation correspond unecomposition de classes, la seconde une combinaison. Lemcanisme de lhritage est certainement imparfait pourcapturer la fois les notions de spcialisation, denrichissement,de composition et de combinaison. Mais lhritage nest pas leseul moyen de dfinir des classes ! Lun des piges qui guettentle programmeur utilisant un langage objets est la mauvaise
utilisation de lhritage. La question quil faut se poser chaque dfinition de classe est la suivante : faut-il que B hritede A , ou bien B doit-elle contenir un champ qui soit uneinstance de A ?B est-il une sorte de A ou bien B contient-il unA ? Nous reviendrons au chapitre 6 sur la pratique de laprogrammation par objets, et en particulier sur ces problmes.
2.5 LE POLYMORPHISME
La notion de po lymo rphi sme recouvre la capacit pour unlangage de dcrire le comportement dune procdure de faonindpendante de la nature de ses paramtres. Ainsi la procdurequi change les valeurs de deux variables est polymorphe si lonpeut lcrire de faon indpendante du type de ses paramtres.De faon similaire la procdure Empiler est polymorphe si ellene dpend pas du type de la valeur empiler.
Comme le polymorphisme est dfini par rapport la notionde type, il ne concerne que les langages typs. On distingueplusieurs types de polymorphisme, selon la technique employepour sa mise en uvre :
Le polymorphisme ad hoc consiste crire plusieurs fois lecorps de la procdure, pour chacun des types de paramtres
souhaits. Cest ce que lon appelle souvent la surcharge : on
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
34/161
Principes de base 27
peut dfinir Echanger (Entier, Entier) etEchanger (Disque,Disque) de faon indpendante, de mme que Empiler (Pile,Entier) etEmpiler (Pile, Disque). Ce type de polymorphismeest gnralement rsolu de faon statique ( la compilation). Ilutilise le systme de types pour dterminer quelle incarnationde la procdure il faut appeler, en fonction des types effectifsdes paramtres de lappel.
Le polymorphisme dinc lus ion est fond sur une relationdordre partiel entre les types : si le type B est infrieur seloncette relation dordre au type A, alors on peut passer un objetde type B une procdure qui attend un paramtre de type A.Dans ce cas la dfinition dune seule procdure dfinit en
ralit une famille de procdures pour tous les types infrieursaux types mentionns comme paramtres. Si Entier etDisquesont tous deux des types infrieurs Objet, on pourra dfinirles procdure Echanger (Obje t, Objet) et Empiler (Pile,Objet).
Le polymorphisme paramtrique consiste dfinir un modlede procdure, qui sera ensuite incarn avec diffrents types. Ilest implment par la gnricit, qui consiste utiliser destypes comme paramtres. Ainsi si lon dfinit la procdureEchanger (, ), on pourra lincarner avec =Entier ou = Disque. On peut faire de mme pourEmpiler(Pile, ).
Ces trois types de polymorphisme existent dans diverslangages classiques. En Pascal le polymorphisme existe maisnest pas accessible lutilisateur ; on ne peut donc pas lequalifier puisque sa mise en uvre est implicite. Par exemple lesoprateurs arithmtiques sont polymorphes : laddition, lasoustraction, etc. sappliquent aux entiers, aux rels, et mmeaux ensembles. De mme, les procdures dentre-sortie readetwrite sont polymorphes puisquelles sappliquent diffrentstypes de paramtres.
Ada offre un polymorphisme ad hoc par la possibilit de
surcharge des noms de procdures et des oprateurs. Il offre
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
35/161
28 Les langages objets
galement un polymorphisme paramtrique par la possibilit dedfinir des fonctions gnriques. En revanche lepolymorphisme dinclusion est limit car trs peu de types sontcomparables par une relation dordre.
Le polymorphisme dans les langages objets
La dfinition du polymorphisme est dpendante de la notionde type. Pourtant, tous les langages objets ne sont pas typs.Un langage objets typ est un langage objets dans lequelchaque classe dfinit un type, et dans lequel on dclareexplicitement les types des objets que lon utilise. Les langages
objets typs fournissent naturellement le polymorphisme adhoc et le polymorphisme dinclusion. Certains langages offrentle polymorphisme paramtrique mais il ne fait pas partie desprincipes de base prsents dans ce chapitre.
Le polymorphisme ad hoc provient de la possibilit de dfinirdans deux classes indpendantes (cest--dire nayant pas derelation dhritage) des mthodes de mme nom. Le corps deces mthodes est dfini indpendamment dans chaque classe,mais du point de vue de lutilisateur, on peut envoyer le mmemessage deux objets de classes diffrentes. Ce polymorphismead hoc est intrinsque aux langages objets : il ne ncessiteaucun mcanisme particulier, et dcoule simplement du fait que
chaque objet est responsable du traitement des messages quilreoit.
La dfinition de plusieurs mthodes de mme nom dans unemme classe ou dans des classes ayant une relation dhritageest une forme de polymorphisme ad hoc qui nest pas implicitedans les langages objets, bien que la plupart dentre euxoffrent cette possibilit de surcharge. De plus, la redfinitiondune mthode dans une classe drive, avec le mme nom et lesmmes paramtres que dans la classe de base, ne constitue pasune surcharge mais une redfinition de mthode, comme nouslavons vu dans la description de lhritage (section 2.5).
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
36/161
Principes de base 29
Les langages objets disposent galement naturellement dunpolymorphisme dinclusion que lon appelle aussipolymorphisme dhri tage. En effet, la hirarchie des classes(dans le cas de lhritage simple) induit un ordre partiel : si Bhrite de A (directement ou indirectement), alors B est infrieurA. Toute mthode de A est alors applicable un objet de classeB : cest ainsi que lon a dfini lhritage des mthodes. Lepolymorphisme dhritage nous permet donc dappliquer lamthode Sommetde la classe Pile un objet de la classe Tour,puisque Tour est une sous-classe de Pile.
Le polymorphisme dhritage sapplique galement lhritage multiple, en dfinissant une relation dordre partiel
compatible avec le graphe dhritage de la faon suivante : uneclasse B est infrieure une classe A si et seulement si il existeun chemin orient de B vers A dans le graphe dhritage. Legraphe tant sans cycle, on ne peut avoir la fois un cheminorient de A vers B et un chemin orient de B vers A , ce quiassure la proprit dantisymtrie.
Le polymorphisme dhritage sapplique non seulement aureceveur des messages, mais galement au passage de paramtresdes mthodes : si une mthode prend un paramtre formel declasse A, on peut lui passer un paramtre rel de classeB siB estinfrieur A. Ainsi la mthode Empiler prend un paramtre declasse Entier. On peut lui passer un paramtre de classe Disque,siDisque hrite deEntier.
Liaison statique et liaison dynamique
Le polymorphisme dhritage interdit aux langages objetsun typage exclusivement statique : un objet dclar de classe Apeut en effet contenir, lexcution, un objet dune sous-classedeA. Les langages objets sont donc au mieux fortement typs,ce qui a des consquences importantes pour la compilation deces langages. Dans un langage typage statique, le compilateurpeut dterminer quelle mthode de quelle classe esteffectivement appele lors dun envoi de message : on appelle
cette technique la liaison statique.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
37/161
30 Les langages objets
Lorsque le typage statique ne peut tre ralis, on doit avoirrecours la liaison dynamique, cest--dire la dtermination lexcution de la mthode appeler. La liaison dynamique faitperdre un avantage important des langages compils :lefficacit du code engendr par le compilateur. La liaisondynamique doit aussi tre utilise dans les langages non typs,car labsence de systme de types interdit toute dtermination apriori de la mthode invoque par un envoi de message. Dansles deux cas, nous verrons les techniques employes pour rendrela liaison dynamique efficace.
Les liens troits entre polymorphisme, typage, et mode deliaison dterminent en grande partie les compromis raliss par
les diffrents langages objets entre puissance dexpression dulangage, scurit de programmation, et performance lexcution. De ce point de vue, il nexiste pas aujourdhui delangage idal, et il est probable quil ne puisse en exister.
2.6 LES MTACLASSES
Nous avons dfini jusqu prsent la notion dobjet de faonassez vague : un objet doit appartenir une classe. Certainslangages permettent de considrer une classe comme un objet ;en temps quobjet, cette classe doit donc tre linstance duneclasse. On appelle la classe dune classe une mtaclasse (voirfigure 6).
La description que nous avons donne dune classe ressembleeffectivement celle dun objet : une classe contient la liste desnoms des champs de ses instances et le dictionnaire desmthodes que lon peut invoquer sur les instances. La liste deschamps dune mtaclasse a donc deux lments : la liste desnoms de champs et le dictionnaire des mthodes.Linstanciation est une opration qui est ralise par une classe ;cest donc une mthode de la mtaclasse.
Une mtaclasse peut galement stocker dautres champs et
dautres mthodes. Ainsi, larbre dhritage tant une relation
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
38/161
Principes de base 31
Mtaclasse
Base
Drive
objets
classes
mtaclasses
Figure 6 - La notion de mtaclasse
entre les classes, chaque classe contient un champ qui dsigne saclasse de base (reprsent par les flches grises paisses dans lesfigures). Une mthode de la mtaclasse permet de tester si uneclasse est sous-classe dune autre classe.
Plusieurs modles de mtaclasses existent. Le plus simpleconsiste avoir une seule mtaclasse (appele par exempleMtaclasse). Le plus complet permet de dfinir arbitrairementdes mtaclasses. Cela autorise par exemple la redfinition delinstanciation ou lajout de mthodes de classes (dfinies dansla mtaclasse). Un modle intermdiaire, celui de Smalltalk-80,prvoit exactement une mtaclasse par classe. Lenvironnementde programmation se charge de crer automatiquement lamtaclasse pour toute classe cre par le programmeur. Cedernier peut dfinir des mthodes de classes, qui sont stockesdans le dictionnaire de la mtaclasse. Cette approche rend lesmtaclasses pratiquement transparentes pour le programmeur, et
offre un compromis satisfaisant dans la plupart des applications.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
39/161
32 Les langages objets
Dans tous les cas, la notion de mtaclasse induit une rgression linfini : en effet, une mtaclasse est une classe, donc un objet,et a donc une classe ; cette classe a donc une mtaclasse, qui estun objet, etc. Cette rgression est court-circuite par une boucledans larbre dinstanciation. Par exemple, la classe Mtac lasseest sa propre mtaclasse.
Les mtaclasses ont deux applications bien diffrentes. Lapremire est de permettre une dfinition mta-circulaire dunlangage et de rendre accessible ses propres structuresdexcution. On appelle cela la rification. Cette proprit existegalement en Lisp et permet dcrire trs simplement uninterprte Lisp en Lisp. Un langage rifi permet galement de
construire facilement des moyens dintrospection pour aider la mise au point des programmes : trace des envois de messageet des invocations de mthodes, trace des changements de valeurdes variables, etc.
La deuxime application des mtaclasses est de permettre laconstruction dynamique de classes. Prenons lexemple duneapplication graphique interactive dans laquelle lutilisateur peutcrer de nouveaux objets graphiques utilisables comme lesobjets primitifs (cercles, rectangles, etc.). Chaque nouvel objetgraphique, lorsquil est transform en modle, donne lieu lacration dune nouvelle classe. Cette nouvelle classe est crepar instanciation dune mtaclasse existante. En labsence demtaclasses, il faudrait dune faon ou dune autre simuler cemcanisme, ce qui peut tre fastidieux.
Disposer de mtaclasses dans un langages objets signifie quelon peut dynamiquement ( lexcution) dfinir de nouvellesclasses et modifier des classes existantes. Cela interdit donc touttypage statique, et cest la raison pour laquelle les mtaclasses nesont disponibles que dans les langages non typs. Certainslangages typs utilisent nanmoins implicitement desmtaclasses, en autorisant par exemple la redfinition desmthodes dinstanciation. Il est galement possible de dfinirdes objets qui jouent le rle des mtaclasses pour la
reprsentation, lexcution, de larbre dhritage. Mais la
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
40/161
Principes de base 33
pleine puissance des mtaclasses reste rserve aux langages nontyps.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
41/161
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
42/161
Chapitre 3
LANGAGES OBJETSTYPS
Ce chapitre prsente les langages objets typs, dont Simula estlanctre. Ce dernier tant peu utilis aujourdhui, ce sont leslangages plus rcents C++, Eiffel et Modula3 qui nous servirontde base. La premire version de C++ a t dfinie en 1983 par
Bjarne Stroustrup aux Bell Laboratories, le mme centre derecherches o sont ns Unix et le langage C. Eiffel est unlangage cr partir de 1985 par Bertrand Meyer de InteractiveSoftware Engineering, Inc. Modula3 est une nouvelle version deModula dveloppe depuis 1988 au Systems Research Center deDEC sous limpulsion de Luca Cardelli et Greg Nelson.
Nous utilisons pour les exemples un pseudo-langage dont lasyntaxe, inspire en grande partie de Pascal, se veut intuitive.Nous donnons ci-dessous la description de ce langage sousforme de notation BNF tendue, avec les conventions suivantes :
les mots cls du langage sont en caractres gras ;
les autres terminaux sont en italique ;
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
43/161
36 Les langages objets
les crochets indiquent les parties optionnelles ; la barre verticale dnote lalternative ;
les parenthses servent grouper des parties de rgles ;
+ indique la rptition au moins une fois ;
* indique la rptition zro ou plusieurs fois ;
les indicateurs de rptition peuvent tre suivis dunevirgule ou dun point-virgule qui indique le sparateur utiliser lorsquil y a plus dun lment dans la liste ;
prog ::= ( classe | mthode )+
classe ::= id-cls = classe [id-cls +,] {
[champs champs+][mthodes mthodes+]
}
champs ::= id-champ +,: type ;
mthodes ::= procdure id-proc (param*;);| fonction id-fonc (param*;): type ;
type ::= id-cls | entier | boolen| tableau[ const .. const ]de type
param ::= id-param +,: type
mthode ::= procdure id-cls.id-proc (param*;) bloc
| fonction id-cls.id-fonc (param*;): type bloc
bloc ::= { [decl+] instr*;}
decl ::= id-var +,: type ;
instr ::= var := expr| [var.]id-proc (expr*,)| tantque expr-bool faire instr| si expr-bool alors corps [sinon instr]| pour id-var := expr expr faire instr| retourner [expr]| bloc
var ::= id(.id-champ)* | var [ expr ]
id ::= id-var | id-param | id-champ
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
44/161
Langages objets typs 37
expr ::= var | const| [var.]id-fonc (expr*,)| expr ( + | - | * |/) expr
expr-bool ::= expr ( < | > | = | ) expr| expr-bool ( et | ou ) expr-bool| non expr-bool
Pour complter cette description, il convient de prciser queles commentaires sont introduits par deux tirets et se poursuiventjusqu la fin de la ligne.
3.1 CLASSES, OBJETS, MTHODES
Dfinir une classe
La notion de classe dobjets est une extension naturelle de lanotion de type enregistrement. En effet, une classe contient ladescription dune liste de champs, complte par la descriptiondun ensemble de mthodes.
Notre classe Pile peut scrire :
Pile = classe {champs
pile : tableau [1..N] de entier;sommet : entier;
mthodesprocdure Empiler (valeur: entier);procdure Dpiler ();fonction Sommet () : entier;
}
La dclaration dun objet correspond linstanciation :
p1 : Pile;
Linvocation des mthodes dun objet utilise loprateur
point ( . ), qui permet traditionnellement laccs un champ
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
45/161
38 Les langages objets
dun enregistrement. On peut donc considrer que les mthodesse manipulent comme des champs de lobjet :
p1.Empiler (10);p1.Empiler (15);p1.Dpiler ();s := p1.Sommet (); -- s vaut 10
Cette notation indique clairement quel est le receveur dumessage (ici p1), la mthode invoque, et ses paramtres.Comme lenvoi de message ncessite imprativement unreceveur, on ne peut invoquer les mthodes autrement que parcette notation pointe :
Empiler (10)
na pas de sens car on ne connat pas le receveur du message,sauf sil y a un receveur implicite, comme nous le verrons plusloin.
Cette mme notation pointe permet daccder aux champs delobjet :
p1.pile [5];
Les rgles de visibilit empchent gnralement un tel accs auxchamps. Comme nous lavons vu au chapitre 2, les champs sontdun accs priv tandis que les mthodes sont dun accs
public. Ceci signifie que les champs dun objet sont accessiblesseulement par cet objet, alors que les mthodes sont accessiblespar tout objet grce lenvoi de message.
Dfinir des mthodes
La dclaration dune classe contient les en-ttes des mthodes.Nous allons dcrire leurs corps de faon spare. Pour cela,nous utiliserons la notation classe.mthode qui permet unequalification complte de la mthode. En effet, deux mthodesde mme nom peuvent tre dfinies dans deux classesdiffrentes. Rappelons que cela constitue la premire forme depolymorphisme offerte par les langages objets, le
polymorphisme ad hoc.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
46/161
Langages objets typs 39
Selon les langages, la faon de dclarer les corps des mthodesvarie. La notation que nous avons choisie est inspire de C++.Eiffel adopte une autre convention qui consiste mettre lesdclarations de mthodes dans un bloc associ la classe oelles sont dfinies, ce qui pourrait tre transcrit de la faonsuivante dans notre pseudo-langage :
Pile = classe {procdure Empiler (valeur : entier) {
-- corps de Empiler}-- etc.
}
La notation qualifie que nous avons adopte ici permet desparer la dclaration de la classe de la dclaration des corps desmthodes, mais les deux mcanismes sont strictementquivalents.
Dans notre exemple, si lon omet les tests de validit desoprations (pile vide, pile pleine), on a les dfinitions de corpsde mthodes suivantes :
procdure Pile.Empiler (valeur: entier) {-- attention : pas de test de dbordementsommet := sommet + 1;pile [sommet] := valeur;
}procdure Pile.Dpiler () {
-- attention : pas de test de pile videsommet := sommet - 1;
}
fonction Pile.Sommet () : entier {retourner pile [sommet];
}
Une mthode est toujours invoque avec un objet receveur,qui sert de contexte son excution. Laccs aux champs delobjet receveur (pile et sommet dans notre exemple) se fait en
mentionnant directement leurs noms.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
47/161
40 Les langages objets
Pour tre plus prcis, les entits accessibles depuis unemthode sont :
lobjet receveur,
les champs de lobjet receveur,
les mthodes de lobjet receveur,
les paramtres de la mthode,
les variables locales de la mthode,
les objets dclars de faon globale au programme.
Les champs des objets et les paramtres tant eux-mmes desobjets, on peut invoquer leurs mthodes. Pour illustrer cela,supposons lexistence dune classe Fichier et crivons denouvelles mthodes pour la classe Pile (ces mthodes doiventtre ajoutes la dclaration de la classe Pile) :
procdure Pile.crire (sortie : Fichier) {pour i := 1 sommet faire sortie.crire (pile [i]);
}procdure Pile.Vider () {
tantque sommet > 0 faire Dpiler ();}
Pile.crire invoque la mthode crire du paramtre sortie.Elle crit sur ce fichier lensemble des lments de la pile. Nous
supposons ici que cri re est une mthode de la classeFichier.Pile.Vider invoque la mthode Dpiler sans la qualifierpar un receveur, ce qui semble contraire ce que nous avons ditplus haut. Mais ici on est dans le contexte dun objet receveurde classe Pile, qui devient le receveur implicite de Dpiler (voirfigure 7). Cest par un mcanisme identique que sommet reprsente le champ sommetde lobjet receveur du message.
La pseudo-variable moi
Bien que lobjet receveur soit implicite en ce qui concernelaccs aux champs et aux mthodes, il est parfois ncessaire dele rfrencer explicitement, par exemple pour le passer enparamtre une autre mthode. Selon les langages, il porte le
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
48/161
Langages objets typs 41
Pile
Vider ( ) {tant que sommet > 0 faire
Dpiler ( );}
Dpiler ( ) {
}
Vider1
2
3
pilesommet
4
Figure 7 - Accs aux champs et aux mthodes.Les flches hachures reprsentent linvocation de mthode
nom rserv de self (Modula3, mais aussi Smalltalk), Current (Eiffel), this (C++). Nous lappellerons moi .Moi nest pas proprement parler un objet, mais une faon derfrencer le receveur de la mthode en cours dexcution. Onutilise pour cela le terme de pseudo-variable.
Lexemple suivant illustre lutilisation de moi. Les classesSommetetArc permettent de reprsenter un graphe. Un sommetest reli un ensemble darcs, et un arc relie deux sommets.
Sommet = classe {champs
-- reprsentation des arcs adjacentsmthodes
procdure Ajouter (a : Arc);}
Arc = classe {champs
dpart, arrive : Sommet;mthodes
procdure Relier (s1, s2 : Sommet);}
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
49/161
42 Les langages objets
crivons le corps de la mthode Relier de la classeArc :procdure Arc.Relier (s1, s2 : Sommet) {
dpart := s1;arrive := s2;s1.Ajouter (moi);s2.Ajouter (moi);
}
Cet exemple montre quil est indispensable de pouvoirrfrencer explicitement le receveur du message dans le corpsde la mthode invoque : cest larc qui reoit le message Relierqui doit tre ajout aux sommets s1 et s2.
On peut galement utiliser la pseudo-variable moi pourqualifier les champs et les mthodes locales, mais cela napporterien sinon une notation plus lourde. La mthode Vider de laclasse Pile pourrait ainsi scrire comme suit :
procdure Pile.Vider () {tantque moi.sommet > 0 faire moi.Dpiler ();
}
Les classes primitives
Nous avons utilis pour dfinir la classe Pile un champ detype entier et un champ de type tableau, considrant ces typescomme prdfinis dans le langage. Le statut de ces typesprdfinis varie dun langage lautre. En gnral, les typesatomiques (entier, boolen, caractre) ne sont pas des classes eton ne peut en hriter. Les types structurs comme les tableauxsont parfois accessibles comme des classes gnriques.
On peut toujours construire une classe qui contient un champdun type prdfini. Malheureusement, moins de disposer demcanismes de conversion implicite entre types atomiques etclasses, on ne peut utiliser ces classes de faon transparente.
Par exemple, si lon dfinit la classe En ti er , contenant unchamp de type entier, comme suit :
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
50/161
Langages objets typs 43
Entier = classe {champs
valeur : entier;mthodes
procdure Valeur (v : entier);}procdure Entier.Valeur (v : entier) {
valeur := v;}
et si lon change le type entier par la classeEntier dans la classePile, on ne peut plus crire
p1.Empiler (10);
car 10 est une valeur du type prdfini entier, et non un objet dela classe Entier . Sans mcanisme particulier du langage, il fautcrire :
v : Entier;v.Valeur (10);p1.Empiler (v);
La diffrence de statut entre types atomiques et classes rsultedun compromis dans lefficacit de limplmentation deslangages objets typs. Cette diffrence ne pose que peu deproblmes dans la pratique, bien quelle soit peu satisfaisantepour lesprit.
3.2 HRITAGE
Nous allons maintenant prsenter comment est mis en uvrelun des concepts de base des langages objets : lhritage.Nous allons pour cela prsenter les deux principales utilisationsde lhritage, la spcialisation et lenrichissement.
Spcialisation par hritage
Nous dfinissons maintenant une sous-classe de la classe Pile,la classe Tour . Rappelons quune tour est une pile dont lesvaleurs sont dcroissantes.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
51/161
44 Les langages objets
Tour = classe Pile {mthodes
procdure Initialiser (n : entier);fonction PeutEmpiler (valeur : entier) : boolen;procdure Empiler (valeur : entier);
}
Lhritage est mentionn dans len-tte de la dclaration(comparer avec la dclaration de la classe Pile). La procdureInitialiser empile n disques de tailles dcroissantes :
procdure Tour.Initialiser (n : entier) {sommet := 0;
pour i := n 1 faire Empiler (i);}
Init ialiser invoque la mthode Empiler, qui est redfinie dansla classe Tour. Dfinissons maintenant les corps des mthodesPeutEmpiler etEmpiler :
fonction Tour.PeutEmpiler (valeur : entier) : boolen {si sommet = 0
alors retourner vrai;sinon retourner valeur < Sommet ();
}
La mthode PeutEmpiler rfrence le champ sommet de saclasse de base ainsi que la mthode Sommet dfinie galement
dans la classe de base. Elle teste si la valeur peut tre empile,cest--dire si la tour est vide ou sinon si la valeur est plus petiteque le sommet courant de la tour. Empiler utilise PeutEmpilerpour dcider de lempilement effectif de la valeur :
procdure Tour.Empiler (valeur : entier) {si PeutEmpiler (valeur)
alors Pile.Empiler (valeur);sinon erreur.crire (impossible dempiler);
}
On suppose ici lexistence dun objet global erreur, de laclasse Fichier, qui permet de communiquer des messages lutilisateur grce sa mthode crire .
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
52/161
Langages objets typs 45
Tour
Empiler (valeur: entier) {
Pile. Empiler (valeur);
}
Pile
Empiler
Figure 8 - Spcialisation de la mthode Empiler
Lappel de Pile.Empiler (valeur) mrite quelques explications.La classe Tour est une spcialisation de la classe Pile, cest--dire que lon a simplement redfini une mthode de la classePile. Dans cette situation, la mthode redfinie a souvent besoinde rfrencer la mthode de mme nom dans la classe de base.Si lon avait crit
Empiler (valeur)
on aurait provoqu un appel rcursif, puisque lon est dans lecorps de la mthodeEmpiler de la classe Tour. La notation
Pile.Empiler (valeur)
permet de qualifier le nom de la mthode appele. Comme Tourhrite de Pile, la mthode Empiler de Pile est accessible dans lecontexte courant, mais elle est cache par sa redfinition dans laclasse Tour (voir figure 8). La notation qualifie permet laccs la mthode de la classe de base, dans le contexte de lobjetreceveur. Elle ne peut tre utilise que dans cette situation.
Une fois la classe Tour dfinie, on peut en dclarer desinstances et invoquer des mthodes :
t : Tour;...t.Empiler (10);
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
53/161
46 Les langages objets
t.Dpiler;t.Empiler (20);t.Empiler (5); -- impossible dempiler
Comme on la dit, les mthodes de la classe de base restentaccessibles. Dans cet exemple, t.Dpiler invoque Pile.Dpiler.
Enrichissement par hritage
Nous allons maintenant dfinir une classe drive de la classeTour en ajoutant la possibilit de reprsenter graphiquement latour. Pour cela nous supposons lexistence des classes Fentre etRectangle, avec les dfinitions partielles suivantes :
Fentre = classe {mthodes
procdure Effacer ();}
Rectangle = classe {mthodes
procdure Centre (posX, posY : entier);procdure Taille (largeur, hauteur : entier);procdure Dessiner (f : Fentre);
}
TourG est une sous-classe de Tour dfinie comme suit :
TourG = classe Tour {champs
f : Fentre;x, y : entier;
mthodesprocdure Placer (posX, posY : entier);procdure Dessiner ();procdure Empiler (valeur: entier);procdure Dpiler ();
}
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
54/161
Langages objets typs 47
Il sagit ici dun enrichissement : trois nouveaux champsindiquent la fentre de lcran dans laquelle sera affiche latour, et la position de la tour dans cette fentre. Chaque tage dela tour sera reprsent par un rectangle de taille proportionnelle la valeur entire qui le reprsente dans la tour. Deux nouvellesmthodes permettent daffecter une position la tour et dedessiner la tour. Enfin, les mthodes Empiler et Dpiler sontredfinies afin dassurer que la tour est redessine chaquemodification. Le corps des mthodes est dcrit ci-dessous.
Placer affecte la position de la tour et la redessine.
procdure TourG.Placer (posX, posY : entier) {
x := posX;y := posY;Dessiner ();
}
Dessiner commence par effacer la fentre, puis redessine latour tage par tage. Dessiner est similaire dans son principe lamthode crire dfinie auparavant dans la classe Pile.
procdure TourG.Dessiner () {rect : Rectangle;f.Effacer ();pour i := 1 sommet faire {
rect.Centre (x, y - i);
rect.Taille (pile [i], 1);rect.Dessiner (f);
}}
Empiler etDpiler invoquent la mthode de mme nom dansla classe de base Tour et redessinent la tour. On pourrait bien sroptimiser laffichage, mais ce nest pas lobjet de lexemple.
procdure TourG.Empiler (valeur: entier) {Tour.Empiler (valeur);Dessiner ();
}
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
55/161
48 Les langages objets
procdure TourG.Dpiler () {Tour.Dpiler ();Dessiner ();
}
Il est noter que Tour.Dpiler na pas t dfinie. En fait laclasse Tour hriteDpiler de la classe Pile, donc Tour.Dpiler estidentique Pile.Dpiler . Nanmoins, il serait imprudentdutiliser Pile.Dpiler directement car on peut tre amen redfinir Dpiler dans Tour.
3.3 HRITAGE MULTIPLE
Lhritage multiple permet dutiliser plusieurs classes de base.La classe TourG , par exemple, reprsente une tour qui saitsafficher dans une fentre. En changeant lgrement de pointde vue, on peut considrer que la classe TourG est la fois unetour et une fentre. On a alors un hritage multiple de Tour etde Fentre (figure 9). Voyons la dfinition de la classe TourGMainsi obtenue :
TourGM = classe Tour, Fentre {champs
x, y : entier;mthodes
procdure Placer (posX, posY : entier);procdure Dessiner ();procdure Empiler (valeur: entier);procdure Dpiler ();
}
Lhritage multiple est mentionn en faisant apparatre la listedes classes de base dans len-tte de la dclaration. Le champ fnapparat plus : il est remplac par lhritage de Fentre.
La seule mthode qui change par rapport la classe TourG estla mthodeDessiner :
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
56/161
Langages objets typs 49
Pile
Tour Fentre
Tour GM
Figure 9 - Hritage multiple de la classe TourGM
procdure TourGM.Dessiner () {rect : Rectangle;Effacer ();pour i := 1 sommet faire {
rect.Centre (x, y - i);rect.Taille (pile [i], 1);rect.Dessiner (moi);
}}
On constate que linvocation de la mthode Effacer nest plusqualifie par le champ f. En effet, cette mthode est maintenanthrite de la classe Fentre . Par ailleurs, linvocation de lamthode Dessiner prend comme argument la pseudo-variablemoi . En effet, TourGM hrite maintenant de Fentre, donc uneTourGMest une fentre : on utilise ici le polymorphismedhritage sur le paramtre de la mthode Dessiner.
Bien que les diffrences entre les implmentations de TourG etTourGM soient minimes, leffet de lhritage multiple est plus
important quil ny parat. En effet, alors que TourG nhrite
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
57/161
50 Les langages objets
que des mthodes de Tour, TourGMhrite de celles de Tour etde Fentre. Il est donc tout fait possible dcrire :
tgm : TourGM;tgm.Placer (100, 100);tgm.Empiler (20);tgm.Empiler (10);tgm.Effacer ();
Linvocation dEffacer est correcte puisque Effacer est hritede Fentre. Pour un objet de la classe TourG, cet envoi demessage aurait t illicite. On voit donc que le choix
dimplmenter une tour graphique par la classe TourG ou laclasse T o u r G M dpend du contexte dutilisation danslapplication. Lhritage, comme lhritage multiple, ne doit pastre utilis comme une facilit dimplmentation, mais commeune faon de spcifier des liens privilgis entre classes.
Lhritage multiple cre cependant une ambigut : supposonsque la classe Fentre dfinisse une mthode crire, qui imprimeson tat. La classe Tour de son ct hrite une mthode crirede la classe Pile. Que se passe-t-il si lon crit :
tgm.crire (fich);
Il y a un conflit car la classe TourGMhrite deux fois de la
mthode crire . Les langages rsolvent ce problme dediffrentes manires :
lordre de lhritage multiple dtermine une priorit entreles classes ; dans notre cas TourGMhrite dabord de Tour,puis de Fentre, donc Tour.crire masque Fentre.crire .Le rsultat est donc dimprimer la tour, cest--dire la pile.
il faut qualifier linvocation de la mthode, par exempletgm.Fentre.crire (fich). Cela suppose donc quelutilisateur connaisse le graphe dhritage, ce qui nefavorise pas lide dencapsulation et dabstraction. Cest lemcanisme choisi par Modula3 et C++.
il faut renommer, lors de lhritage, les mthodes quiengendrent des conflits. On peut ainsi hriter de Tour, et de
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
58/161
Langages objets typs 51
Fentre en renommant la mthode crire hrite de fentreencrireF. tgm.crire(fich) imprime donc la tour, alors quetgm.crireF(fich) imprime la fentre. Cest le mcanismeimpos par Eiffel, et disponible en C++.
il faut dfinir une mthode crire dans la classe TourGM,qui lvera le conflit en masquant les deux mthodes crire.
La dernire mthode est toujours ralisable. Dans notreexemple, on pourrait dfinir cette mthode de la faon suivante :
procdure TourGM.crire (sortie : Fichier) {Tour.crire (sortie);Fentre.crire (sortie);sortie.crire (x);sortie.crire (y);
}
Cette mthode crit la partie Tour , la partie Fentre et leschamps propres de To u r G M . Les invocations qualifiesTour.crire et Fentre.crire lvent lambigut en mme tempsquelles vitent lappel rcursif de TourGM.crire.
Lorsque des champs de plusieurs classes de base portent lemme nom, les mmes problmes de conflits daccs se posent.Ils sont rsolus par un accs qualifi (en C++) ou parrenommage (en Eiffel).
Nous avons voqu au chapitre prcdent dautres problmesconcernant lhritage multiple, et notamment lhritage rpt :que se passe-t-il si une classe hrite, directement ouindirectement, plusieurs fois de la mme classe ? Faut-ildupliquer les champs de cette classe ou doivent-ils apparatreune seule fois ?
En C++, la notion de classe de base virtuelle permet de ne voirquune fois une classe de base qui est accessible par plusieurschemins dhritage. En Eiffel, le contrle est plus fin car chaquechamp dune classe de base hrite plusieurs fois peut tredupliqu ou partag, selon que le champ est renomm ou non.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
59/161
52 Les langages objets
3.4 LIAISON DYNAMIQUETel que nous lavons prsent, lhritage des mthodes dans
un langage objets typ permet de dterminer de faon statiqueles invocations de mthodes : pour un objet o de la classe A ,lappel
o.m (paramtres)
est rsolu en recherchant dans la classe A une mthode de nomm . Si elle nest pas trouve, la recherche se poursuit dans laclasse de base de A, et ainsi de suite jusqu trouver la mthodeou atteindre la racine de larbre dhritage. Si la mthode esttrouve, linvocation de mthode est correcte, sinon elle est
errone.
Le compilateur peut profiter de cette recherche, destine vrifier la validit du programme, pour engendrer le code quiappelle directement la mthode trouve. Cela vite unerecherche similaire lexcution et rend donc le programmeplus efficace. Cela sappelle la liaison statique.
Malheureusement, le polymorphisme dhritage rend cetteoptimisation invalide, comme le montre lexemple suivant :
t : Tour ;tg : TourG ;
...t := tg ;t.Empiler (10) ; -- que se passe-t-il ?
Laffectation de la tour graphique tg la tour simple t estcorrecte en vertu du polymorphisme dhritage : une tourgraphique est un cas particulier de tour, donc un objet de typetour peut rfrencer une tour graphique. En utilisant la liaisonstatique, le compilateur rsout linvocation dEmpiler parlappel de Tour.Empiler, car t est dclar de type Tour. Mais tcontient en ralit, lors de lexcution, un objet de classe TourG,et linvocation de Tour.Empiler est invalide : il aurait falluinvoquer TourG.Empiler.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
60/161
Langages objets typs 53
Dans cet exemple, le typage statique ne nous permet pas desavoir que t contient en ralit un objet dune sous-classe deTour et la liaison statique brise la smantique du polymorphismedhritage.
Les mthodes virtuelles
Ce problme avait t not ds Simula, et rsolu enintroduisant la notion de mthode virtuelle : en dclarantEmpiler virtuelle, on indique dutiliser une liaison dynamique etnon plus une liaison statique : le contrle de type a toujours lieu la compilation, mais la dtermination de la mthode appeler
a lieu lexcution, en fonction du type effectif de lobjet. Oncomprend aisment que la liaison dynamique est plus chre lexcution que la liaison statique, mais quelle est indispensablesi lon veut garder la smantique du polymorphisme dhritage.
Lexemple suivant montre une autre situation dans laquelle lesmthodes virtuelles sont indispensables :
tg : TourG ;tg.Initialiser (4);
On initialise une tour graphique avec quatre disques. Nousallons voir que l encore, il faut que Empi ler ait t dclarevirtuelle. La procdure In it ialiser est hrite de Tour. Voicicomment nous lavons dfinie :
procdure Tour.Initialiser (n : entier) {pour i := n 1 faire Empiler (i);
}
Si Empi le r nest pas dclare virtuelle, son invocation estrsolue par liaison statique par lappel de Tour.Empiler, puisquele receveur est considr de classe Tour. Lorsque lon invoquetg.Initialiser(4), le receveur sera en ralit de classe TourG, etcest la mauvaise version dEmpi ler qui sera invoque (voirfigure 10). En dclarant Empiler virtuelle, ce problme disparat.En loccurrence, cest TourG.Empiler qui sera invoque,provoquant le dessin de la tour au fur et mesure de son
initialisation.
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
61/161
54 Les langages objets
Initialiser (4)
TourG
Empiler (v) {}
Tour
Empiler (v) {}
Initialiser (n) {pour i := n 1
Empiler (i)}
Statique
Dynamique
13
3'
2
tg
Figure 10 - Liaison statique contre liaison dynamique
Lutilisation extensive du polymorphisme dans les langages objets pourrait laisser penser que toutes les mthodes doiventtre virtuelles. Cest la solution choisie dans Eiffel et Modula3,qui assurent au programmeur que tout se passe comme si laliaison tait toujours dynamique.
Par contre, C++ et Simula obligent dclarer explicitement lesmthodes virtuelles comme telles. Cela offre au programmeur lapossibilit de choisir entre la scurit de la liaison dynamique etlefficacit de la liaison statique, ses risques et prils. Enpratique, on se rend compte quun nombre limit de mthodesont effectivement besoin dtre virtuelles, mais quil est difficilede dterminer lesquelles, surtout lorsque les classes sontdestines tre rutilises.
Limplmentation de la liaison dynamique
Limplmentation usuelle de la liaison dynamique consiste attribuer chaque mthode virtuelle un indice unique pour la
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
62/161
Langages objets typs 55
une Tour
une Pile
une autre Pile
Pile
EmpilerDpiler
Tour
EmpilerDepiler
Code de Pile.EmpilerCode de Pile.Dpiler
Code de Tour.Empiler
Figure 11 - Implmentation de la liaison dynamique
hirarchie de classes laquelle elle appartient. Lors delexcution, chaque classe est reprsente par une table, quicontient pour un indice donn ladresse de la mthodecorrespondante de cette classe. Chaque objet dune classecontenant des mthodes virtuelles contient ladresse de cette
table (figure 11). Linvocation dune mthode exigesimplement une indirection dans cette table. Le cot delimplmentation est donc le suivant :
une table, dite table virtuelle, par classe ;
un pointeur vers la table virtuelle par objet ;
une indirection par invocation de mthode virtuelle.
On peut considrer ce cot comme acceptable, surtout si on lecompare au cot dinvocation des mthodes dans les langagesnon typs (dcrit la fin de la section 4.3 du chapitre 4). Onpeut aussi considrer quil est inutile de supporter ce cotsystmatiquement, et cest la raison pour laquelle Simula et C++
donnent le choix (et la responsabilit) au programmeur de
7/31/2019 Beaudouin-Lafon Les Langages Objets (Armand Colin)
63/161
56 Les langages objets
dclarer virtuelles les mthodes quil juge utile. Modula3, aucontraire, tire parti de la table virtuelle ncessaire chaque objetpour autoriser un objet redfinir des mthodes : il suffit de luicrer une table virtuelle propre. On quitte alors le modle strictdes langages de classes, puisque ce nest plus la classe quidtient le comportement de toutes ses instances.
3.5 RGLES DE VISIBILIT
La dclaration explicite des types dans un langage assu
Top Related