artpoo

8/3/2019 artpoo

1/33

Introduction la Programmation Oriente Objet

parEric Sigoillot (site)

Date de publication : 25/07/2004

Dernire mise jour : 10/09/2011

Dans ce tutoriel vousapprendrez manier

la ProgrammationOriente Objet, ou POOpour les intimes, dansle cadre du langage

Pascal Orient Objet.Loin d'tre aussi complexe

qu'elle peut le laissertransparatre, la POO peut

se matriser rapidementau point de ne plus

pouvoir s'en passer.
http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

2/33

Introduction la Programmation Oriente Objet parEric Sigoillot (site)

- 2 -Les sources prsentes sur cette pages sont libres de droits, et vous pouvez les utiliser votre convenance. Par contre la page de prsentationde ces sources constitue une oeuvre intellectuelle protge par les droits d'auteurs. Copyright 2004-2011 - Eric Sigoillot. Aucune reproduction,mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse del'auteur. Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.

http://hdd34.developpez.com/cours/artpoo/

Avant-Propos................................................................................................................................................................31 - Vue d'ensemble de la POO...................................................................................................................................41.1 - L'objet.................................................................................................................................................................. 51.2 - Objet et classe....................................................................................................................................................61.3 - Les trois fondamentaux de la POO....................................................................................................................7

1.3.1 - Encapsulation..............................................................................................................................................7

1.3.2 - Hritage.......................................................................................................................................................71.3.3 - Polymorphisme........................................................................................................................................... 9

2 - Diffrents types de mthodes..............................................................................................................................112.1 - Constructeurs et destructeurs..................................................................................................................... 11

2.1.1 - Constructeurs...................................................................................................................................... 112.1.2 - Destructeurs........................................................................................................................................ 11

2.2 - Pointeur interne........................................................................................................................................... 112.3 - Mthodes virtuelles et mthodes dynamiques............................................................................................ 12

2.3.1 - Mthodes virtuelles............................................................................................................................. 122.3.1.1 - Principe....................................................................................................................................... 122.3.1.2 - Constructeurs et Table des Mthodes Virtuelles........................................................................ 13

2.3.2 - Mthodes dynamiques........................................................................................................................ 13

2.4 - Mthodes abstraites.................................................................................................................................... 133 - Visibilit................................................................................................................................................................ 153.1 - Champs et mthodes publics......................................................................................................................153.2 - Champs et mthodes privs....................................................................................................................... 153.3 - Champs et mthodes protgs................................................................................................................... 15

4 - Le Pascal Objet................................................................................................................................................... 164.1 - Dclaration d'un objet..................................................................................................................................16

4.1.1 - Dclaration simple...............................................................................................................................164.1.2 - Dclarations imbriques......................................................................................................................16

4.2 - Champs et mthodes.................................................................................................................................. 174.2.1 - Procdures et fonctions...................................................................................................................... 184.2.2 - Constructeurs...................................................................................................................................... 194.2.3 - Destructeurs........................................................................................................................................ 20

4.2.4 - Mthodes virtuelle et dynamique........................................................................................................ 204.2.5 - Mthodes abstraites............................................................................................................................ 214.2.6 - Paramtre implicite Self...................................................................................................................... 22

4.3 - Visibilit........................................................................................................................................................ 224.4 - Hritage........................................................................................................................................................23

4.4.1 - Dclaration...........................................................................................................................................234.4.2 - Surcharge et appel de l'anctre..........................................................................................................24

4.4.2.1 - Anctre direct..............................................................................................................................244.4.2.2 - Anctre indirect........................................................................................................................... 25

4.4.3 - Valeur de retour d'un constructeur......................................................................................................254.4.4 - Ordre d'appel de l'anctre dans les constructeurs et destructeurs.....................................................26

4.5 - Instanciation d'un objet................................................................................................................................26

4.5.1 - Instanciation statique...........................................................................................................................264.5.2 - Instanciation dynamique......................................................................................................................274.5.2.1 - Allocation.....................................................................................................................................274.5.2.2 - Dsallocation...............................................................................................................................29

4.6 - L'objet gnrique TObject............................................................................................................................30Conclusion..................................................................................................................................................................32Remerciements.......................................................................................................................................................... 33
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

3/33




Avant-Propos

Si la programmation dite procdurale est constitue de procdures et fonctions sans liens particuliers agissant sur desdonnes dissocies pouvant mener rapidement des difficults en cas de modification de la structure des donnes,la programmation objet, pour sa part, tourne autour d'une unique entit : l'objet, offrant de nouvelles perspectives,

et que je vous invite dcouvrir de suite...

Attention !

Borland a longtemps employ le nom de Pascal Objet pour Delphi. Celui-ci a t

rcemment renomm langage Delphi. Nous n'aborderons pas dans ce tutoriel une

approche spcifique Delphi. Nous nous orienterons plus vers une approche gnrale

du Pascal, tous compilateurs Pascal confondus sitt que ceux-ci supportent la

Programmation Oriente Objet, comme c'est le cas pour Turbo Pascal, Free Pascal,

GNU Pascal... et bien srDelphi.
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

4/33




1 - Vue d'ensemble de la POO

Avant de rentrer plus avant dans le sujet qui nous intresse, nous allons commencer par poser un certain nombrede bases.

8/3/2019 artpoo

5/33




1.1 - L'objet

Il est impossible de parler de Programmation Oriente Objet sans parler d'objet, bien entendu. Tchons donc dedonner une dfinition aussi complte que possible d'un objet.Un objet est avant tout une structure de donnes. Autrement, il s'agit d'une entit charge de grer des donnes,

de les classer, et de les stocker sous une certaine forme. En cela, rien ne distingue un objetd'une quelconque autrestructure de donnes. La principale diffrence vient du fait que l'objetregroupe les donnes et les moyens detraitement de ces donnes.Un objetrassemble de fait deux lments de la programmation procdurale.

Les champs :Les champs sont l'objet ce que les variables sont un programme : ce sont eux qui ont en charge lesdonnes grer. Tout comme n'importe quelle autre variable, un champ peut possder un type quelconquedfini au pralable : nombre, caractre... ou mme un type objet.

Les mthodes :Les mthodes sont les lments d'un objet qui servent d'interface entre les donnes et le programme. Sous

ce nom obscur se cachent simplement des procdures ou fonctions destines traiter les donnes.

Les champs et les mthodes d'un objet sont ses membres.Si nous rsumons, un objetest donc un type servant stocker des donnes dans des champs et les grer autravers des mthodes.Si on se rapproche du Pascal, un objet n'est donc qu'une extension volue des enregistrements (type record)disposant de procdures et fonctions pour grer les champs qu'il contient.

On notera souvent les membres d'un objetObjet.Membre de faon lever toute ambigut

quant au propritaire du membre considr.
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

6/33




1.2 - Objet et classe

Avec la notion d'objet, il convient d'amener la notion de classe. Cette notion de classe n'est apparue dans le langagePascal qu'avec l'avnement du langage Delphi et de sa nouvelle approche de la Programmation Oriente Objet. Elleest totalement absente du Pascal standard.

Ce que l'on a pu nommer jusqu' prsent objet est, pour Delphi, une classe d'objet. Il s'agit donc du type proprement parler. L'objet en lui-mme est une instance de classe, plus simplement un exemplaire d'une classe,sa reprsentation en mmoire.Par consquent, on dclare comme type une classe, et on dclare des variables de ce type appeles des objets.Si cette distinction est bien prendre en considration lors de la programmation en Delphi, elle peut toutefois tretotalement ignore avec la plupart des autres compilateurs Pascal. En effet, ceux-ci ne s'appuient que sur les notionsd'objet et d'instance d'objet.Nous adopterons par consquent ici ce point de vue qui simplifie le vocabulaire et la comprhension.On pourra remarquer que Free Pascal pour sa part dfinit une classe comme un "pointeur vers un objet ou unenregistrement".

8/3/2019 artpoo

7/33




1.3 - Les trois fondamentaux de la POO

La Programmation Oriente Objet est dirige par trois fondamentaux qu'il convient de toujours garder l'esprit :encapsulation, hritage et polymorphisme. Houl ! Inutile de fuir en voyant cela, car en fait, ils ne cachent quedes choses relativement simples. Nous allons tenter de les expliquer tout de suite.

1.3.1 - Encapsulation

Derrire ce terme se cache le concept mme de l'objet : runir sous la mme entit les donnes et les moyens deles grer, savoir les champs et les mthodes.L'encapsulation introduit donc une nouvelle manire de grer des donnes. Il ne s'agit plus de dclarer des donnesgnrales puis un ensemble de procdures et fonctions destines les grer de manire spare, mais bien derunir le tout sous le couvert d'une seule et mme entit.Si l'encapsulation est dj une ralit dans les langages procduraux (comme le Pascal non objet par exemple) autravers des units et autres librairies, il prend une toute nouvelle dimension avec l'objet.En effet, sous ce nouveau concept se cache galement un autre lment prendre en compte : pouvoir masqueraux yeux d'un programmeur extrieur tous les rouages d'un objet et donc l'ensemble des procdures et fonctions

destines la gestion interne de l'objet, auxquelles le programmeur final n'aura pas avoir accs. L'encapsulationpermet donc de masquer un certain nombre de champs et mthodes tout en laissant visibles d'autres champs etmthodes.Nous verrons ceci un peu plus loin.Pour conclure, l'encapsulation permet de garder une cohrence dans la gestion de l'objet, tout en assurant l'intgritdes donnes qui ne pourront tre accdes qu'au travers des mthodes visibles.

1.3.2 - Hritage

Si l'encapsulation pouvait se faire manuellement (grce la dfinition d'une unit par exemple), il en va tout autrementde l'hritage. Cette notion est celle qui s'explique le mieux au travers d'un exemple. Considrons un objet Btiment.Cet objet est pour le moins gnrique, et sa dfinition reste assez vague. On peut toutefois lui associer divers champs,dont par exemple :

les murs ; le toit ; une porte ; l'adresse ; la superficie.

On peut supposer que cet objet Btimentdispose d'un ensemble de mthodes destines sa gestion. On pourrait

ainsi dfinir entre autres des mthodes pour :

ouvrir le Btiment ;

8/3/2019 artpoo

8/33




fermer le Btiment ; agrandir le Btiment.

Grce au concept d'hritage, cet objet Btiment va pouvoir donner naissance un ou des descendants. Cesdescendants vont tous bnficier des caractristiques propres de leuranctre, savoir ses champs et mthodes.Cependant, les descendants conservent la possibilit de possder leurs propres champs et mthodes. Tout comme un

enfant hrite des caractristiques de ses parents et dveloppe les siennes, un objet peut hriter des caractristiquesde son anctre, mais aussi en dvelopper de nouvelles, ou bien encore se spcialiser.Ainsi, si l'on poursuit notre exemple, nous allons pouvoir crer un objet Maison. Ce nouvel objet est toujours considrcomme un Btiment, il possde donc toujours des murs, un toit, une porte, les champsAdresse ou Superficie et lesmthodes destines par exemple Ouvrir le Btiment.Toutefois, si notre nouvel objet est toujours un Btiment, il n'en reste pas moins qu'il s'agit d'une Maison. On peutdonc lui adjoindre d'autres champs et mthodes, et par exemple :

nombre de fentres ; nombre d'tages ; nombre de pices ; possde ou non un jardin ;

possde une cave.

Notre Btimenta ici bien volu. Il s'est spcialis. Avec notre Maison, nous sommes alls plus avant dans lesdtails, et elle est mme de nous offrir des services plus volus. Nous avons complt ce qui n'tait qu'un squelette.Ce processus d'hritage peut bien sr tre rpt. Autrement dit, il est tout fait possible de dclarer prsent undescendant de Maison, dveloppant sa spcialisation : un Chaletou encore une Villa. Mais de la mme manire,il n'y a pas de restrictions thoriques concernant le nombre de descendants pour un objet. Ainsi, pourquoi ne pasdclarer des objets Immeuble ou encore Usine dont l'anctre commun serait toujours Btiment.Ce concept d'hritage ouvre donc la porte un nouveau genre de programmation.On notera qu'une fois qu'un champ ou une mthode sont dfinis, il ou elle le reste pour tous les descendants, quelque soit leur degr d'loignement.

8/3/2019 artpoo

9/33




1.3.3 - Polymorphisme

Le terme polymorphisme est certainement celui que l'on apprhende le plus. Mais il ne faut pas s'arrter cela.Afin de mieux le cerner, il suffit d'analyser la structure du mot :polycomme plusieurs et morphisme comme forme.Le polymorphisme traite de la capacit de l'objet possderplusieurs formes.Cette capacit drive directement du principe d'hritage vu prcdemment. En effet, comme on le sait dj, un objetva hriter des champs et mthodes de ses anctres. Mais un objet garde toujours la capacit de pouvoir redfinirune mthode afin de la rcrire, ou de la complter.

On voit donc apparatre ici ce concept de polymorphisme : choisir en fonction des besoins quelle mthode anctreappeler, et ce au cours mme de l'excution. Le comportement de l'objet devient donc modifiable volont.Le polymorphisme, en d'autres termes, est donc la capacit du systme choisir dynamiquement la mthode quicorrespond au type rel de l'objet en cours. Ainsi, si l'on considre un objet Vhicule et ses descendants Bateau,Avion, Voiture possdant tous une mthodeAvancer, le systme appellera la fonction Avancerspcifique suivantque le vhicule est un Bateau, unAvion ou bien une Voiture.

Attention !

Le concept depolymorphisme ne doit pas tre confondu avec celui d'hritage multiple.

En effet, l'hritage multiple - non support par le Pascal standard - permet un objet

d'hriter des membres (champs et mthodes) de plusieurs objets la fois, alors que le

polymorphisme rside dans la capacit d'un objet modifier son comportement propre

et celui de ses descendants au cours de l'excution.

8/3/2019 artpoo

10/33




8/3/2019 artpoo

11/33




2 - Diffrents types de mthodes

Parmi les diffrentes mthodes d'un objet se distinguent deux types de mthodes bien particulires et remplissantun rle prcis dans sa gestion : les constructeurs et les destructeurs.

2.1 - Constructeurs et destructeurs

2.1.1 - Constructeurs

Comme leur nom l'indique, les constructeurs servent construire l'objet en mmoire. Un constructeurva doncse charger de mettre en place les donnes, d'associer les mthodes avec les champs et de crer le diagrammed'hritage de l'objet, autrement dit de mettre en place toutes les liaisons entre les anctres et les descendants.Il faut savoir que s'il peut exister en mmoire plusieurs instances d'un mme type objet, autrement dit plusieursvariables du mme type, seule une copie des mthodes est conserve en mmoire, de sorte que chaque instancese rfre la mme zone mmoire en ce qui concerne les mthodes. Bien entendu, les champs sont distincts d'unobjet un autre. De fait, seules les donnes diffrent d'une instance une autre, la "machinerie" reste la mme, ce

qui permet de ne pas occuper inutilement la mmoire.Certaines remarques sont prendre en considration concernant les constructeurs.

Un objet peut ne pas avoir de constructeur explicite. Dans ce cas, c'est le compilateur qui se charge decrer de manire statique les liens entre champs et mthodes.

Un objet peut avoir plusieurs constructeurs : c'est l'utilisateur qui dcidera du constructeur appeler.La prsence de constructeurs multiples peut sembler saugrenue de prime abord, leur rle tant identique.Cependant, comme pour toute mthode, un constructeur peut tre surcharg, et donc effectuer diversesactions en plus de la construction mme de l'objet. On utilise ainsi gnralement les constructeurspourinitialiser les champs de l'objet. diffrentes initialisations peuvent donc correspondre diffrentsconstructeurs.

S'il n'est pas ncessaire de fournir un constructeur pour un objet statique, il devient obligatoire en cas de

gestion dynamique, car le diagramme d'hritage ne peut tre construit de manire correcte que lors del'excution, et non lors de la compilation.

2.1.2 - Destructeurs

Le destructeurest le pendant du constructeur : il se charge de dtruire l'instance de l'objet. La mmoire allouepour le diagramme d'hritage est libre. Certains compilateurs peuvent galement se servir des destructeurs pourliminer de la mmoire le code correspondant aux mthodes d'un type d'objet si plus aucune instance de cet objetne rside en mmoire.L encore, diffrentes remarques doivent tre gardes l'esprit.

Tout comme pour les constructeurs, un objet peut ne pas avoir de destructeur. Une fois encore, c'est lecompilateur qui se chargera de la destruction statique de l'objet.

Un objet peut possderplusieurs destructeurs. Leur rle commun reste identique, mais peut s'y ajouter ladestruction de certaines variables internes pouvant diffrer d'un destructeur l'autre. La plupart du temps, un constructeur distinct est associ un destructeur distinct.

En cas d'utilisation dynamique, un destructeur s'impose pour dtruire le diagramme cr par leconstructeur.

2.2 - Pointeur interne

Trs souvent, les objets sont utiliss de manire dynamique, et ne sont donc crs que lors de l'excution. Si lesmthodes sont toujours communes aux instances d'un mme type objet, il n'en est pas de mme pour les donnes.

Il peut donc se rvler indispensable pour un objet de pouvoir se rfrencer lui-mme. Pour cela, toute instancedispose d'un pointeur interne vers elle-mme.

8/3/2019 artpoo

12/33




Ce pointeur peut prendre diffrentes appellations. En Pascal, il s'agira du pointeurSelf.D'autres langages pourront le nommerthis, comme le C++...

2.3 - Mthodes virtuelles et mthodes dynamiques

2.3.1 - Mthodes virtuelles

2.3.1.1 - Principe

Une mthode dite virtuelle n'a rien de fictif ! Il s'agit d'une mthode dont la rsolution des liens est effectuedynamiquement. Voyons ce que cela signifie.Comme nous le savons dj, toute mthode est susceptible d'tre surcharge dans un descendant, de manire tre crase ou complte. Par consquent, toute mthode surcharge donne lieu cration d'une nouvelle section

de code, et donc une nouvelle adresse en mmoire.De plus, tout objet possde un lien vers la table des mthodes de ses anctres : le diagramme d'hritage. De fait,tout type objet est directement li ses types anctres. Autrement dit, si nous reprenons l'exemple du dbut, l'objetMaison peut tre assimil un Btiment.Considrons prsent la mthode Ouvrird'un Btiment. Celle-ci consiste ouvrir la porte principale. prsent, surchargeons cette mthode pour l'objet Maison, de sorte que la mthode Ouvrirnon seulement ouvre laporte principale, mais galement les volets de notre Maison.Dclarons maintenant une instance statique de Btiment, et appelons cette mthode Ouvrir. Lors de la crationde l'excutable, le compilateur va vrifier le type d'instance cr. Le compilateur lie alors notre appel celui deBtiment.Ouvrir(la mthode Ouvrirde l'objet Btiment), en toute logique. Il ne se pose aucun problme.Considrons prsent un autre exemple : dclarons une variable dynamique destine, en principe, recevoir unobjet Btiment. Comme nous l'avons vu juste avant, l'objet Maison est compatible avec l'objet Btiment. Commenous travaillons en dynamique, nous nous servons de pointeurs. De fait, je peux trs bien dcider, avec cette variablepointant vers un objet Btiment, de dclarer une instance de type Maison : le compilateur ne montrera aucunerticence.Si nous rsumons, nous avons donc une variable de type officiel pointeurvers Btimentet contenant en ralit uneMaison.Appelons alors notre mthode Ouvrir. Comme nous avons une Maison, il faut que l'on ouvre les volets. Or, si nousexcutons notre programme, les volets resteront clos. Que s'est-il pass ?Lors de la cration du programme, le compilateur s'est arrt sur notre appel Ouvrir. Ayant dclar un objet Btiment,le compilateurignore tout du comportement du programme lors de son excution , et par consquent ignoreque la variable de typepointeurvers Btimentcontiendra l'excution un objet Maison. De fait, il effectue une liaisonvers Btiment.Ouvriralors que nous utilisons une Maison !La solution, vous l'aurez compris, rside dans l'utilisation des mthodes virtuelles. Grce celles-ci, la rsolutiondes liens est effectue dynamiquement, autrement dit lors de l'excution. Ainsi, si nous dclarons notre mthode

Ouvrircomme virtuelle, lors de la cration du programme, le compilateur n'effectuera aucune liaison statique avantnotre appel. Ce n'est que lors de l'excution, au moment de l'appel, que la liaison va s'effectuer. Ainsi, au moment
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

13/33




o l'on dsirera appelerOuvrir, notre programme va interroger son pointeur interne pour dterminer son type. Bienvidemment, cette fois-ci, il va dtecter une instance de Maison, et l'appel se fera donc en direction de Maison.Ouvrir.Les volets s'ouvrent...Vous aurez not toute l'importance des mthodes virtuelles. D'une manire gnrale, sitt qu'une mthode estsusceptible d'tre surcharge, il faut la dclarer comme virtuelle.

Attention !Les constructeurs des objets ne seront jamais dclars comme virtuels, car c'est

toujours le bon constructeur qui est appel. Le caractre virtuel est donc inutile et sera

mme signal comme une erreur par le compilateur.

Par contre, les destructeurs seront toujours dclars comme virtuels car souvent

surchargs.

Il n'en est pas de mme pour les classes qui elles peuvent s'appuyer sur le principe de

constructeur virtuel. C'est notamment le cas de Delphiavec les rfrences de classes

propos desquelles la documentation donne plus de prcisions.

Vous pouvez aussi consulter les tutoriels suivants :

* Cours sur la POO de Frdric Beaulieu ;

* Cours sur les mtaclasses de Laurent Dardenne.

2.3.1.2 - Constructeurs et Table des Mthodes Virtuelles

Afin de pouvoir appeler la mthode approprie au moment souhait, un objet doit s'appuyer sur une liste de sesmthodes virtuelles : la VMT ou Virtual Methods Table, la Table des Mthodes Virtuelles. Cette table est mise enplace par les constructeurs d'un objet.Tout objet possde sa propre VMT, conservant toujours un lien avec la VMT de son anctre.Lorsqu'un appel une mthode virtuelle est effectu, l'objet recherche dans sa VMT s'il trouve la mthode recherche.Si c'est le cas, alors il utilise l'adresse enregistre et excute la mthode. Sinon, il parcourt la VMT de son anctredirect et ainsi de suite jusqu' l'anctre le plus loign dans la hirarchie.De mme, lorsque qu'une mthode surcharge fait appel la mthode anctre, alors une recherche est effectueen partant cette fois-ci de la VMT du premier anctre.La VMT est dtruite par un destructeurlorsque celle-ci n'a plus lieu d'exister.

Si jamais on utilise une mthode virtuelle sans avoir appel au pralable un

constructeur, le caractre virtuel ne sera pas pris en compte et les rsultats seront

imprvisibles.

2.3.2 - Mthodes dynamiques

Aprs les mthodes virtuelles, on se demande ce que l'on a pu inventer de pire ! Rassurez-vous, rien du tout. Lesmthodes dynamiques ne sont en fait que des mthodes virtuelles.Leur particularit rside dans le fait qu'elles sont indexes. Autrement dit, chaque mthode dynamique possde

un numro unique pour l'identifier.Il convient de les comparer aux mthodes virtuelles :

Avantage : les mthodes dynamiques consomment moins de mmoire ; Inconvnient : la gestion interne des mthodes dynamiques est plus complexe, et donc plus lente.

Par consquent, on prfrera toujours les mthodes virtuelles, sauf si de nombreuses mthodes virtuellesdoivent tre dclares, auquel cas on se reportera aux mthodes dynamiques.

2.4 - Mthodes abstraites

Une mthode abstraite est une mthode qu'il est ncessaire de surcharger. Elle ne possde donc pasd'implmentation. Ainsi, si on tente d'appeler une mthode abstraite, alors une erreur est dclenche.
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://laurent-dardenne.developpez.com/articles/metaclasse/http://fbeaulieu.developpez.com/guide/14-objets-2.htmlhttp://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

14/33




Bien entendu, il convient lors de la surcharge d'une telle mthode de ne pas faire appel la mthode de l'anctre...Les mthodes abstraites sont gnralement utilises lorsque l'on btit un squelette d'objet devant donner lieu demultiples descendants devant tous possder un comportement analogue. On pourra prendre notamment l'exemplede l'objet TStream et de tous ses descendants.

8/3/2019 artpoo

15/33




3 - Visibilit

De par le principe de l'encapsulation, afin de pouvoir garantir la protection des donnes, il convient de pouvoirmasquer certaines donnes et mthodes internes les grant, et de pouvoir laisser visibles certaines autres devantservir la gestion publique de l'objet. C'est le principe de la visibilit.

3.1 - Champs et mthodes publics

Comme leur nom l'indique, les champs et mthodes dits publics sont accessibles depuis tous les descendants etdans tous les modules : programme, unit...On peut considrer que les lments publics n'ont pas de restriction particulire.Les mthodes publiques sont communment appeles accesseurs : elles permettent d'accder aux champs d'ordrepriv.Il existe des accesseurs en lecture, destins rcuprer la valeur d'un champ, et des accesseurs en criture destinspour leur part la modification d'un champ.Il n'est pas ncessaire d'avoir un accesseur par champ priv, car ceux-ci peuvent n'tre utiliss qu' des fins internes.Trs souvent, les accesseurs en lecture verront leur nom commencer parGetquand leurs homologues en criture

verront le leur commencer parSetou Put.

Les constructeurs et les destructeurs ventuels d'un objet devront bnficier de la

visibilitpublique, sans quoi un programme externe ne pourrait pas les appeler !

Attention !

Un champ ne devra tre publicque si sa modification n'entrane pas de changement

dans le comportement de l'objet. Dans le cas contraire, il faut passer par une mthode.

Modifier un champ "manuellement" et ensuite appeler une mthode pour informer de cette

modification est une violation du principe d'encapsulation.

3.2 - Champs et mthodes privs

La visibilit prive restreint la porte d'un champ ou d'une mthode au module o il ou elle est dclar(e). Ainsi,si un objet est dclar dans une unit avec un champ priv, alors ce champ ne pourra tre accd qu' l'intrieurmme de l'unit.

Cette visibilit est bien considrer. En effet, si un descendant doit pouvoir accder un

champ ou une mthode priv(e), alors ce descendant doit ncessairement tre dclar

dans le mme module que son anctre.

Gnralement, les accesseurs, autrement dit les mthodes destines modifier les champs, sont dclars commeprivs.

3.3 - Champs et mthodes protgs

La visibilit protg correspond la visibilit priv except que tout champ ou mthode protg(e) est accessibledans tous les descendants, quel que soit le module o ils se situent.

Cette visibilit est souvent prfrer la visibilit prive, cependant elle n'est pas

supporte par tous les compilateurs. Par exemple, Turbo Pascal ne la reconnat pas.

8/3/2019 artpoo

16/33




4 - Le Pascal Objet

Tous les lments de la Programmation Oriente Objet noncs jusqu'ici sont bien entendu supports par le PascalObjet. Nous allons voir prsent comment les implmenter.

4.1 - Dclaration d'un objet

4.1.1 - Dclaration simple

Avant de pouvoir utiliser la POO, il convient de savoir dclarer un objet. Pour ce faire, on a recours au mot rservobject. Un objet tant une structure de donnes, il sera donc toujours dclar l'intrieur d'un bloc type.L'objet le plus basique que l'on puisse dclarer est tout simplement l'objet vide, qui n'effectue rien et ne contient rien.On le dclare comme ceci :

type

TObjetVide = object end;

On remarquera que la dclaration d'un objet se terminera toujours par un end;.De plus, on adopte trs souvent en Pascal une convention de notation pour les objets : leur nom commence toujoursparT, comme type. Nous respecterons toujours cette convention dans ce tutoriel, et nous parlerons donc des objetsTMaison ou encore TChose.

Attention !

Sur les compilateurs de nouvelle gnration, le mot rserv objectsera remplac par le

mot rserv class.

type

TObjetVide = class

end;

Dans la suite de ce tutoriel, nous adopterons l'utilisation de mot rserv object. Celui-ci sera remplacer en fonctiondu compilateur utilis (Delphi par exemple).

4.1.2 - Dclarations imbriques

Il est parfois ncessaire de dclarer des objets qui s'utilisent mutuellement. On peut ainsi prendre l'exemple de deuxobjets, TParentet TEnfant, le parent ayant la ncessit de connatre la liste de ses enfants, et l'enfant la ncessit

de connatre son parent.Intervient alors le problme de la dclaration imbrique de deux objets. Si l'on tente de les dclarer comme ceci :

type

TParent = object

Enfant: TEnfant;

end;

TEnfant = object

Parent: TParent;

end;

Le compilateur va dclencher une erreur indiquant qu'il connat pas encore TEnfant lorsqu'il tente d'analyser la

structure de TParent.

8/3/2019 artpoo

17/33




La solution au problme passe ncessairement parl'instanciation dynamique des deux objets (voir le paragrapheconcern). On va donc dclarer deux pointeurs vers les deux types considrs et seulement ensuite, on dclarerales objets eux-mmes, ceci dans le mme bloc type :

type

{ Dclaration des pointeurs }PParent = ^TParent;

PEnfant = ^TEnfant;

{ Dclaration des objets utilisant les pointeurs }

TParent = object

Enfant: PEnfant;

end;

TEnfant = object

Parent: PParent;

end;

Grce cette mthode, plus aucune erreur n'est dclenche, car lorsque le compilateur va analyserTParent, il auradj eu connaissance de l'existanceexistence de PEnfant. Ceci n'est bien videmment possible que parce que lecompilateur accepte la dclaration prmature de pointeurs avant le type vers lequel ils pointent.

Sous Delphi, l'instanciation tant automatiquementdynamique, ce problme ne se pose

pas, et pour rsoudre le problme, on se contente d'annoncer la classe avec une

dclaration partielle :

type

{ Dclarations partielles }

TParent = class;

TEnfant = class;

{ Dclaration des objets utilisant les classes }

TParent = classEnfant: TEnfant;

end;

TEnfant = class

Parent: TParent;

end;

4.2 - Champs et mthodes

Un objet vide ne prsentant pas d'intrt majeur, il pourrait tre intressant de savoir comment lui ajouter des champset des mthodes.

Attention !

Dans un objet, il convient de toujours dclarer les champs AVANT les mthodes.

Si jamais un champ tait dclar aprs une mthode, alors le compilateur gnrerait une

erreur (gnralement, le compilateur indique qu'il attend un endau niveau du champ mal

plac).

Comme l'intrieur d'un enregistrement de type record, les champs se dclarent comme de simples variables, sansrutiliser le mot rserv var l'intrieur de la dclaration de l'objet.Tous les types peuvent tre utiliss pour un champ. Ainsi, les exemples suivants sont tous valides :

type

TChose = objectEntier: Integer;

Chaine: string;
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo//#L4.5.2http://hdd34.developpez.com/cours/artpoo//#L4.5.2http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

18/33




Fichier: file;

end;

type

TBidule = object

Enr: record

A, B: Integer; end;

Entier: Integer;

end;

type

TTruc = object

Obj1: TChose;

Obj2: object

Champ: Char;

end;

end;

On pourra ainsi accder aux champs de la manire suivante :

var

Bidule: TBidule;

Truc: TTruc;

begin

...

Bidule.Enr.A := ...;

...

Truc.Obj1.Entier := 0;

Truc.Obj2.Champ := 'X';

...

end.

Les mthodes se dclarent la suite des champs. Le schma thorique actuel de description d'un objet serait ainsi :

type

TObjet = object

Champ;

...

Champ;

Methode;

...

Methode;

end;

4.2.1 - Procdures et fonctions

Les mthodes - procdures et fonctions - se dclarent l'intrieur de l'objet comme on le ferait dans la partie interfaced'une unit :

type

TObjet = object

Champs;

....

procedure Methode1(Params: ParamType);

function Methode2(Params: ParamType): RetType;

end;

8/3/2019 artpoo

19/33




Une fois ces mthodes dclares, il faut crire le code source associ. On complte leur dclaration en dehors dela dclaration de l'objet. Le nom de la mthode est alors prcd du nom de l'objet suivi d'un point. Un exempleexpliquant aussi bien, voici donc ce que donnerait l'ajout d'une mthode Methode1 :

type

TObjet = object procedure Methode1(Param: ParamType);

end;

procedure TObjet.Methode1(Param: ParamType);

begin

...

end;

Comme il s'agit d'une dclaration de type forward, on peut ventuellement omettre les paramtres lorsque l'oncomplte la dclaration d'une mthode :

typeTObjet = object

procedure Methode1(Param: ParamType);

end;

procedure TObjet.Methode1;

begin

...

end;

Ce code et le code prcdent sont tous deux parfaitement identiques. On choisira donc de privilgier soit la facilitde lecture, soit la simplicit d'criture.

4.2.2 - Constructeurs

Un constructeur se dclare exactement comme une autre mthode. Il n'y a pas d'ordre particulier, et on peut trsbien intercaler des constructeurs au milieu des autres mthodes. Le mot rserv procedure (ou function) sera iciremplac par le mot rserv constructor:

type

TObjet = object

constructor Init(Param: ParamType);

end;

constructor TObjet.Init;

begin

...

end;

L'usage veut que le constructeur principal d'un objet soit appel Initou Create. Il n'y a aucune obligation dans cedomaine, mais on essaie la plupart du temps de suivre cette convention.

Turbo Pascalutilise pour tous les objets standard la "convention Init", etDelphipour sa

part utilise la "convention Create".

Il est possible de faire chouer un constructeur, par exemple si une opration ncessaire l'initialisation de l'objet

s'est mal droule.En fonction du compilateur, soit on dclenchera une exception (Delphi), soit on fera appel la procdure Fail :
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

20/33




type

TObjet = object

constructor Init;

end;


begin...

{ Fait chouer le constructeur }

if ... then Fail;

end;

4.2.3 - Destructeurs

De mme que pour les constructeurs, on se servira ici du mot rserv destructor:

type

TObjet = object

destructor Done; end;

destructor TObjet.Done;

begin

...

end;

Ici encore, l'usage veut que l'on appelle les destructeurs Done ou Destroy. De plus, la plupart du temps, un destructeurn'aura pas de paramtre. Toutefois, le contraire est tout fait autoris par le compilateur.

Turbo Pascalutilise pour tous les objets standard la "convention Done", etDelphipour

sa part utilise la "convention Destroy".

4.2.4 - Mthodes virtuelle et dynamique

Si vous dsirez dclarer une mthode virtuelle, alors vous devez ajouter la dclaration de la mthode (procdure,fonction, constructeur ou destructeur) le mot rserv virtual suivi d'un point-virgule. virtual ne devra pas tre reprislorsque vous complterez le code de la mthode :

type

TObjet = object

procedure Methode(Param: ParamType); virtual;

end;

procedure Methode(Param: ParamType);

begin

...

end;

Les mthodes dynamiques sont galement appeles mthodes virtuelles indexes. En effet, rien ne les distinguedes mthodes virtuelles si ce n'est qu'elles possdent un index, un numro pour les identifier.La dclaration d'une mthode dynamique varie d'un compilateur un autre. Sur les compilateurs plus anciens, ellesseront dclares comme ceci :

type

TObjet = object

procedure Methode(Param: ParamType); virtual IndexUnique;

end;

8/3/2019 artpoo

21/33




procedure Methode(Param: ParamType);

begin

...

end;

O IndexUnique reprsente un entierunique permettant d'identifier la mthode virtuelle.

Sur les compilateurs plus rcents, l'index est gr automatiquement, et il suffit pour

dclarer une mthode dynamique de remplacer le mot rserv virtualpar le mot rserv

dynamic:

type

TObjet = class

procedure Methode(Param: ParamType); dynamic;

end;

procedure TObjet.Methode(Param: ParamType);

begin

...end;

Attention !

Si votre compilateur utilise le mot rserv object (comme Turbo Pascal ), et si

une mthode est dclare avec le mot rserv virtual alors toutes les mthodes

surcharges devront aussi tre dclares avec virtual.

Il en sera de mme avec les mthodes dynamiques.

Si par contre votre compilateur utilise le mot rserv class, les mthodes surcharges

devront tre dclares avec le mot rserv override. Consultez la documentation de votre

compilateur pour plus de dtails.

4.2.5 - Mthodes abstraites

La dclaration d'une mthode abstraite dpend du compilateur utilis. Si vous utilisez un compilateur Pascald'ancienne gnration, alors, bien qu'une mthode abstraite ne doive en thorie pas possder d'implmentation,celle-ci se dclarera comme toute autre mthode, et dans le corps de la mthode, on ajoute un appel la procdureAbstract; :

type

TObjet = object

procedure MethodeAbs;

end;

procedure TObjet.MethodeAbs;begin

{ C'est une mthode abstraite }

Abstract;

end;

Les nouveaux compilateurs utilisent le mot rserv abstract, et suppriment logiquement

le corps de la mthode :

type

TObjet = class

{ C'est une mthode abstraite }

procedure MethodeAbs; abstract;

end;

8/3/2019 artpoo

22/33




4.2.6 - Paramtre implicite Self

Ds lors qu'une mthode est appele, le compilateur lui fournit implicitement, autrement dit de manire non visible,un paramtre supplmentaire, Self, que vous n'avez donc pas grer.Le paramtre Selfreprsente l'instance de l'objet en cours, et possde donc le mme type que l'objet. Ainsi, si un

objet possde un champ nomm Toto, alors les deux codes suivants seront identiques :

procedure TObjet.Methode;

begin

Toto := 1;

end;

procedure TObjet.Methode;

begin

Self.Toto := 1;

end;

Le paramtre Selfsert de manire interne l'objet pour garantir un appel correct des mthodes virtuelles.Pour le programmeur, Selfpeut aussi servir vrifier qu'une instance d'un mme type d'objet est dj en mmoireet, par exemple, interdire la cration d'une nouvelle instance :

type

TObjet = object

constructor Init;

end;

var

Instance: TObjet;


begin if Instance Selfthen Fail;

...

end;

begin

Instance.Init;

...

end.

Le paramtre Selfest toujours transmis en premier la mthode. Ceci peut avoir son

importance lors de l'utilisation de l'assembleur.

4.3 - Visibilit

La visibilit de champs et mthodes s'indique grce divers mots rservs :

visibilit publique : public ; visibilit prive : private ; visibilit protge : protected.

Le spcificateur de visibilit doit tre plac avant l'ensemble des champs et mthodes devant bnficier de cettevisibilit :

type

TObjet = object

private

8/3/2019 artpoo

23/33




ChampPriv;

...

MethodePriv;

...

public

ChampPub;

...

MethodePub;

...

end;

Les spcificateurs peuvent tre placs dans un ordre quelconque, et apparatre plusieurs fois si ncessaire, bien quecette possibilit soit rarement utilise.

Rappel

La visibilitprotge n'est pas disponible sous Turbo Pascal.

4.4 - Hritage

4.4.1 - Dclaration

Un objet en Pascal ne peut hriter que d'un seul anctre. Afin de spcifier celui-ci, on spcifie son nom entreparenthses aprs le mot rserv object :

type

TObjet = object(TAncetre)

...

end;

Sitt qu'un anctre est dclar pour un objet, ce dernier peut accder tous les champs et mthodes de son anctre

sans avoir les redclarer(en fonction de la visibilit).

Attention !

Si vous dsirez surcharger une mthode virtuelle, alors vous devez la redclarer

exactement comme elle tait dclare dans l'anctre. Notamment, vous ne pourrez

pas ajouter ou supprimer de paramtres sa dclaration.

Par contre, si vous redfinissez une mthode, alors vous pourrez trs bien modifier ses

paramtres comme vous le dsirez si celle-ci n'estpas virtuelle.

type

TAncetre = object

Champ: Integer;

procedure ModifChamp(Valeur: Integer); virtual; procedure ARedefinir;

end;

procedure TAncetre.ModifChamp(Valeur: Integer);

begin

Champ := Valeur;

end;

procedure TAncetre.ARedefinir;

begin

...

end;

typeTDescendant = object(TAncetre)

procedure ModifChamp(Valeur: Integer); virtual;

8/3/2019 artpoo

24/33




procedure ARedefinir(ParamSup: Integer);

end;

{ On surcharge la mthode virtuelle ModifChamp en la remplaant par une autre }

procedure TDescendant.ModifChamp(Valeur: Integer);

begin

{ On accde au champ sans le redclarer dans TDescendant }

Champ := Valeur + 1;

end;

{ La mthode a t redfinie avec de nouveaux paramtres }

procedure TDescendant.ARedefinir(ParamSup: Integer);

begin

...

end;

4.4.2 - Surcharge et appel de l'anctre

La plupart du temps, lorsque l'on surcharge une mthode, le but n'est pas d'craser l'ancienne, mais de la complterde faon apporter de nouvelles fonctionnalits. Il est donc ncessaire de pouvoir appeler la mthode anctre.

Deux cas de figure sont alors envisager.

Il n'est pas ncessaire de surcharger ou de redfinir une mthode ! Ainsi, si un objet

ne surcharge pas une mthode, c'est celle du premier anctre la dfinissant ou la

surchargeant qui sera appele.

De fait, il n'est pas ncessaire pour un objet de rcrire un constructeur (ou un destructeur)

si celui de son anctre suffit son initialisation.

4.4.2.1 - Anctre direct

Gnralement, on appelle l'anctre direct, celui dont on hrite en premire main. Pour appeler la mthode anctre,on utilise alors le mot rserv inherited devant le nom de la mthode, l'endroit on l'on dsire effectuer l'appel :

type

TAncetre = object

Champ: Integer;


end;

procedure TAncetre.ModifChamp(Valeur: Integer);

begin

Champ := Valeur;

end;

typeTDescendant = object(TAncetre)

Temp: Integer;


end;

procedure TDescendant.ModifChamp(Valeur: Integer);

begin

{ On effectue diverses actions }

Inc(Valeur);

{ On appelle l'anctre }

inherited ModifChamp(Valeur);

{ On peut effectuer d'autres actions }

Temp := Champ;

end;

8/3/2019 artpoo

25/33




La mthode anctre peut tre appele autant de fois que dsir, et on peut effectuer un nombre quelconqued'oprations avant et/ou aprs ce ou ces appel(s).

4.4.2.2 - Anctre indirect

Dans certains cas particuliers, il peut tre ncessaire d'appeler un anctre plus loign dans la hirarchie : parexemple l'anctre de l'anctre direct. Dans ce cas, il faut faire explicitement appel la mthode en faisant prcderson nom par le nom de l'anctre suivi d'un point. Dans ce cas, les mthodes surcharges apparaissant entre l'objetet l'anctre appel seront ignores.

type

TPremier = object

...

procedure Methode; virtual;

end;

procedure TPremier.Methode;

begin

...end;

type

TSecond = object(TPremier)

...


end;

procedure TSecond.Methode;

begin

...

end;

type

TDernier = object(TSecond)

...


end;

procedure TDernier.Methode;

begin

...

{ On appelle TPremier.Methode : TSecond.Methode est ignore }

TPremier.Methode;

end;

4.4.3 - Valeur de retour d'un constructeur

Lorsque que le constructeur d'un anctre est appel avec inherited, celui-ci renvoie une valeur boolenne indiquantsi la construction de l'objet s'est effectue sans erreur.Ainsi, si la construction a chou dans l'anctre (par un appel Failnotamment), alors il convient de faire chouergalement la construction du descendant, celui-ci ne pouvant fonctionner sans le support de son anctre. Ds lors,il faudra aussi faire un appel Fail.Gnralement, on adopte la syntaxe suivante :

constructor TDescendant.Init(...);

begin

ifnotinherited Init(...) then Fail;

...end;

8/3/2019 artpoo

26/33




4.4.4 - Ordre d'appel de l'anctre dans les constructeurs et destructeurs

S'il est possible de faire appel inherited o on le souhaite et le nombre de fois dsir dans une mthode,les constructeurs et les destructeurs sont rgis par des rgles plus strictes qui ne seront pas vrifies par lecompilateur. Elles sont donc d'autant plus importantes.

Constructeurs :D'une manire gnrale, le constructeur anctre devra tre appel en premier lieu, aucune autre instructionne devant prcder cet appel.Cependant, il est possible d'effectuer diverses oprations en vue, par exemple, de transmettre une valeur enparamtre au constructeur anctre. Nanmoins, on s'abstiendra de toute modification de la valeur d'unchamp avant l'appel l'anctre, car cette valeur serait sujette modification.

constructor TDescendant.Init(...);

begin

{ Premire opration du constructeur : l'appel de l'anctre }

ifnotinherited Init(...) then Fail;

...end;

Destructeur:De faon logique, l'appel au destructeur anctre devra se faire en dernier, une fois tous les champs dudescendant ncessitant un traitement particulier dsallous proprement. En effet, une fois un destructeurappel, il est impossible de prvoir la valeur d'un champ.

destructor TDescendant.Done;

begin

...

{ Dernire opration du destructeur : l'appel de l'anctre }

inherited Done;

end;

4.5 - Instanciation d'un objet

Une fois l'objet dclar - autrement dit le type dfini - il reste crer une ou plusieurs instances de celui-ci, avec desvariables : c'est l'instanciation, ou plus simplement la cration. Il en existe de deux sortes : l'instanciation statiqueet l'instanciation dynamique.

4.5.1 - Instanciation statique

L'instanciation statique est certainement la plus simple mettre en oeuvre, mais aussi celle viter le plus possible.Elle consiste simplement dclarer une variable du type objet comme on dclarerait n'importe quelle variable :

type

TObjet = object

...

end;

var

MonObjet: TObjet;

Si l'objet possde un constructeur, celui-ci devra tre appel avant toute autre mthode, et de mme, si l'objetpossde un destructeur, il devra tre appel en dernier.

8/3/2019 artpoo

27/33




type

TObjet = object

...

constructor Init(...);

destructor Done;

end;

constructor TObjet.Init(...);

begin

...

end;

destructor TObjet.Done;

begin

...

end;

var

MonObjet: TObjet;

begin

...

MonObjet.Init(...);

...

MonObjet.Methode;

...

MonObjet.Done;

...

end.

L'instanciation statique prsente plusieurs inconvnients, le principal concernant la

mmoire. En effet, en mode rel sous DOS, seuls 64 Ko de mmoire sont disponibles pour

les variables statiques. Il en rsulte donc une limitation drastique concernant le nombre

d'objets en mmoire et leur taille.

L'instanciation statique a t supprime sur les compilateurs rcents comme Delphi,o la gestion est obligatoirement dynamique, mais en gardant une syntaxe quivalente

la syntaxe statique (suppression notamment de l'utilisation explicite des pointeurs).

4.5.2 - Instanciation dynamique

L'instanciation dynamique est certainement la plus utilise et celle permettant de stocker en mmoire le plus d'objetset d'informations. Elle suppose bien entendu une connaissance des pointeurs.Afin de pouvoir utiliser le dynamique, il faut commencer par dclarer un pointeur vers le type objet que l'on projetted'utiliser. L'usage veut que cette dclaration se fasse conjointement avec celle de l'objet en lui-mme. De mme, onchoisit gnralement de faire figurer la dclaration du pointeur juste avant celle de l'objet.Le nom du pointeur pourra reprendre celui de l'objet, en remplaant le T initial par un P. Par exemple, si l'on considrel'objet TObjet, alors le pointeur vers l'objet sera nomm communment PObjet.

type

PObjet = ^TObjet;

TObjet = object

...

end;

4.5.2.1 - Allocation

L'allocation mmoire de l'objet et son initialisation se font gnralement en mme temps l'aide de la fonction

standard New. Deux formes peuvent tre utilises :
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

28/33




New(VarObjet, Constructeur);Avec cette syntaxe, on utilise New en tant que procdure en faisant apparatre en tant que deuximeparamtre le constructeur avec ses ventuels paramtres.

var

Objet: PObjet;

begin

New(Objet, Init(...));

...

end.

VarObjet := New(PointeurTypeObjet, Constructeur);Cette syntaxe utilise la syntaxe tendue de New en l'utilisant en tant que fonction. On fait toujours apparatreen deuxime le constructeur affect de ses divers paramtres.La diffrence vient du fait que l'on spcifie clairement de quel type l'objet doit tre.Cette syntaxe permet plus de libert en ce que l'on peut trs bien affecter un pointeur quelconque (un typedescendant par exemple) un autre type objet.De plus, cette syntaxe se rapproche beaucoup de celle adopte par les compilateurs plus rcents commeDelphi. On pourra donc lgitimement la prfrer.

var

Objet: PObjet;

begin

Objet := New(PObjet, Init(...));

...

end.

Il est tout fait possible d'allouer dans un premier temps l'objet comme n'importe quel

pointeur avec New(Objet); et ensuite d'appeler le constructeur.

Nanmoins, cette pratique est obsolte et on l'vitera autant que possible.

On n'oubliera pas lors de l'appel aux mthodes que l'on utilise dornavant un pointeur. Le

symbole ^ est donc de mise :

var

Objet: PObjet;

begin

...

Objet^.Methode(...);

...

end.

Attention !

Comme on travaille prsent avec des pointeurs, il faut vrifier que l'objet est bien

allou. On peut ainsi tester l'galit avecnilou bien utiliser la fonction interneAssigned:

var

Objet: PObjet;

begin


if Objet nilthen

begin

...Dispose(Objet, Done);

end;

8/3/2019 artpoo

29/33




end.

Ou :

var

Objet: PObjet;

begin


if Assigned(Objet) then

begin

...

Dispose(Objet, Done);

end;

end.

Les compilateurs rcents comme Delphi utilisent la syntaxe VarObjet :=

TypeObjet.Constructeur;, les pointeurs tant intgrs directement la dclaration de la

classe. Ils sont donc implicites. De plus, on se servira de blocs try...finallypour protger

son code :

type

TObjet = class

constructor Create(...);

end;

var

Objet: TObjet;

begin

Objet := TObjet.Create(...);

try

...

finally

...

end;

end;

4.5.2.2 - Dsallocation

Tout comme pour l'allocation, la dsallocation d'effectue s'effectue gnralement en mme temps que l'appel dudestructeur de l'objet l'aide de la procdure Dispose. Le destructeur est alors pass avec ses ventuels paramtrescomme deuxime paramtre de la procdure.

var

Objet: PObjet;

begin

...

Dispose(Objet, Done(...));

end.

Tout comme pour les constructeurs, il est possible d'appeler le destructeur pour n'appeler

que par la suite Dispose sparment. Cette pratique devra toutefois tre vite car

obsolte et parfois source d'erreurs.

Delphin'appelle pas directement le destructeur mais fait appel la procdure Free :
http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

30/33




var

Objet: TObjet;

begin

Objet := TObjet.Create(...);

try

...

finally

TObjet.Free;

end;

end.

4.6 - L'objet gnrique TObject

Turbo Pascal et la plupart des autres compilateurs dfinissent un objet gnrique servant de base tous les objetsde la bibliothque standard : c'est TObject. Cet objet, plac dans l'unit Objects, est dclar comme ceci :

type

PObject = ^TObject;TObject = object

constructor Init;

destructor Done; virtual;

procedure Free;

end;

Init :Le constructeur de TObject, en plus d'effectuer son rle habituel (mise en place du diagramme d'hritage,VMT...), met zro tous les champs. Cette opration n'est en effet pas automatique pour un objetquelconque, et, par consquent, tous les objets ne drivant pas de TObject voient le contenu de leurschamps indfini au moment de l'initialisation.

Done :

Le destructeurDone n'effectue rien ! Son seul intrt rside dans le fait qu'il est dclar comme virtuel. Parconsquent, tous les descendants devront implmenter un destructeur virtuel, ce qui permet d'viter touteerreur due l'oubli de la sorte.

Free :La mthode Free permet de se dispenser de l'appel Dispose. En effet, en appelant Free, l'objet se libretout seul.

On pourra donc prendre pour habitude de driver tous ses objets de base de TObject, car il fournit une architecturede base pratique et importante pour la compatibilit avec les objets de la bibliothque standard. L'allocation et ladsallocation d'un tel objet deviendront alors :

usesObjects;

type

PChose = ^TChose;

TChose = object(TObject)

private

...

public

...

constructor Init(...);

destructor Done; virtual;

end;

constructor TChose.Init(...);

begin

ifnotinherited Init then Fail;

...

8/3/2019 artpoo

31/33




end;

destructor TChose.Done;

begin

...

inherited Done;

end;

...

var

Chose: PChose;

begin

Chose := New(PChose, Init(...));

if Assigned(Chose) then

begin

...

Chose^.Free;

end;

end.

Delphiimpose par dfautTObjectcomme anctre si aucun anctre n'est spcifi lors de

la dclaration d'une classe. Ainsi, les deux exemples suivants sont quivalents :

type

TObjet = class

...

end;

type

TObjet = class(TObject)

...

end;

8/3/2019 artpoo

32/33




Conclusion

Vous avez appris ici les bases de la Programmation Oriente Objet et vous tes prsent mme de construirevous-mme vos propres programmes objets.Seule la pratique permettant de faire des progrs, vos claviers !

Liens consulter en complment :

* Cours sur la POO de Frdric Beaulieu ;

* Cours sur les mtaclasses de Laurent Dardenne ;

* Les exemples de code illustrant le livre de John Colibri.
http://hdd34.developpez.com/cours/artpoo/http://www.jcolibri.com/scripts/jcolibri.exe?a=1?filename=livre_programmation_objet.ziphttp://laurent-dardenne.developpez.com/articles/metaclasse/http://fbeaulieu.developpez.com/guide/14-objets-2.htmlhttp://hdd34.developpez.com/cours/artpoo/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot/http://www.developpez.com/

8/3/2019 artpoo

33/33


Remerciements

Remerciements particuliers Laurent Dardenne et Richard Gaillard, ainsi qu' Claude Leloup pour sa relecture.
http://www.developpez.net/forums/u124512/claudeleloup/http://hdd34.developpez.com/http://www.developpez.net/forums/u115/eric-sigoillot

Documents

artpoo