Upload
anonymous-wpl47bwu4
View
229
Download
0
Embed Size (px)
Citation preview
8/18/2019 Cours Delphi ASD2
1/45
Licence SHS
Université Bordeaux 2
Support du cours ASD
Algorithmique et Structuresde Données avec Delphi
Jean Marc Salotti
8/18/2019 Cours Delphi ASD2
2/45
Résumé
Intitulé ASD : Algorithmes et structures de données,plateorme Delphi
Langue : Français
Crédits : 3 Code : Responsable : Jean Marc Salotti
Cours : 12 h Heures/semaine : 1 Total semaines : 12 Semestre :
T ! : 1" h Heures/semaine : 1# Total semaines : 12 Semestre :
$ré re%uis Introduction & la pro'rammation# al'orithmi%ue de base
Contenu Ré(isions sur $ascal et !elphi) Introduction au lan'a'e ob*et !elphi# & lapro'rammation é(énementielle# au+ composants 'raphi%ues de !elphi#utilisation des structures de données listes# piles# manipulation de ,ichierste+tes )ini
-b*ecti,s Conception structurée de pro'rammes a(ec !elphiMéthode Cours . e+ercices sur machine en T!
(aluation e+amen écrit
8/18/2019 Cours Delphi ASD2
3/45
Sommaire
1. Rappels sur le langage Pascal.............................................................................................61.1 Syntaxe générale.........................................................................................................61.2 Types prédéfinis..........................................................................................................61.3 Création de type..........................................................................................................61.4 Instructions de ase.....................................................................................................61.! "xercices de ré#ision sur les oucles..........................................................................$
2. Ré#ision sur les ooléens et les taleaux............................................................................%2.1 &es ooléens................................................................................................................%2.2 "xercices sur les ooléens........................................................................................1'2.3 "xercices sur les taleaux.........................................................................................1'
3. (ic)iers textes généri*ues TInifile....................................................................................12
3.1 Introduction...............................................................................................................123.2 +rganisation d,un fic)ier .ini.....................................................................................123.3 -tilisation d,un oet TInifile....................................................................................123.4 Propriétés et /ét)odes des oets TInifile................................................................12
3.4.1 &ecture dans un fic)ier .ini...............................................................................133.4.2 "criture dans un fic)ier .ini...............................................................................13
3.! "xe/ple....................................................................................................................134. Introduction au langage oet............................................................................................1!
4.1 -tilité des oets.......................................................................................................1!4.2 "xe/ple....................................................................................................................1!4.3 Classe T(or/............................................................................................................164.4 Pulic 0 Pri#ate..........................................................................................................164.! Constructeur..............................................................................................................1$4.6 estructeur................................................................................................................1$4.$ ffectation................................................................................................................1$4. éritage si/ple.........................................................................................................1$4.% "xercice.....................................................................................................................1
!. éritage et poly/orp)is/e...............................................................................................2'!.1 Surc)arge..................................................................................................................2'!.2 5ét)ode stati*ue.......................................................................................................2'!.3 5ét)odes #irtuelles...................................................................................................21
!.4 5ét)ode astraite......................................................................................................21!.! Self............................................................................................................................22!.6 +pérateurs de classe..................................................................................................22
6. Poly/orp)is/e étude d,un exe/ple................................................................................236.1 Prol7/e...................................................................................................................236.2 Solution.....................................................................................................................236.3 "xtension...................................................................................................................2!
$. &istes c)a8nées..................................................................................................................26$.1 Représentation...........................................................................................................26$.2 9estion d:une liste c)a8née.......................................................................................26$.3 &iste c)a8née dans un taleau...................................................................................26
$.4 Taleaux dyna/i*ues................................................................................................2$$.! T&ist..........................................................................................................................2$
8/18/2019 Cours Delphi ASD2
4/45
$.6 "xe/ple....................................................................................................................2$.$ "xercices...................................................................................................................2%
. Piles...................................................................................................................................3'.1 Représentation...........................................................................................................3'.2 9estion d:une pile.....................................................................................................3'
.3 "xe/ples de piles.....................................................................................................3'.4 +ets TStac;............................................................................................................3'.! 5ét)odes de TStac;..................................................................................................31.6 "xercice.....................................................................................................................31
%. (iles...................................................................................................................................33%.1 Représentation...........................................................................................................33%.2 9estion d:une file......................................................................................................33%.3 "xe/ple de file.........................................................................................................33%.4 +ets T
8/18/2019 Cours Delphi ASD2
5/45
I>TR+-CTI+>
!our"uoi Delphi :
A parce *ue le te/ps est ré#olu de Bprogra//er dans un langageB on dé#eloppe desapplications infor/ati*ues a#ec une Bplatefor/e de dé#eloppe/entB.A parce *ue elp)i per/et la progra//ation é#éne/entielleA parce *ue le langage Pascal +et est si/ple et pédagogi*ue/ent acceptaleA parce *ue la progra//ation sous elp)i est tr7s rapideA parce *ue elp)i per/et la conception d,interfaces professionnellesA parce *ue elp)i est gratuitA parce *u,il existe un grand no/re de progra//eurs elp)i dans le /onde et *ue deno/reux co/posants sont proposés sur le e pour faire par exe/ple de la reconnaissance#ocale pour récupérer l,i/age d,un scanner ou d,une ca/éra etc.
"xe/ples d,applications présentées en cours et nécessitant tr7s peu de code @A reconnaissance #ocaleA synt)7se #ocale agents ani/és D5icrosoft gentEA li#e #idéo et capture d,i/age en utilisant une eca/
utres applications présentées en cours @A traite/ent d,i/agesA synt)7se d,i/agesA /ou#e/ents ellipti*ues de plan7tes et astéroFdes autour du soleil
A gestion d,arre généalogi*ueA eu de si/ulation de type ge of "/pires @ 5arsase
#onnaissances re"uises pour suivre le cours ASD :=ases du langage Pascal Dun polycopié en ligne est disponile pour ceux *ui ont esoin d,une/ise G ni#eau a#ec cours et exercices corrigésE.
$ustiication de la ma%trise d&une plateorme de développement :&es logiciels du co//erce ne font pas tout ce *u,on #oudrait faire. Il est donc nécessaired,apprendre G créer soiA/H/e les applications infor/ati*ues *ui rel7#ent du do/aine des/at)é/ati*ues appli*uées aux sciences )u/aines et sociales DSSE.
ans le do/aine de la rec)erc)e on peut égale/ent noter l,application des principauxconcepts et /ét)odes utilisés dans les /od7les de systèmes complexes adaptatifs proposés ensciences )u/aines et sociales Dtra#aux des sociologues politologues )istoriens ou desécono/istes xelrod =oles et 9intis "pstein et xtell Sc)ellingE. Ils portent sur l,é/ergence de la co//unication et du langage de la coopération la sélection des nor/es etl,é/ergence des institutions l,étude de syst7/es écono/i*ues en particulier des /arc)éset réseaux de production et d,éc)ange ou encore sur l,organisation sociale de l,espace.Par/i les concepts et /ét)odes dé#eloppés dans ce do/aine de rec)erc)e figurent les notionsd,é/ergence d,attracteurs de lois d,éc)elle de régi/e dyna/i*ue et de transition de
percolation d,apprentissage de eux é#olutionnaires etc. dont la /odélisation nécessitesou#ent le dé#eloppe/ent d,applications infor/ati*ues dédiées.
8/18/2019 Cours Delphi ASD2
6/45
1. Rappels sur le langage Pascal
1.1 Syntaxe générale
Pas de différenciation /inuscule 0 /auscule&es co//entaires co//encent par 0 et finissent par 0 ou co//encent par D et par ESur une ligne ce *ui est apr7s 00 est considéré co//e co//entaires.&,espace et le retour G la ligne sont des séparateurs. Il faut au /oins 1 séparateur entre c)a*ue/otAclé ou #ariale.
1.2 Types prédéinis
Il existe ! grands types de ase @integer real oolean J Ktrue falseL c)ar string
"n cas de nécessité les entiers et les réels peu#ent toutefois se décliner en @ yte longint currency et doule
&a déclaration d,un taleau stati*ue se fait de la faMon sui#ante @arrayNindice1..indice2O of no/detype
1.! "réation de type
&a création d,un nou#eau type est précédée du /otAclé BtypeB."xe/ples @type tta J arrayN1..1''O of realQ
entier J integerQ&a déclaration d,une structure co/posée nécessite le /ot clé record et se ter/ine par endQ"xe/ple @ rpoint J record xy @ realQ endQ
1.# $nstructions de %ase
Remar"ues préliminaires :ans les descriptions ciAdessous une expression est une for/ule /at)é/ati*ue *uelcon*ueDpar exe/ple 3x1 ou sinD4EE *ui aura une #aleur G l,exécution du progra//e alors *u,uneinstruction est une opération *ui exploite des expressions et é#entuelle/ent d,autresinstructions /ais *ui n,a aucune #aleur G l,exécution.
• 'nstruction d&aectation :
no/de#ariale @J expression 00 &a #ariale prend la #aleur de l:expression
• 'nstruction conditionnelle :
i expression ooléenne then instruction1 else instruction2 00 a/ais de Q a#ant else&e else est optionnel. Si plusieurs i then else sont i/ri*ués et *u,il y a a/iguFté le else serapporte touours au then le plus proc)e *ui le préc7de.
• 'nstruction (tant "ue( :
)hile expression ooléenne do instructionTant *ue l,expression ooléenne est é#aluée G true l,instruction apr7s do est répétée.
• 'nstruction composée :
*egin instruction1Q instruction2Q instruction3Q endQ
8/18/2019 Cours Delphi ASD2
7/45
• 'nstruction (répéter +us"u&( :
repeat instruction until expression ooléenne
• 'nstruction d&itération (pour( :
or no/#ariale @J expression1 to expression2 do instruction 00 #ariale non réelle
est é*ui#alent G @no/de#ariale @J expression1Q)hile no/de#ariale UJ expression2 do*egin
instructionQincDno/de#arialeEQ 00 ug/entation de 1 si c,est un entier
endQVariante descendante @ or no/#ariale @J expression1 do)nto expression2 do instruction
• 'nstruction du traitement cas par cas :
case expression
o @
#aleur1 @ instruction1Q#aleur2 @ instruction2Qelse instruction>Q
endQ
>oteW *ue l,affectation l,instruction conditionnelle le )ile et l,instruction co/poséesuffisent G écrire n,i/porte *uel progra//e. ,autres instructions /oins fonda/entalesexistent se rapporter au /anuel utilisateur ou G l,aide en ligne.
1.& 'xercices de révision sur les %ouclesans les exercices sui#ants on utilisera les fonctions StrToInt pour con#ertir une c)aine decaract7res en entier IntToStr pour la con#ersion in#erse (loatToStr pour con#ertir un réel enstring et StrTo(loat pour la con#ersion in#erse. +n utilisera égale/ent la /ét)odeT5e/o.lines.addD texte E pour affic)er une c)a8ne de caract7res dans un T5e/o.
1. éfinir les #ariales et écrire la suite d,instructions per/ettant de calculer la so//e de 1'no/res pairs consécutifs en co//enMant G partir de 4. &e résultat est placé dans une#ariale appelée BresB.Solution 1 @var i, pair, res : integer;
beginres := 0;
pair := 4; for i:=1 to 10 do // 10 passages dans la boucle, car il y a 10 calculs à faire
begin
res := res + pair; pair := pair + 2;
end;end;Solution 2 @var i, res : integer;begin
res := 0;
8/18/2019 Cours Delphi ASD2
8/45
for i:=1 to 10 do // toujours 10 passages dans la boucle
res := res + i!2 + 2; // "or#ule en fonction de iend;
2. "crire un progra//e *ui de/ande une #aleur de n G l,utilisateur dans un T"dit et *ui
affic)e les n pre/iers no/res i/pairs par ordre décroissant dans un T5e/o.
3. Soit la suite définie par K-1 J 1'Q -n1J 2.-n A 3L. "crire un progra//e *ui de/ande une
#aleur de n G l,utilisateur dans un T"dit et *ui affic)e les n pre/iers /e/res de cette suitedans un T5e/o.
4. "crire un progra//e *ui de/ande G l,utilisateur une #aleur de n dans un T"dit et *uiaffic)e le résultat de nX dans un T&ael.
!. "crire un progra//e *ui de/ande G l,utilisateur une #aleur pour un réel x et un entier y
positif dans 2 T"dit et *ui affic)e le résultat de xy dans un T&ael.
6. "crire un progra//e *ui de/ande G l,utilisateur une #aleur de n dans un T"dit puis calcule
la so//e des n pre/iers carrés D1 4 % 16 2! n2E en affic)ant tous les résultatsinter/édiaires dans un T5e/o.
$. 5ontreW l,é#olution du contenu des #ariales x et y puis déduire le résultat G l,écran desinstructions sui#antes @var $,y : integer;
begin $ := 0; y :=1;
%&ile '$ (=2) dobegin
$ := $ + 1; y := y + $;
end; for#1*#e#o1*lines*add 'a valeur finale de y est : + y);
end;
. Rec)erc)e dic)oto/i*ue. "crire un progra//e *ui calcule l,ascisse du point d,intersectionentre les coures yJ lnDxE et yJ10x a#ec une précision de '''1. &a /ét)ode consiste G c)oisir 2 points d,ascisses x1 x2 autour de l,intersection et G situer le point /ilieu. Selon sa positionon l,éc)ange a#ec un des 2 points ce *ui per/et de di#iser l,inter#alle par 2. "nsuite on
reco//ence. +n pourra exploiter le fait *u,G gauc)e de l,intersection lnDxEU10x et *u,G droiteau contraire lnDxEY10x.
%. eu du de#ine le no/re @ écrire un progra//e *ui crée un no/re entier aléatoire x entre' et %%%% et *ui de/ande G un oueur )u/ain d,essayer de le trou#er. c)a*ue essai du
oueur l,ordinateur doit répondre si celuiAci est Btrop grandB Btrop petitB ou s,il a BgagnéB. &e eu se poursuit tant *ue l,Htre )u/ain n,a pas trou#é le no/re x. &ors*ue le oueur a gagnél,ordinateur annonce le no/re d,essais effectués par le oueur. &,ordinateur de/ande ensuiteau oueur s,il #eut reouer et agit en consé*uence.Il existe en Pascal un générateur de no/res aléatoires. Pour l,utiliser il faut écrirel,instruction rando/iWe au déut du progra//e Dfor/create par exe/pleE. "nsuite la fonction
rando/DexpressionE a pour #aleur un no/re réel co/pris entre ' et la #aleur de l,expression."xe/ple @ x @J rando/ D1''EQ K onne G x une #aleur dans l:inter#alle N'1''N L
8/18/2019 Cours Delphi ASD2
9/45
2. Révision sur les %ooléens et les ta%leaux
2.1 (es %ooléens
&es ooléens sont utilisés pour expri/er *u,une condition est #raie ou fausse. &e type ooléenest défini par un ense/le constitué de 2 élé/ents K trueQ false L et oéit G Z l:alg7re de=oole [.e /H/e *ue pour les integer ou les real il existe des opérateurs faisant inter#enir les
ooléens @
- Le and&e and est un opérateur inaire *ui nécessite donc deux opérandes. -n and entre 2expressions ooléennes a et per/et d,expri/er *u,une condition est respectée D#raieE si etseule/ent si les conditions définie par a et sont respectées D#raiesE. e /H/e *u,il existeune tale d,addition ou de /ultiplication pour les entiers il existe une tale du and pour les
ooléens @A.D alse true
alse false false
true false true
"xe/ple @ypot)7ses @A est un ooléen *ui #aut true si Pierre est plus grand *ue Paul et false sinonA = est un ooléen *ui #aut true si Pierre est plus grand *ue (ranMois et false sinonD and =E #aut true si Pierre est plus grand *ue Paul et Pierre est plus grand *ue (ranMois et
#aut false dans tous les autres cas ce *ui correspond G notre logi*ue intuiti#e.
- Le or&e or est égale/ent un opérateur inaire. -n or entre 2 expressions ooléennes a et per/etd,expri/er *u,une condition est respectée D#raieE si et seule/ent si l,une ou l,autre des deuxconditions définies par a et est respectée D#raieE. &a tale du or est présentée ciAdessous.
/R alse true
alse false true
true true true
Reprenons notre exe/ple @D or =E #aut true si Pierre est plus grand *ue Paul ou Pierre est plus grand *ue (ranMois oules deux et #aut false sinon ce *ui correspond lG encore G notre logi*ue intuiti#e.
- Le not&e not est le troisi7/e opérateur ooléen. Il expri/e tout si/ple/ent la #aleur contraire d,un
ooléen. insi x étant un ooléen si x #aut true not x #aut false et in#erse/ent si x #autfalse not x #aut true.
"nfin il ne faut pas oulier les opérateurs de co/paraison entre entier ou réels dont le résultat
est un ooléen. Par exe/ple D1' Y !E #aut true et D! J 6E #aut false. +n peut ien entendu
8/18/2019 Cours Delphi ASD2
10/45
co/iner les opérateurs @ si x y et W sont des réels l,expression Dx Y yE and Dx Y WE est un ooléen *ui #aut true si et seule/ent si x est supérieur G y et W.
2.2 'xercices sur les %ooléens
1. Soient ! #ariales ooléennes = C " expri/ant les propositions logi*ues sui#antes @
@ Il faut prendre le c)e/in de droite= @ Il ne faut pas prendre le c)e/in de gauc)eC @ Il ne faut pas prendre le c)e/in du /ilieu @ = dit la #érité et est un /enteur " @ C dit la #érité ou est un /enteur Sac)ant *ue 3 des propositions sont fausses par/i les ! *uel c)e/in fautAil prendre \Réponse partielle @ il faut essayer les 3 c)e/ins et calculer le no/re de #rais et e faux.
2. Soient 3 #ariales ooléennes = C expri/ant les propositions logi*ues sui#antes @ @ &e li#re est G droite de la la/pe= @ &a la/pe est G droite du crayonC @ &e crayon est G gauc)e du li#re"n utilisant les opérateurs and or et not appli*ués G = C donneW l,é*ui#alence ooléennedes propositions sui#antes @
1E &e crayon est l,oet le plus G droite.2E &a la/pe est au /ilieu3E &e li#re n,est pas l,oet le plus G gauc)e4E Si le crayon est au /ilieu alors la la/pe est G droite sinon la la/pe est au /ilieu.
Réponse du 1E @ not D=E and notDCE Dpeu i/porte la position du li#re par rapport G la la/peE
3. "crire la suite d,instructions *ui suppose *ue les coordonnées xy d,un point P sont données
par l,utilisateur et *ui affecte la #aleur true G une #ariale ooléenne res si et seule/ent si Pappartient G la Wone )ac)urée sui#ante Ddonc false sinonE @1E 2E
y J x
1A1
A1
1
3E
A2
A1
1
2
2.! 'xercices sur les ta%leaux
1. "crire un progra//e *ui de/ande G l,utilisateur 1' #aleurs enti7res 1 par 1 dans un seulT"dit *ui les stoc;e au fur et G /esure dans un taleau et *ui affic)e dans un T5e/o la plusgrande #aleur ainsi *ue son ordre d:insertion.
8/18/2019 Cours Delphi ASD2
11/45
2. "crire un progra//e *ui de/ande G l,utilisateur 1' #aleurs enti7res correspondant G desnotes entre ' et 2' G l:aide d:1 seul T"dit *ui les stoc;e dans un TString9rid et *ui affic)edans un T&ael co/ien de notes sont supérieures ou égales G 1'.
3. Soit T un taleau de $ caract7res correspondant G un /ot. "crire les instructions per/ettantde /odifier T de sorte *ue le /ot soit ren#ersé. Par exe/ple BonourB de#ient BruonoB.
4. +n désire effectuer des calculs sur les précipitations rele#ées c)a*ue /ois dans un /H/eendroit.aE outer un TString9rid pour *ue l:utilisateur puisse rentrer les #aleurs des précipitations
pour les 12 /ois. "crire les instructions per/ettant d:affic)er en pre/i7re colonne de cetaleau le no/ des 12 /ois d7s le lance/ent du progra//e.
E ans une procédure attac)ée G un outon écrire les instructions per/ettant d,affic)er dansun T5e/o l,écart de précipitation entre le /ois le plus plu#ieux et le /ois le /oins plu#ieuxainsi *ue le no/ de ces /ois.
cE "crire les instructions per/ettant d,affic)er l,)istogra//e des précipitations en utilisantl:instruction can#as.rectanleDx1 y1 x2 y2E de sorte *u:en ascisse on ait le nu/éro du/ois et en ordonnée les précipitations nor/alisées pour a#oir entre ' et 4'' pixels 4'' pour le /ois le plus plu#ieux.
!. -n da/ier 1' x1' d,un eu de da/es se présente en déut de partie de la faMon sui#ante @
1' > > > > >
% > > > > >
> > > > >
$ > > > > >
6!
4 = = = = =
3 = = = = =
2 = = = = =
1 = = = = =
1 2 3 4 ! 6 $ % 1'
aE Trou#er une structure de données adaptée pour ce eu. E "crire une procédure init *ui place les pions dans le taleau co//e indi*ué sur la figure.
6. eu du dé/ineur.-n terrain rectangulaire /iné est représenté par un taleau de >x5 cases d,entiers. u déutdu eu on placera un no/re ? de /ines de faMon aléatoire dans le terrain @ s,il n,y a pas de/ine la #aleur de la case doit Htre égale G A2 et s,il y a une /ine la #aleur de la case doit Htreégale G A1. "nsuite le oueur doit donner les coordonnées xy d,une case. S,il to/e sur unecase a#ec A1 il a perdu sinon on affecte G la case xy le no/re de /ines présentes dans uncarré 3 fois 3 centré en xy. +n affic)e alors toutes les cases du terrain a#ec la con#entionsui#ante @ si le no/re est négatif DA1 ou A2E on affic)e un point d,interrogation sinon onaffic)e la #aleur de la case. "nsuite on reco//ence le oueur doit donner les coordonnéesd,une autre case etc. &e eu se ter/ine lors*ue le oueur to/e sur une /ine ou lors*u,il atrou#é toutes les cases non /inées. &e no/re ? de /ines est de/andé G l,utilisateur au déutdu eu. > et 5 pourront Htre déclarés en constantes toutes 2 égales G ! pour co//encer.
8/18/2019 Cours Delphi ASD2
12/45
!. )ichiers textes génériques T$niile
!.1 $ntroduction
&es fic)iers textes a#ec extension .ini sont exploités par ]indos depuis les pre/i7res#ersions du syst7/e. Ils ser#aient nota//ent G initialiser Dd,o^ leur extensionE les différents
progra//es et l,en#ironne/ent grap)i*ue de ]indos. Ils sont définis dans elp)i par letype TInifile.
!.2 *rganisation d+un ichier .ini
-n fic)ier texte de type TInifile est constitué de sections placées entre croc)ets N et O. +n peutdéfinir autant de sections *ue nécessaires les unes G la suite des autres.ans c)a*ue section on définit un no/re aritraire de propriétés Ddéfinies en stringEé#entuelle/ent ' aux*uelles on affecte une #aleur au /oyen du signe J. Retour G la ligne etlignes lanc)es sont considérés co//e des séparateurs. es co//entaires peu#ent Htreaoutés apr7s des Q .&es fic)iers .ini sont généri*ues dans le sens o^ le type des propriétés est *uelcon*ue. Il peuts,agir d,entiers de réels de ooléens ou de string."xe/ple de contenu d,un fic)ier .ini @
Naffic)ageOlargeurJ'')auteurJ6''couleurJ165
NsonO
présence enceintesJno présence /icrop)oneJno
Npolice de caract7resOfonteJTi/es >e Ro/antailleJ14couleurJrouge
!.! ,tilisation d+un o%-et T$niile
TInifile est une classe donc un type. +n déclare un oet de type TInifile co//e toutes les#ariales et on le crée G l,aide de la fonction create a#ec co//e para/7tre un no/ de fic)ier.ttention par défaut le répertoire est celui de ]indos Dutiliser 9etir pour otenir lerépertoire de l,applicationE.éclaration en #ariale @ #ar f @ TInifileQInitialisation @ f @J TInifile.Create D no/defic)ier EQ(in d,utilisation @ f.freeQ
!.# Propriétés et méthodes des o%-ets T$niile
&a propriété fonda/entale des TInifile est (ilena/e *ui contient le no/ co/plet du fic)ier texte. &es oets de type TInifile co/portent essentielle/ent des /ét)odes Dprocédures etfonctionsE dédiées G la récupération des données présentes dans un fic)ier .ini ou G l,écriture
dans un tel fic)ier.
8/18/2019 Cours Delphi ASD2
13/45
!.#.1 (ecture dans un ichier .ini
• function ReadString DSection Ident efault@ StringE@ StringQ
Récup7re la c)a8ne de caract7res DstringE affectée G la propriété définie par BIdentB dans lasection BSectionB. Si BSectionB ou BIdentB n,existent pas la fonction retourne la #aleur du
para/7tre BefaultB.
• function Read=ool DSection Ident@ StringQ efault@ =ooleanE@ =oolean Q
Co//e ReadString /ais pour récupérer une #aleur ooléenne.
• function Read(loat DSection Ident@ StringQ efault@ ouleE@ oule Q
Co//e ReadString /ais pour récupérer une #aleur réelle en doule précision.
• function ReadInteger DSection Ident@ StringQ efault@ &ongIntE@ &ongInt Q
Co//e ReadString /ais pour récupérer une #aleur enti7re codée sur 4 octets.Il existe aussi Readate ReadTi/e et ReadateTi/e pour récupérer des )eures et des dates.
!.#.2 'criture dans un ichier .ini
>oteW *ue l,appel G la /ét)ode create ne gén7re auto/ati*ue/ent un nou#eau fic)ier *ue si
aucun fic)ier de /H/e no/ ne préexiste.• procedure ]riteStringDSection Ident Value@ StringEQ
ffecte G la propriété définie par BIdentB dans la section BSectionB la #aleur BValueB. SiBSectionB ou BIdentB n,existent pas elles sont créées auto/ati*ue/ent.
• procedure ]rite=oolDSection Ident @ StringQ Value@ =ooleanEQ
Co//e ]riteString /ais pour affecter un ooléen.
• procedure ]rite(loatDSection Ident @ StringQ Value@ ouleEQ
Co//e ]riteString /ais pour affecter un réel en doule précision.
• procedure ]riteIntegerDSection Ident @ StringQ Value@ &ongIntEQ
Co//e ]riteString /ais pour affecter un entier.
Il existe aussi ]riteate ]riteTi/e ]riteateTi/e
Pour la liste co/pl7te des /ét)odes se référer G l,aide en ligne. +n peut noter nota//ent lesfonctions ooléennes Section"xists pour tester l,existence d,une section et Value"xists pourtester l,existence d,une propriété dans une section donnée.
!.& 'xemple
9estion d,un arre généalogi*ue. &es données concernant c)a*ue personne sont )étérog7neset sou#ent inco/pl7tes ou approxi/ati#es ce *ui co/pli*uerait la gestion d,une ase dedonnées classi*ue. &e TInifile facilite cette utilisation. u dé/arrage de l,application unfic)ier de type TInifile est lu afin de rentrer toutes les données JY é#éne/ent (or/Create
procedure -"or#1*"or#.reate'ender: -bject);
var f : -nifile;
section, se$e, repertoire, annee : string; i : integer;
trouve : boolean; p : ppersonne; // tructure de donne de type record pour stoc3er les infor#ations
begin // concernant une personne
et5ir '0, repertoire) ; // 6er#et dobtenir le rpertoire courant de lapplication repertoire := repertoire + 7; // e fic&ier est plac en sous8rpertoire
f := -nifile*create'repertoire + genealogie*ini); // nitialisalisation du -nifile i := 0;
8/18/2019 Cours Delphi ASD2
14/45
trouve := true;
// .&arge#ent des personnes while trouve do
begin
i := i + 1; // nu#ro de la personne
section := nt-otr'i); if f*ection9$ists'section) then begin
p*identifiant := i;
p*no# := f*eadtring'section,no#, ); p*preno# := f*eadtring'section,preno#, );
p*no# := f*eadtring'section,no#, ); p*anneenaissance := f*eadnteger'section,anneenaissance, 81);
p*#oisnaissance := f*eadtring'section, #oisnaissance, );
p*no#jeunefille := f*eadtring'section, no#jeunefille,); se$e := f*eadtring'section, se$e,#);
p*se$e := se$e1
8/18/2019 Cours Delphi ASD2
15/45
re/Jort)ograp)e préno/ \ données incertaines fournies par upond (ranMoisesexeJ/
8/18/2019 Cours Delphi ASD2
16/45
#. $ntroduction au langage o%-et
#.1 ,tilité des o%-ets
&e langage oet per/et @• &,encapsulation de c)a/ps et de /ét)odes dans une /H/e classe dans le ut
d,organiser et de structurer les données de /ani7re co)érente.
• -ne plus grande /odularité c)a*ue classe pou#ant sou#ent Htre construite
indépenda//ent des autres.
• -ne plus grande réutilisailité gr_ce G la définition de classes généri*ues co//e par
exe/ple TStac; T
8/18/2019 Cours Delphi ASD2
17/45
endQ
#.! "lasse T)orm
&a classe T(or/ est la classe *ui définit les fic)es. &ors de la définition d,une nou#elle fic)etype typi*ue/ent T(or/1 on )érite des propriétés et /ét)odes de T(or/ gr_ce G la ligne @
T(or/1 J class D T(or/ E&ors*u,on place de nou#eaux co/posants T&ael T"dit etc. sur la fic)e ceuxAciappartiennent G T(or/1 /ais pas G T(or/.ttention T(or/1 est une classe définie dans la partie type. Pour créer une fic)e de typeT(or/1 il faut déclarer une #ariale par exe/ple (or/1 *ui est de type T(or/1. Ceci estfait auto/ati*ue/ent par elp)i lors de la création d,une nou#elle fic)e. Co//e tous lesoets il faut attriuer un espace /é/oire G for/1 gr_ce G un appel G la /ét)ode create oué#entuelle/ent celle *ui la re/place. Ceci est égale/ent réalisé de faMon auto/ati*ue par elp)i au ni#eau du fic)ier proet Dle .dprE gr_ce G la ligne @
pplication.Create(or/DT(or/1 (or/1EQTous les é#éne/ents associés G des co/posants de la fic)e par exe/ple un clic sur un
outon sont des /ét)odes de la fic)e et sont donc déclarées dans T(or/1.+n peut égale/ent aouter G la fic)e des propriétés et des /ét)odes *ui ne sont pas associéesG un co/posant de la fic)e. Toutefois l,intérHt du langage oet est de regrouper les propriétéset les /ét)odes de faMon logi*ue il faut donc l,é#iter.
#.# Pu%lic Private
-ne propriété ou une /ét)ode peut Htre déclarée dans la partie BpulicB ou Bpri#ateB d,uneclasse. Si elle est dans la partie pulic elle est accessile par un oet de n,i/porte *uelleclasse. Si elle est dans la partie pri#ate seule une /ét)ode de la /H/e classe peut y faireréférence ou é#entuelle/ent du /H/e fic)ier pascal. Par défaut toutes les propriétés et
/ét)odes sont puli*ues. Cependant il faut au contraire pri#atiser au /axi/u/ pour garantir une séparation claire des oets.0xemple :
Interface
type
-.lassbjet1 = class public $ : integer;
private y : integer;
end;-classbjet2 = class
private > : integer;
procedure essai;end;
implementation
procedure -.lassbjet2*essai;
var obj1 : -.lassbjet1;begin
obj1 := -.lassbjet1*.reate;
obj1*$ := ?; // @utoris, car $ est publiAueobj1*y := 4; // 9rreur à la co#pilation, car interdit, y est priv
> := ?; // @utoris, car priv, #ais appartient à la classe
end;
8/18/2019 Cours Delphi ASD2
18/45
#.& "onstructeur
constructor est une /ét)ode spéciale de la classe appelée pour allouer de l,espace /é/oire Gl,oet et initialiser é#entuelle/ent certains c)a/ps. 9énérale/ent on l,appelle BcreateB a#ec
parfois des para/7tres en fonction des esoins.Si on ne définit pas de constructeur c,est la /ét)ode Create de T+ect *ui oue ce rle par
défaut Dcar on )érite oligatoire/ent des /ét)odes de T+ectE. &,appel au constructeur doitse faire pour c)a*ue oet créé. Si on c)erc)e G accéder G la #aleur d,un c)a/p de l,oet alors*u,il n,y a pas eu d,appel au constructeur il y a une erreur tout si/ple/ent parce *u,il n,y a pasd,espace /é/oire #alide attac)é G l,oet.
• "xe/ple de construction @
#ar p @ TClassPointQ egin
p @J TClassPoint.Create D 1 2 EQ
>oteW *u,apr7s appel au constructeur l,oet p est en fait une référence per/ettant G
l,application de retrou#er en /é/oire tous les c)a/ps et /ét)odes de l,oet. Pour accéder Gces c)a/ps il faut si/ple/ent aouter un point et le no/ du c)a/p par exe/ple p.x ou p.y.
#./ Destructeur
destructor est une /ét)ode spéciale de la classe appelée pour liérer l,espace /é/oire del,oet et é#entuelle/ent effectuer d,autres traite/ents. 9énérale/ent on l,appelle BdestroyBa#ec parfois des para/7tres en fonction des esoins. &a /ét)ode BfreeB est égale/entsou#ent utilisée lors*u,on désire seule/ent liérer l,espace /é/oire.ttention apr7s appel du destructeur ou de free l,acc7s G un c)a/p de l,oet entra8ne uneerreur car il n,y a plus de référence #alide en /é/oire.
#.0 AectationSoit 2 oets p1 et p2 de la /H/e classe. Si p1 a été créé a#ec appel du constructeur alorsBp2 @J p1B est autorisé et affecte la référence de p1 dans p2 de sorte *ue p1 et p2 référencentle /H/e oet G la /H/e position en /é/oire.Re/ar*ue @ si p1 et p2 référencent 2 oets différents l,affectation précédente conduit G perdrela référence de p2.Si on #eut *ue les c)a/ps de p1 soient copiées dans les c)a/ps de p2 il faut affecter c)a*uec)a/p indépenda//ent."xe/ple @
p2.x @J p1.xQ
p2.y @J p1.yQinsi p1 et p2 sont 2 oets différents Dréférence différente position différente en /é/oireE/ais leurs c)a/ps ont la /H/e #aleur..B @ Pour certaines classes prédéfinies de elp)i il est possile d,affecter tous les c)a/psd,un seul coup gr_ce G la /ét)ode BssignB. e /H/e si on crée une nou#elle classe on a
parfois intérHt G définir une /ét)ode pour copier les c)a/ps d,un oet et les affecter G unautre oet de la classe.
#. éritage simple
Pour )ériter des c)a/ps et des /ét)odes d,une classe il suffit de préciser entre parent)7seslors de la déclaration la classe ancHtre. "xe/ples @
T(igure J class endQTRectangle J class D T(igure E endQ
8/18/2019 Cours Delphi ASD2
19/45
TCarre J class D TRectangle E endQT"llipse J class D T(igure E endQAttention il existe des r7gles contraignantes pour l,affectation si on /anipule des oets declasses )éritées.ans le cas des déclarations précédentes si on a @
#ar ( @ T(igureQ R @ TRectangleQ C @ TCarreQ " @ T"llipseQ+n a le droit d,écrire @( @J RQ ( @J "Q ( @J CQ R @J CQ5ais on n,a pas le droit d,écrire entre autres @R @J (Q " @J (Q C @J (Q C @J RQ
0xplications :( est un T(igure donc G l,adresse /é/oire référencée par ( on doit pou#oir accéder G tousles c)a/ps *ui appartiennent au type T(igure. Si on fait ( @J R on a effecti#e/ent G lanou#elle adresse de ( tous les c)a/ps de la classe T(igure puis*u,il s,agit d,un TRectangle*ui )érite de T(igure. "n re#anc)e si on fait R @J ( on a G la nou#elle adresse de R tout ce
*ui concerne un T(igure /ais on ne peut a#oir d,é#entuels nou#eaux c)a/ps appartenantspécifi*ue/ent G un TRectangle
R1gle complémentaire :Il est possile de donner G une /ét)ode de la nou#elle classe le /H/e no/ *u,une /ét)ode)éritée. &a /ét)ode appelée en priorité est touours celle *ui correspond au type de la#ariale. >ous #errons dans les c)apitres sui#ants d,autres r7gles concernant l,)éritage etl,utilisation du /H/e no/ de /ét)ode.
#.3 'xercice
0xercice :TClassPersonne est défini co//e suit @TClassPersonne J class
no/ @ stringQ preno/ @ stringQage @ integerQinfor/ation @ stringQ
endQCréeW une nou#elle classe T&istPersonnes *ui )érite de T&ist et *ui inclut les /ét)odessui#antes @function Rec)erc)e D no/ preno/ @ string E @ TClassPersonneQ 00 Retourne le TClassPersonne
00 rec)erc)é procedure TriPargeQ 00 Trie la liste par ordre croissant en fonction de l,_ge
Réponse :interface type
T&istPersonnes J class D T&ist Econstructor createQfunction Rec)erc)e D no/ preno/ @ string E @ TClassPersonneQ
procedure TriPargeQdestructor destroyQ
endQi/ple/entation
8/18/2019 Cours Delphi ASD2
20/45
DEconstructor T&istPersonnes.CreateQ
eginin)erited createQ
endQ
DEfunction T&istPersonnes.Rec)erc)eD no/ preno/ @ string E @ TClassPersonneQ#ar i @ integerQ trou#e @ ooleanQ p @ TClassPersonneQ
egintrou#e @J falseQ i @J 'Q p @J nilQ)ile not trou#e and Di U count E do
egin p @J ite/sNiOQ 00 Rappel passage oligatoire car ite/sNiO est de type pointeur if Dp.no/ J no/E and Dp.preno/ J preno/Et)en trou#e @J trueelse i @J i 1Q
endQRec)erc)e @J pQ
endQDEfunction co/pare D p1 p2 @ pointer E @ integerQ#ar pers1 pers2 @ TClassPersonneQ
egin pers1 @J p1Q pers2 @J p2Q 00 +ligatoire pour a#oir acc7s aux c)a/psif pers1.age U pers2.age t)en co/pare @J 1else if pers1.age J pers2.age t)en co/pare @J 'else co/pare @J A1
endQ procedure T&istPersonnes.TriPargeQ egin
sort D co/pare EQendQDEdestructor T&istPersonnes.estroyQ
eginin)erited destroyQ
endQ
#ommentaires @ "n )éritant de T&ist on énéficie auto/ati*ue/ent des /ét)odes Dpar exe/ple countE et des c)a/ps de T&ist Dnota//ent ite/sE. &,intérHt est de pou#oir /anipuler un seul type pour gérer une liste de personnes. Par ailleurs si T&ist était a/éliorée on)ériterait en /H/e te/ps de ces a/éliorations sans a#oir G se soucier du détail des/odifications apportées.
0xercice 2Créer un oet TClassPoint pour /anipuler des points en 3 di/ensions a#ec la possiilité decalculer la distance entre 2 points et une procédure d,affic)age *ui grossit le point de 1 G 1'
pixels selon *ue la 37/e co/posante est proc)e ou loin de l,origine.
8/18/2019 Cours Delphi ASD2
21/45
&. éritage et polymorphisme
&.1 Surcharge
u sein d:une /H/e classe on peut déclarer plusieurs /ét)odes a#ec le /H/e no/ Gcondition *u:elles aient un no/re de para/7tres ou0et un type différent. Il faut alors indi*uer G la fin de la /ét)ode le /otAclé o#erload Dsurc)argeE."xe/ple a#ec le constructeur @TCercle J class
?' b' @ real QR @ real Q00 Construction G partir du centre et du rayonConstructor create D x' y' @ real Q R @ real E Q +#erload Q00 Construction G partir du carré engloantConstructor create D r @ trect E Q +#erload Q
00 Construction G partir de 3 pointsConstructor create D x1 y1 x2 y2 x3 y3 @ real E Q +#erload Q
end Q.B @ S:il existe une /ét)ode de /H/e no/ dans la classe ancHtre 2 cas se présentent @
o Si la liste des para/7tres est différente elle peut aussi Htre appelée.
o Si la liste des para/7tres est identi*ue G une /ét)ode redéclarée elle est Z /as*uée [
et ne peut pas Htre appelée.
&.2 4éthode statique
Par défaut toutes les /ét)odes sont dites Z stati*ues [. &ors*u:une /ét)ode stati*ue estappelée et *u:une /ét)ode de /H/e no/ existe dans la classe ancHtre c:est le type déclaré del:oet déclaré en #ariale *ui déter/ine *uelle /ét)ode est appelée."xe/ple @Type
T(igure J classProcedure dessin Q
end QTRectangle J class D T(igure E
Procedure dessin Q
end Q#ar
(igure @ T(igure QRectangle @ TRectangle Q
=egin(igure @J T(igure.create Q(igure.dessin Q 00 ppelle T(igure.dessin(igure.destroy Q(igure @J TRectangle.create Q 00 utorisé #oir r7gles d:affectation(igure.dessinQ 00 ppelle touours T(igure.dessinX(igure.destroy QRectangle @J TRectangle.create QRectangle.dessin Q 00 ppelle TRectangle.dessin
Rectangle.destroy Q"nd Q
8/18/2019 Cours Delphi ASD2
22/45
&.! 4éthodes virtuelles
-ne /ét)ode peut Htre déclarée #irtuelle dans une classe ancHtre G l:aide du /otAcléZ #irtual [. ans les classes *ui )éritent de la classe ancHtre une /ét)ode de /H/e no/ peutHtre déclarée surc)argée a#ec le /otAclé Z o#erride [. &a différence c:est *ue cette foisAci la/ét)ode appelée ne dépend pas du type déclaré de la #ariale /ais du type utilisé pour la
construction de la #ariale."xe/ple @Type
T(igure J classProcedure dessin Q #irtual Q
end QTRectangle J class D T(igure E
Procedure dessin Q o#erride Q
end Q#ar
(igure @ T(igure QRectangle @ TRectangle Q=egin
(igure @J T(igure.create Q(igure.dessin Q 00 ppelle T(igure.dessin(igure.destroy Q(igure @J TRectangle.create Q 00 utorisé #oir r7gles d:affectation(igure.dessinQ 00 ppelle TRectangle.dessin XXX(igure.destroy QRectangle @J TRectangle.create QRectangle.dessin Q 00 ppelle TRectangle.dessinRectangle.destroy Q
"nd Q
"n général on utilise #irtual pour pou#oir utiliser une /ét)ode o#erride définie dans uneclasse descendante d:o^ le concept de #irtualité..B @ Si o#erride est o/is c:est la /ét)ode #irtuelle *ui est appelée..B2 @ -ne /ét)ode peut égale/ent Htre déclarée Z dyna/ic [ au lieu de Z #irtual [. &econcept est prati*ue/ent é*ui#alent l:idée étant *ue c:est G l:exécution de faMon dyna/i*uedonc *u:il y a déter/ination de la /ét)ode G appeler.
&.# 4éthode a%straite
-ne /ét)ode #irtuelle ou dyna/i*ue est astraite DZ astract [E si son i/plé/entationn:existe pas. &e prol7/e est résolu G l:exécution a#ec une /ét)ode o#erride dans une desclasses descendantes."xe/ple @Type
T(igure J classProcedure dessin Q #irtual Q astract Q
end QTRectangle J class D T(igure E
Procedure dessin Q o#erride Q
end Q#ar
(igure @ T(igure Q
=egin (igure @J T(igure.create Q(igure.dessin Q 00 I>T"RIT XXX car T(igure.dessin est astraite
8/18/2019 Cours Delphi ASD2
23/45
(igure.destroy Q(igure @J TRectangle.create Q 00 utorisé #oir r7gles d:affectation(igure.dessinQ 00 VoilG le seul usage possile @ appelle TRectangle.dessin XXX(igure.destroy Q
"nd Q
.B @ Si une /ét)ode )éritée est astraite on ne peut pas utiliser Z in)erited [ dans la /ét)ode
surc)argée.
&.& Sel
Z self [ est un /otAclé faisant référence G l:oet luiA/H/e dans une des /ét)odes de saclasse. +n peut a#oir esoin d:utiliser Z self [ pour plusieurs raisons nota//ent si on #eut
passer l:oet en para/7tre d:une /ét)ode."xe/ple @InterfaceType TPeinture J class
Procedure ffic)e Q
end QT(igure J class
Procedure ra D peinture @ Tpeinture E Q
"ndQi/ple/entation
procedure TPeinture.ffic)eQ#ar f @ T(igure Q
eginf @J T(igure.create Qf.ra D self E Q 00 Self désigne ici l:instance de la classe TPeinture *ui a per/is d:appeler affic)ef.destroy Q
end Q
#ar p @ TPeinture Q
egin p @J TPeinture.create Q p.affic)e Q 00 Ici c:est p *ui est l:instance de la classe TPeinture p.destroy Q
end Q
.B @ self est co//e une #ariale locale *ui existe dans toutes les /ét)odes
&./ *pérateurs de classe
3 4ranst5page+n peut /odifier le type d:une #ariale G l:exécution en la précédant du no/ d:un autre type
puis de la #ariale entre parent)7ses. Il faut é#iter autant *ue possile cette action *ui conduitsou#ent G des erreurs /ais dans certains cas il n:y a pas d:autres solutions."xe/ple @Var & @ T&ist Q p @ TClassPoint Q p @J &.ite/sN'O Q
x' @J p.x"*ui#alent G x' @J TClassPointD &.ite/sN'O E.x Q
3 /pérateur is&:opérateur Z is [ per/et de tester le type d:une #ariale oet.
>o/+et is >o/Classe ren#oie true si l:oet est de cette classe et false sinon."xe/ple @If for/1.acti#econtrol is T"dit t)en s @J T"ditD for/1.acti#econtrol E.text Q
8/18/2019 Cours Delphi ASD2
24/45
/. Polymorphisme5 étude d+un exemple
/.1 Pro%l6me
+n dispose d,une liste de figures géo/étri*ues *ui sont de type TClassCercle ouTClassRectangle *ui )éritent d,une classe TClass(igure. Pour gérer cette liste on #oudraitutiliser le type T&ist. Pour insérer une nou#elle figure dans la liste on de/ande si/ple/ent Gl,utilisateur soit les coordonnées du centre et la #aleur du rayon soit les coordonnées des 4so//ets du rectangle puis on crée un oet de la classe appropriée et on l,aoute G la liste."nsuite on de/ande G l,utilisateur un no/re n et on affic)e G l,écran la ni7/e figure de laliste ainsi *ue le résultat du calcul de sa surface.&,idéal serait de pou#oir écrire la procédure sui#ante @var iste"igures : -ist; // Bariable globale
procedure -"or#1*Cutton5e#ande@ffic&age9turface ' sender : -bject );
var n : integer;
f : -.lass"igure; // Due ce soit un cercle ou un rectanglebegin
n := tr-ont' editnu#*te$t ); // editnu# est un -9dit f := iste"igures*te#sn81
8/18/2019 Cours Delphi ASD2
25/45
i#ple#entation
constructor -.lass.ercle*.reate ' $, y : integer; rayon : integer );begin
in&erited create;
$0 := $; y0 := y; := rayon;
end;
procedure -.lass.ercle*@ffic&e ' canvas : -.anvas );
begin
canvas*ellipse ' $08, y08, $0+, y0+);end;
function -.lass.ercle*urface : real;
begin
urface := pi!!;end;
constructor -.lassectangle*.reate ' a, b, c, d : -6oint );
begin
in&erited create; p1 := a; p2 := b; p? := c; p4 := d;
end;
procedure -.lassectangle*@ffic&e ' canvas : -.anvas );
begincanvas*polyline ' p1, p2, p?, p4, p1< );
end;
function -.lassectangle*urface : real;
beginurface := sArt'sAr'p2*$8p1*$)+sAr'p2*y8p1*y)) ! sArt'sAr'p4*$8p1*$)+sAr'p4*y8p1*y));
end;
Reste G écrire les procédures liées G l,interface.
procedure -"or#1*Cutton.ree.ercle.lic3 ' sender : -bject );
var . : -.lass.ercle;
begin .:= -.lass.ercle*.reate ' tr-ont'edit1*te$t),
tr-ont'edit2*te$t), tr-ont'edit?*te$t) ); iste"igures*@dd ' . );
end;
procedure -"or#1*Cutton.reeectangle.lic3 ' sender : -bject );
var : -.lassectangle; a, b, c, d : -6oint;begin
a*$ := tr-ont' stringgrid1*cells1,1< ); a*y := tr-ont' stringgrid1*cells2,1< );b*$ := tr-ont' stringgrid1*cells1,2< ); b*y := tr-ont' stringgrid1*cells2,2< );
c*$ := tr-ont' stringgrid1*cells1,?< ); c*y := tr-ont' stringgrid1*cells2,?< );d*$ := tr-ont' stringgrid1*cells1,4< ); d*y := tr-ont' stringgrid1*cells2,4< );
8/18/2019 Cours Delphi ASD2
26/45
:= -.lassectangle*create ' a,b, c, d);
iste"igures*@dd ' );end;
&e poly/orp)is/e est ici /is en #aleur gr_ce G l,astraction des /ét)odes de Tfigure. Si on
de#ait aouter /aintenant une classe TClassTriangle per/ettant de traiter égale/ent desfigures de type triangle il suffirait de raouter les /ét)odes spécifi*ues G cette classed,aouter une interface per/ettant de récupérer les para/7tres du triangle et le reste du
progra//e resterait identi*ue.
/.! 'xtension
Supposons /aintenant *ue nous désirions pou#oir a#oir le c)oix de dessiner en trait plein ouen pointillé ainsi *ue la couleur du trait. Il s,agit ici de para/7tres *ui sont indépendants dutype de figure. +n peut donc raouter des c)a/ps au ni#eau de la classe T(igure et du /H/ecoup i/plé/enter un constructeur pour les initialiser.
-.lass"igure = class // Ee$iste Aue pour bnficier de l&ritage
couleurdutrait : -color;typedetrait : string; // plein ou pointill
constructor create ' c : -.olor; trait : string );
procedure affic&e ' canvas : -canvas ); virtual; abstract; function surface : real; virtual; abstract;
end;
constructor -.lass"igure*.reate ' c : -.olor; trait : string );
begin
in&erited create;couleurdutrait := c;typedetrait := trait;
end;
Il faudrait ensuite raouter une interface pour *ue l,utilisateur puisse définir ses c)oix et/odifier les constructeurs des classes descendantes afin *ue le Bin)erited createB co/porte les2 para/7tres re*uis. "nfin il faut /odifier la procédure d,affic)age co//e suit @
procedure -"or#1*Cutton5e#ande@ffic&age9turface ' sender : -bject );var n : integer;
f : -.lass"igure; // Due ce soit un cercle ou un rectanglebegin
n := tr-ont' editnu#*te$t ); // editnu# est un -9dit
f := iste"igures*te#sn81
8/18/2019 Cours Delphi ASD2
27/45
0. (istes cha7nées
0.1 Représentation
&iste c)a8née de n élé/ents @
.
• 0lément @ structure *uelcon*ue par exe/ple un oet TI/age ou une structure de type
Z record [.
• 'dée de cha%nage @ G partir de l:élé/ent courant il est possile d:accéder G l:élé/ent
sui#ant.
• #onsé"uence @ il suffit d:a#oir l:acc7s au 1er élé/ent pour pou#oir accéder G tous les
élé/ents de la liste.
0.2 8estion d9une liste cha7née
Pour gérer correcte/ent une liste c)a8née il faut pou#oir @A créer et suppri/er la listeA aouter des élé/entsA suppri/er des élé/entsA déplacer des élé/entsA accéder aux élé/ents nota//ent le 1er et le dernier A conna8tre le no/re d:élé/entsA c)erc)er la présence d:un élé/ent donné
0.! (iste cha7née dans un ta%leau
+n peut utiliser un taleau pour représenter une liste d:élé/ents.0xemple @00 éfinition d:un type pour représenter des personnestypeRpersonne J record
>o/ @ stringN!'O Qge @ integer QProfession @ stringN!'O Q
"nd Q00 éfinition d:un taleau de 1'' personnes en #ariale#ar T @ arrayN1..1''O of Rpersonne Q
Adresse mémoire 6aleurs1''' upond
2!rc)itecte
11'4 urand4!+u#rier agricole
12' Colin
2!=an*uier
"tc.
"lé/ent 1 "lé/ent 2 "lé/ent 3 "lé/ent n
8/18/2019 Cours Delphi ASD2
28/45
Avantages :
• C)a8nage intégré dans la structure sé*uentielle du taleau @ le sui#ant est placé en /é/oire
G l:adresse sui#ante.
• Parcours si/ple de la liste G l:aide d:une #ariale représentant l:indice de l:élé/ent.
• +n peut accéder G n:i/porte *uel élé/ent G tout /o/ent G partir de son indice.
Désavantages et limites :
• Réorganisation de la liste fastidieuse. Par exe/ple co//ent insérer un nou#el élé/ent au
/ilieu \ Il faut opérer un décalage de tous les autres élé/ents. 5H/e prol7/e pour lasuppression d:un élé/ent G /oins de gérer des cases #ides.
• +n ne peut pas utiliser une liste d:élé/ents *uelcon*ues par exe/ple un entier co//e 1er
élé/ent puis un record constitué de 2 string co//e 27/e élé/ent etc. Cause @ pour accéder G l:élé/ent d:indice i l:ordinateur calcule l:adresse du déut du taleau et aoute i fois la
place occupée par l:élé/ent structurant du taleau *ui ne peut donc #arier.
• Si on utilise un taleau Z stati*ue [ le no/re d:élé/ents doit Htre fixé G l:a#ance /H/e si
on ne sait pas co/ien d:élé/ents il y aura dans la liste.
0.# Ta%leaux dynamiques
&e prol7/e d aux taleaux stati*ues dont la taille est définie G l:a#ance peut Htre résolu par l:utilisation de taleaux dyna/i*ues G l:aide de l:instruction Z setlengt) [.Set&engt) D no/dutaleau no/redele/ents E Q0xemple @#ar t @ array of RPersonne Q 00 Pas d:indice défini G l:a#ance
puis dans le progra//e @setlengt) D t 1'' E Q 00 lloue de la place /é/oire pour 1'' élé/ents de type RPersonne
Remar"ues @
• Tous les taleaux dyna/i*ues ont pour pre/ier indice '.
• Pour les taleaux /ultidi/ensionnels il suffit de définir les tailles sui#antes. "xe/ple @
setlengt) Dt 1'' 3E Q 00 Co//e arrayN'..%% '..2O
0.& T(ist
T&ist est un type généri*ue de elp)i pour gérer les listes c)a8nées G l:aide d:un taleau de pointeurs.
45pe pointer :
Z pointer [ est un entier *ui stoc;e une adresse en /é/oire Dou pointeurE d:une #ariale. &a/anipulation de pointeurs est co/plexe seul nous suffit pour l:instant la co/pré)ension duconcept.
!ropriétés de 4List :
• Count @ integer Q 00 >o/re d:élé/ents de la liste
• Ite/s @ array of pointer Q 00 Taleau pointant sur les élé/ents
• Capacity @ integer Q 00 >o/re /axi/al d:élé/ents *ue peut contenir la liste. Cette
propriété n:a de sens *ue parce *ue T&ist exploite un taleau pour stoc;er les données.
>= @ &es élé/ents sont rangés dans le taleau G partir de l:indice '.
8/18/2019 Cours Delphi ASD2
29/45
7éthodes de 4List 0xplications et commentaires
Constructor Create Q +ligatoire pour initialiser une liste."xe/ple. @ list @J T&ist.Create Q
Procedure (ree Q &iération de l:espace /é/oire allouée G laliste
(unction dd D ele/ent @ pointer E@ IntegerQ oute un élé/ent en fin de liste et ren#oieson indice
Procedure InsertDIndex@ IntegerQ ele/ent @PointerEQ
Ins7re un élé/ent G la position spécifiée
(unction "xtractD ele/ent @ pointerE@ PointerQ Retire l:élé/ent spécifié et ren#oie son pointeur
(unction Re/o#eDele/ent @ PointerE@ IntegerQ Retire la pre/i7re occurrence de l:élé/entspécifié et ren#oie son indice
Procedure eleteDIndex@ IntegerEQ Retire l:élé/ent dont l:index est spécifié
(unction (irst@ PointerQ Co//e Ite/sN'O ren#oie le 1er élé/ent
(unction &ast @ Pointer Q Co//e Ite/sNlist.countA1O ren#oie ledernier élé/ent
Procedure 5o#eDCurIndex >eIndex@IntegerEQ
éplace un élé/ent d:un index #ers un autre.
(unction Index+fDele/ent @ PointerE@ IntegerQ Ren#oie l,indice de la pre/i7re entrée dutaleau Ite/s contenant l:élé/ent spécifié
0./ 'xemple
Voici un petit progra//e *ui définit dans un pre/ier te/ps une nou#elle classe d,oetsno//ée TClassPoint et *ui exploite une liste c)a8née pour insérer 2 points lors du clic; sur un pre/ier outon. -n deuxi7/e outon est utilisé pour récupérer le 1er et le dernier élé/entde la liste et affic)er un petit cercle G la position des points.
E-9"@.9 -ype // a fic&e co#porte un bouton nit et un bouton @ffic&e non dcrits ici
-.lass6oint = class '-bject) $ : integer;
y : integer;
end;
F69F9E-@-E var l : -ist;
procedure -"or#1*Cuttonnit.lic3'ender: -bject);
var p1, p2 : -.lass6oint;begin
l := -ist*.reate; p1 := -.lass6oint*create;
p2 := -.lass6oint*.reate;
p1*$ := 1;
p1*y := 100; p2*$ := G0; p2*y := G0;
8/18/2019 Cours Delphi ASD2
30/45
l*@dd' p1);
l*@dd' p2);end;
procedure -"or#1*Cutton2.lic3'ender: -bject);
var p : -.lass6oint;begin p := l*first;
canvas*ellipse 'p*H, p*I, p*H+2, p*y+2);
p := l*last; canvas*ellipse 'p*H, p*I, p*H+2, p*y+2);
end;
0.0 'xercices
éfinisseW une classe TClassPoint. l,aide d,un outon initialiseW une liste de 3' points a#ecdes coordonnées aléatoires entre 1'' et 3''.outeW un 27/e outon pour affic)er tous les points de la liste sous la for/e d,un cercle rougeDord et intérieurE de ! pixels de dia/7tre centré sur le point D/ét)ode can#as.ellipseEouteW un 37/e outon pour dessiner en leu les 3 pre/iers points de la liste dont lescoordonnées sont inférieures G 2!'.
8/18/2019 Cours Delphi ASD2
31/45
. Piles
.1 Représentation
ans le argon infor/ati*ue une pile est une liste c)a8née d:élé/ents dont la gestions:apparente G celle d:une Z pile [ Dstac; en nglaisE classi*ue par exe/ple une pile dedossiers sur un ureau. &es élé/ents sont donc représentés les uns auAdessus des autres le
pre/ier inséré en as et le dernier en )aut.
ernier arri#é
#antAdernier arri#é
1er arri#é
.2 8estion d9une pile
• &:insertion d:un nou#el élé/ent se fait touours en )aut de la pile.
• Pour la consultation des élé/ents de la pile on acc7de touours G l:élé/ent en )aut d:aord.
• Pour la suppression de /H/e on suppri/e touours celui du )aut d:aord.
insi c:est touours le dernier élé/ent arri#é *ui est consulté et suppri/é en pre/ier. +n parle de gestion L'8/ D&ast In (irst +utE.
.! 'xemples de piles
#trl 9 :ans un éditeur de texte et dans ien d:autres progra//es il est possile d:annuler lesderni7res co//andes et de re#enir en arri7re. C:est d:aord la derni7re co//ande *ui estannulée puis l:a#antAderni7re etc. &es co//andes ont été e/pilées au fur et G /esure dutra#ail dans une pile. &ors de l:annulation c:est la derni7re co//ande enregistrée *ui estannulée et *ui est sortie de la pile on a ien une gestion &I(+.!ile pour la gestion des appels de onction : c)a*ue appel de procédure ou de fonction le progra//e réser#e de la place en /é/oire
pour les #aleurs des para/7tres et des #ariales locales. Il g7re cette réser#ation de placeco//e une pile @ si une nou#elle procédure ou fonction est appelée il réser#e de la place en)aut de la pile et si une procédure ou fonction se ter/ine il li7re la place occupée il dépile.Re/ar*ue @ il arri#e *ue le progra//e n,ait pas asseW de place en /é/oire pour un nou#elappel de procédure ou de fonction. Il est possile de /odifier la taille /é/oire /axi/ale dela pile dans le /enu Proet +ptions et éditions des liens.
.# *%-ets TStac:
TStac; est une classe d,oets dédiés G la gestion des piles. &,élé/ent de la pile peut Htren,i/porte *uel oet ou pointeur.TStac; n,a pas de propriété /ais uni*ue/ent des /ét)odes.
TStac; est défini dans l,unité Contnrs il faut donc aouter Buses contnrsB dans la partie uses del,unité.
"lé/ent 1
"lé/ent 2
"lé/ent n
8/18/2019 Cours Delphi ASD2
32/45
.& 4éthodes de TStac:
constructor CreateQ Co//e toutes les classes il y a un constructeur
function Count @ integerQ Ren#oie le no/re d,élé/ents de la pile
procedure Pus) Dp @ PointerEQ Place l,élé/ent p en )aut de la pile J e/pile
function Pee; @ pointerQ Récup7re l,élé/ent en )aut de la pile sans dépiler
function Pop @ pointerQ Récup7re l,élé/ent en )aut de la pile et lesuppri/e de la pile J dépile
function t&east D n @ integer E @ ooleanQ
éter/ine s,il reste au /oins n élé/ents dans la pile et retourne true ou false.
./ 'xercice
é#eloppeW une application per/ettant de dessiner des points noir n,i/porte o^ sur unco/posant TI/age contenant une i/age *uelcon*ue. -tiliseW pour cela +n5ouseon duco/posant TI/age.outeW un outon BnnulerB *ui annule le dernier point dessiné et rétalit la couleur initiale.
"n gérant la liste des points dessinés a#ec une pile il doit Htre possile d,annuler le no/re de points désirés en cli*uant autant de fois *ue nécessaire sur le outon BnnulerB.
Solution :00 éclaration de T(or/1 non décrite icitype
-.lass6oint = class
$,y : integer; couleur : -.olor;
end;var
"or#1: -"or#1;
i#ple#entation
JK !*df#L
uses .ontnrs;
var pile : -tac3;
procedure -"or#1*#age1Fouse5o%n'ender: -bject; Cutton: -FouseCutton; &ift: -&ifttate; H, I: nteger);
var p : -.lass6oint;
begin // F#orisation de la position du point et de sa couleur initiale
p := -.ass6oint*.reate; p*$ := $;
p*y := y;
p*couleur := i#age1*6icture*Cit#ap*.anvas*6i$els$,y
8/18/2019 Cours Delphi ASD2
33/45
procedure -"or#1*[email protected]'ender: -bject);
var p : -.lass6oint;begin
// i aucun point dans la pile, il ny a rien à annuler
if pile*.ount = 0 t&en e$it;
// cupration du dernier point dessin et suppression de la pile p := pile*pop; // n re#et la couleur initiale
i#age1*6icture*Cit#ap*.anvas*6i$elsp*$,p*y< := p*couleur;
// libration de la place ##oire du point, devenu inutile p*free;
end;
procedure -"or#1*"or#.lose'ender: -bject; var @ction: -.lose@ction);
begin // "in du progra##e, libration de lespace ##oire rserv à la pile
pile*free;end;
initiali>ation pile := -tac3*.reate;
end*
8/18/2019 Cours Delphi ASD2
34/45
3. )iles
3.1 Représentation
ans le argon infor/ati*ue une file est une liste c)a8née d:élé/ents dont la gestions:apparente G celle d:une Z file d:attente [ D*ueue en nglaisE classi*ue par exe/ple une filede #oitures attendant G un feu rouge pour le passage d:un carrefour. &es élé/ents sont doncreprésentés les uns derri7re les autres le pre/ier arri#é restant le pre/ier de la liste.
1er arri#é 27/e arri#é dernier arri#é
3.2 8estion d9une ile
• &:insertion d:un nou#el élé/ent se fait touours en fin de liste BG la *ueue co//e tout le
/onde XB.
• Pour la consultation des élé/ents de la file on acc7de touours G l:élé/ent arri#é en 1er.
• Pour la suppression de /H/e on suppri/e touours celui arri#é en pre/ier.
insi c:est touours le pre/ier élé/ent arri#é *ui est consulté et suppri/é en pre/ier. +n parle de gestion 8'8/ D(irst In (irst +utE.
3.! 'xemple de ile
estion des t;ches d
8/18/2019 Cours Delphi ASD2
35/45
3.# *%-ets T;ueue
Il existe une classe BT
8/18/2019 Cours Delphi ASD2
36/45
uses contnrs;
var f : -Dueue;
procedure -"or#1*"or#.reate'ender: -bject);begin
tringrid1*.ells0,0< := Eo# du docu#ent; tringrid1*.ells1,0< := -aille du docu#ent; tringrid1*.ells2,0< := 9tat de li#pression; f := -Dueue*.reate;end;
procedure lance#enti#pression;
var doc : -.lass5ocu#ent;begin doc := f*pee3; "or#1*-i#er1*nterval := doc*taille !1000; "or#1*-i#er1*9nabled := true; doc*etat := en cours;
for#1*stringgrid1*cells2,1< := doc*etat;end;
procedure -"or#1*Cutton1.lic3'ender: -bject);var doc : -.lass5ocu#ent;begin
doc := -.lass5ocu#ent*.reate; doc*no# := edit1*-e$t; doc*taille := tr-ont'edit2*te$t); doc*etat := en attente; f*6us&'doc); // @ffic&age dans tringrid
stringgrid1*cells0,f*.ount< := doc*no#;
stringgrid1*.ells1,f*count< := nt-otr'doc*taille); stringgrid1*.ells2,f*count< := doc*etat; // ance#ent de li#pri#ante si pas djà fait if ti#er1*9nabled = false t&en lance#enti#pression;end;
procedure -"or#1*-i#er1-i#er'ender: -bject);var i : integer; doc : -.lass5ocu#ent ;begin // #pression ter#ine
"or#1*-i#er1*9nabled := false; // suppression affic&age
for i:=1 to f*count do begin for#1*stringgrid1*cells0,i< := for#1*stringgrid1*cells0,i+1
8/18/2019 Cours Delphi ASD2
37/45
1
8/18/2019 Cours Delphi ASD2
38/45
1
8/18/2019 Cours Delphi ASD2
39/45
i/ple/entationKR .df/L
#ar l @ T&istQ
function co/pareno/ D p1 p2 @ pointer E @ integerQ 00 co/pareno/ est de type T&istSortCo/pare#ar x y @ TClassPersonneQ
egin x @J p1Q y @J p2Q if x.no/ Y y.no/ t)en co/pareno/ @J 1 else if x.no/ J y.no/ t)en co/pareno/ @J ' else co/pareno/ @J A1QendQ
function co/pareage D p1 p2 @ pointer E @ integerQ 00 co/pareage est de type T&istSortCo/pare#ar x y @ TClassPersonneQ
egin x @J p1Q y @J p2Q if x.age Y y.age t)en co/pareage @J 1 else if x.no/ J y.no/ t)en co/pareage @J '
else co/pareage @J A1QendQ
procedure T(or/1.affic)eQ 00 ffic)e la liste des personnes no/ et _ge dans le T5e/o#ar p @ TClassPersonneQ i @ integerQ
egin /e/o1.ClearQ for i@J' to l.CountA1 do egin p @J l.ite/sNiOQ /e/o1.&ines.ddDp.no/ , , IntToStrDp.ageEEQ endQ
endQ
procedure T(or/1.=utton1Clic;DSender@ T+ectEQ#ar p @ TClasspersonneQ
egin p @J TClassPersonne.CreateQ p.no/ @J edit1.TextQ p.age @J StrToIntDedit2.textEQ l.ddDpEQ affic)eQendQ
procedure T(or/1.=utton2Clic;DSender@ T+ectEQ 00 Tri par no/
egin l.SortDco/pareno/EQ affic)eQendQ
procedure T(or/1.=utton3Clic;DSender@ T+ectEQ 00 Tri par _ge egin l.SortDco/pareageEQ affic)eQendQ
initialiWation l @J T&ist.CreateQ
end.
8/18/2019 Cours Delphi ASD2
40/45
11. $mages
11.1 Structures de données
TI/age @A idt)A )eig)tA it/apA it/ap.can#as.pixelsNxyO @ taleau idi/ensionnel de TColor.
Pour se ra/ener G RV= le /ieux est de définir un taleau tridi/ensionnel de yte. Pour otenir R V = G partir d:un codage sur 32 its DTColorE il faut récupérer c)a*ue octet. &e
plus rapide est d:effectuer des décalages G gauc)e ou G droite pour se déarrasser des octetsnon désirés G l:aide s)l et s)r Ds)ift left et s)ift rig)tE.
for $:=1 to i#1*%idt& do
for y:=1 to i#1*&eig&t do
begin colori#age := i#1*bit#ap*canvas*pi$els$81,y81
8/18/2019 Cours Delphi ASD2
41/45
12. Révision5 synth6se
12.1'xercices de synth6se
0xercice +n consid7re la déclaration sui#ante @const > J 1''Qtype ta J arrayN1..>O of realQ"crire une fonction *ui prend en para/7tres un taleau t de type ta et un seuil s de type realet *ui calcule le no/re d,élé/ents de t stricte/ent supérieurs G s.
0xercice 2+n consid7re les déclarations sui#antes @typeTClass5essage J class
/essage @ stringQ)euredarri#ee @ integerQ 00 expri/ée en secondes
priorite @ integerQ 00 entre ' DfaileE et ! D)auteEendQ#ar & @ T&istQ 00 &iste d,oets de type TClass5essage
( @ T
8/18/2019 Cours Delphi ASD2
42/45
faire de la prospecti#e. >otons G ce suet l,existence en 2''3 d,un appel d,offres C>RS pour financer des proets *ui rentrent dans le cadre des BSyst7/es Co/plexes en Sciencesu/aines et SocialesB D#oir @ )[email protected])erc)e.gou#.fr0rec)erc)e0fns0scs)s.)t/E."xe/ples de proets financés @
• "/ergence et é#olution des syst7/es urains @ un /od7le de si/ulation en fonction des
conditions )istori*ues des interactions spatiales.• "&ICCIR "/ergences de l,Indi#idu au Co/porte/ent Collectif @ Interactions et
Représentations. Dsyst7/es /ultiAagents pour tester la prise de décision locale ou collecti#econcernant le /arc)é du tra#ail et les éc)anges écono/i*uesE.
• yna/i*ue spatioAte/porelle des épidé/ies et réseaux stoc)asti*ues /ultiAéc)elles.
http://www.recherche.gouv.fr/recherche/fns/scshs.htmhttp://www.recherche.gouv.fr/recherche/fns/scshs.htm
8/18/2019 Cours Delphi ASD2
43/45
A>>'?'S @ ($ST' D'S TDTP
1. Petits exercices de rappel
2. -tilisation du Can#as
3. -tilisation du Ti/er
4. Can#as tti/er
!. e sais pas *uoi
6. TInifile
$.
. Piles TStac;
%. (iles TClass&ist
1'. T&istox
11. &istes c)a8nées
12.
8/18/2019 Cours Delphi ASD2
44/45
&icence 5SS 0 SciCo37/e année
4D34! et 2: 0xercices de rappel !ascal > Delphi
&es exercices pourront Htre c)oisis en fonction du ni#eau des étudiants.
1. -tilisation du if t)en else
"crire un progra//e pour ouer G Be#ine le no/reB. &,ordinateur c)oisit un no/re defaMon aléatoire entre ' et %%%% et l,utilisateur tente de le de#iner. Pour cela il tape un no/reet l,ordinateur répond trop grand trop petit ou gagné. &e no/re de coups doit Htre affic)é. #ous de conce#oir l,interface pour *ue le eu soit con#i#ial.Rappel @ pour générer un no/re aléatoire entre ' et x il faut faire un appel G la fonctionrando/DxE. Pour *ue le générateur soit initialisé il faut égale/ent appeler rando/iWe 1 seule
fois en déut de progra//e.
2. -tilisation du for
can#as.ellipse Dx1y1 x2 y2E per/et d,affic)er une ellipse inscrite dans le rectangle définit par les coins opposés Dx1 y1E et Dx2y2E. "crire un progra//e *ui de/ande 2 entiers x et y Gl,utilisateur et *ui affic)e les dessins sui#ants DG #ous de conce#oir l,interface appropriéeE @2.1 x rangées de y cercles de dia/7tre 1' pixels et espacés de 1' pixels."xe/ple x J 2 e y J3 @
2.2 Ide/ a#ec 1 cercle de /oins sur la ligne d,en dessous"xe/ple x J 3 y J 6
2.3 -n triangle rectangle et isoc7le de ronds c,estAGAdire x rangées a#ec x ronds en 17re ligne puis xA1 en 27/e ligne etc. us*u,G 1 rond en derni7re ligne Dy n,est pas utiliséE.
2.4 "xercice difficile G faire en fin de séance @ un carré de ronds Dco//e pour 2.1 a#ec xJyEsauf *u,G l,intérieur du carré il y a un #ide *ui a une for/e circulaire de dia/7tre égal G x
petits ronds. &e dessin n,est intéressant *ue pour de grandes #aleurs de x.
3. -tilisation du )ileReprendre le 2.1 le 2.2 et le 2.3 en é#itant d,utiliser la oucle for.
8/18/2019 Cours Delphi ASD2
45/45
4. "crire un progra//e *ui de/ande G l,utilisateur un entier n et *ui calcule nX.4.1 #ec un for 4.2 #ec un )ile4.3 "n utilisant la récursi#ité
!. Créer une application a#ec les caractéristi*ues sui#antes @A une fic)e standard de type T(or/ *ui prend tout l,écranA un lael dans le*uel est écrit ,"#ident /on c)er ]atson,A 3 outons per/ettant de c)anger la police du texte du lael en ti/es ne ro/an courier ouarial.A 1 o8te G coc)er TC)ec;ox per/ettant de rendre le lael #isile si elle est coc)ée etin#isile si elle est décoc)ée.A 1 o8te d,édition T"dit et 1 outon per/ettant d,auster la taille de la police du lael enfonction de la #aleur rentrée dans le T"dit.A 1 o8te d,édition T"dit et 1 outon per/ettant de /odifier la position #erticale du lael sur lafic)e en fonction de la #aleur rentrée dans le T"dit.
A 1 outon per/ettant de rendre le outon précédent inactif Dien *ue touours #isileE.
6. Créer une application a#ec les caractéristi*ues sui#antes @A une fic)e standard de type T(or/ *ui prend tout l,écran et de couleur leueA un lael sur le*uel il y a écrit ,#euilleW patienter 3 /inutes,A un outon aune sur le*uel il y a écrit en rouge ,annulation attente,A si l,utilisateur déplace la souris auAdessus du outon Da#ant /H/e de cli*uerE ce dernier se
positionne aussitt auAdessus de la souris co//e si le outon #oulait éc)apper G l,utilisateur Si le outon arri#e en )aut de la fic)e déplacer le outon tout en as de la fic)e. D-tiliserl,é#éne/ent +n5ouse5o#eE.