Centre Informatique pour les Lettres

et les Sciences Humaines

Apprendre C++ avec Qt : Leon 3
Fonctions sans paramtres
1 - Utilisation de fonctions....................................................................................................... 2
o!r"!oi les pro#rammes sont-ils constit!$s de fonctions %............................................ 2
&$clenc'ement de l(e)$c!tion d(!ne fonction................................................................... 2
*otions d(effet et de r$s!ltat ........................................................................................... 2
+,pe d(!ne fonction......................................................................................................... 3
2 - &$finition de fonctions........................................................................................................ 3
3 - Le corps d(!ne fonction....................................................................................................... 3
&$finition de varia-les . l(int$rie!r d(!n -loc................................................................... /
L(op$rate!r d(affectation.................................................................................................. /
0p$rate!rs arit'm$ti"!es $l$mentaires........................................................................... 1
2et!rn............................................................................................................................ 1
/ - ro-lmes de comm!nication entre fonctions...................................................................... 3
Les varia-les de la fonction appel$e sont inaccessi-les . la fonction appelante................ 3
Les varia-les de la fonction appelante sont inaccessi-les . la fonction appel$e................ 3
L('omon,mie entre varia-les est sans incidence s!r le fonctionnement d! pro#ramme.... 3
1 - Fonctions mem-re.............................................................................................................. 4
Appeler !ne fonction mem-re.......................................................................................... 4
A#ir s!r !ne instance d$si#n$e e)plicitement..........................................................4
*e pas d$si#ner e)plicitement l(instance s!r la"!elle on a#it...................................5
&$finir !ne classe a,ant des fonctions mem-re............................................................... 6
&$finir !ne fonction mem-re d(!ne classe....................................................................... 6
Fonctions mem-re constantes....................................................................................... 17
3 - 8on9 c(est #entil to!t a9 mais a fait d$:. 6 pa#es. Q!(est-ce "!e :e dois vraiment en
retenir %............................................................................................................................ 17
&oc!ment d! 24;71;73 - 2etro!ve< la version la pl!s r$cente s!r 'ttp:;;===.!p.!niv-mrs.fr;=cpp
C++ - Leon 3 Fonctions sans paramtres 2 ; 17
*o!s avons v! "!e le lan#a#e C++ or#anise le code en sections appel$es fonctions. &e pl!s9 no!s
venons de voir "!e la cr$ation d(!ne classe ne prenait to!t son sens "!e dans la mes!re o> cette
classe comporte des fonctions mem-re9 "!i permettent d(a#ir directement s!r les instances de cette
classe9 sans avoir . acc$der e)plicitement a!) varia-les mem-re. ?l est donc clair "!e no!s ne
po!vons #!re aller pl!s loin dans notre $t!de d! lan#a#e sans no!s penc'er s$rie!sement s!r la
notion de fonction9 et comme les fonctions d$crivent les traitements devant @tre effect!$s9 il no!s
fa!dra a! passa#e introd!ire "!el"!es-!ns des op$rate!rs permettant cette description.
1 - Utilisation de fonctions
L(!tilisation de fonctions n(est pas !ne option po!r no!s : c(est ainsi "!e C++ or#anise le code9 et il
va no!s falloir d$finir des fonctions o! a-andonner ce lan#a#e. ?l est cependant int$ressant de
comprendre po!r"!oi les concepte!rs de -ea!co!p de lan#a#es de pro#rammation ont adopt$ cette
or#anisation. ?l est en o!tre pl!s facile de comprendre comment on d$finit des fonctions si on a d$:.
!ne id$e de comment !n pro#ramme pe!t , faire appel.
o!r"!oi les pro#rammes sont-ils constit!$s de fonctions %
?l , a de!) ar#!ments ma:e!rs en fave!r d! d$co!pa#e des pro#rammes en fonctions :
1A &ans !n pro#ramme9 il est fr$"!ent "!e le m@me traitement doive @tre appli"!$ . pl!sie!rs
ensem-les de donn$es diff$rents. l!s ce traitement est comple)e9 pl!s il est avanta#e!) de
n($crire "!(!ne se!le fois le code correspondant et de l!i confier s!ccessivement les diff$rents
ensem-les de donn$es. La notion de fonction est !ne concr$tisation directe de cette approc'e.
2A Le d$co!pa#e d! pro#ramme en !nit$s po!vant @tre Bdans !ne certaine mes!reA e)$c!t$es
isol$ment permet d(envisa#er la cr$ation de c'ac!ne d(entre elles comme !n pro:et a!tonome9 "!e
sa taille restreinte rend pl!s facile . maCtriser. Q!and to!s les morcea!) sont pr@ts9 il n(, a pl!s
"!(. les r$!nir9 et9 id$alement9 le pro#ramme est termin$.
&$clenc'ement de l(e)$c!tion d(!ne fonction
C'a"!e fonction porte !n nom9 ce "!i permet a!) a!tres fonctions de la d$si#ner. o!r appeler !ne
fonction Bc(est . dire en d$clenc'er l(e)$c!tionA9 il fa!t faire s!ivre son nom d(!n co!ple de
parent'ses. Ainsi9 s(il e)iste !ne fonction nomm$e maFonction9 la li#ne de code s!ivante indi"!e
"!(il est temps d(e)$c!ter les instr!ctions "!i la composent :
maFonction(); //exemple d'appel d'une fonction
Di !ne fonction n(est e)$c!t$e "!e lors"!(!ne a!tre fonction l(appelle9 "!i commence % ?l e)iste !ne
fonction nomm$e main()9 "!i sert de Epoint d(entr$eE a! pro#ramme et . partir de la"!elle to!tes
les a!tres sont appel$es Bdirectement o! indirectementA.
&! point de v!e de l(ordre d(e)$c!tion des instr!ctions d! pro#ramme9 l(appel d(!ne fonction
ressem-le . l(appel d(!ne note de -as de pa#e dans !n te)te en franais : le disco!rs principal est
s!spend!
1
9 le te)te de la note est l!9 p!is la lect!re d! te)te principal reprend Bce "!i n$cessite de
resta!rer mentalement le conte)te "!i permet la compr$'ension de la p'rase interromp!e par l(appel
de noteA. A la diff$rence d(!ne note de -as de pa#e9 "!i n(est 'a-it!ellement appel$e "!(en !n se!l
point d! te)te9 la m@me fonction est so!vent appel$e pl!sie!rs fois
1
dans !n m@me pro#ramme.
*otions d(effet et de r$s!ltat
L(e)$c!tion d! code conten! dans la fonction appel$e pe!t avoir po!r effet de modifier l($tat de
certains o-:ets "!i e)istaient avant et contin!ent . e)ister aprs cette e)$c!tion. Di c(est le cas9 cet
effet pe!t9 . l!i se!l9 :!stifier "!e la fonction e)iste et soit appel$e.
Appeler !ne fonction en v!e d(o-tenir son effet9 c(est !n pe! comme mettre en ro!te !n appareil
"!i effect!e !ne certaine tFc'e et s(arr@te de l!i-m@me lors"!(il a fini.
L(e)$c!tion d(!ne fonction pe!t a!ssi cond!ire . !n r$s!ltat9 c(est . dire . !ne vale!r dont le calc!l
est la principale raison d(@tre de la fonction. &ans ce cas9 la fonction pe!t renvoyer la vale!r en
"!estion9 et l(appel de la fonction s(accompa#ne #$n$ralement d(indications s!r ce "!(il convient de
1 Go!s vene< d(e)$c!ter l(appel de note de -as de pa#e. Go!s alle< lire la pr$sente note9 p!is reprendre la lect!re d! te)te
principal . l(endroit o> vo!s l(ave< interromp!.
J-L Pris - 27/01/06
C++ - Leon 3 Fonctions sans paramtres 3 ; 17
faire avec la vale!r "!(elle va renvo,er. 0n po!rra9 par e)emple9 !tiliser la vale!r renvo,$e par la
fonction po!r initialiser !ne varia-le :
int unEntier = maFonction();//appel d'une fonction et utilisation du rsultat
Appeler !ne fonction en v!e d(o-tenir son r$s!ltat9 c(est !n pe! l!i poser implicitement !ne
"!estion. La vale!r "!(elle renvoie correspond . sa r$ponse.
Une fonction pe!t avoir o! non !n effet. Hlle pe!t9 par aille!rs9 prod!ire o! non !n r$s!ltat. BIais
!ne fonction sans effet ne prod!isant pas de r$s!ltat serait d(!n int$r@t asse< do!te!).A
Lors"!(!ne fonction "!i renvoie !n r$s!ltat prod!it a!ssi !n effet9 il pe!t arriver "!(elle soit e)$c!t$e
!ni"!ement en v!e d(o-tenir cet effet. La fonction appelante i#nore alors simplement la vale!r
renvo,$e par la fonction appel$e :
double unDouble = fonctionRenvoyantnDouble(); //appel !complet!
fonctionRenvoyantnDouble(); //appel i"norant la valeur renvoye
+,pe d(!ne fonction
ar convention9
Le t,pe de la vale!r renvo,$e par !ne fonction est ce "!(on appelle le t,pe de cette fonction.
Appli"!er la notion de t,pe . !ne fonction est !ne p!re m$tap'ore : il ne s(a#it $videmment pas de
sp$cifier le format !tilis$ po!r repr$senter la fonction en m$moire9 et encore moins d(indi"!er
"!elles op$rations pe!vent @tre effect!$es s!r cette fonction.
Lors"!(!ne fonction est d$po!rv!e de r$s!ltat9 elle est de t,pe void.
Le t,pe void Bvide9 en an#laisA est !n t,pe sp$cial9 "!i n(est !tilis$ "!e po!r les fonctions "!i9
:!stement9 ne renvoient rien. L(id$e m@me d(!ne varia-le de t,pe void serait a-s!rde : la se!le
raison :!stifiant la cr$ation d(!ne varia-le est le -esoin d(, stocJer !ne information.
2 - &$finition de fonctions
La d$finition d(!ne fonction repose s!r la m@me lo#i"!e "!e celle d(!ne varia-le : il s(a#it to!t
d(a-ord d($noncer son t,pe et son nom. o!r !ne fonction9 to!tefois9 ces de!) informations ne
s!ffisent $videmment pas9 et il fa!t , ad:oindre des pr$cisions concernant d(!ne part les donn$es
devant @tre !tilis$es et9 d(a!tre part9 la proc$d!re permettant d(o-tenir le r$s!ltat.
Les donn$es . !tiliser sont transmises . la fonction . l(aide d! m$canisme de passa#e de
paramtres9 "!i se trad!it9 a! nivea! de la d$finition d(!ne fonction9 par la pr$sence d(!n co!ple de
parent'ses plac$ . droite d! nom de la fonction.
C(est entre ces parent'ses "!e prendront place les indications n$cessaires a! passa#e de
paramtres mais no!s n(allons no!s int$resser9 dans !n premier temps9 "!(. des fonctions ne
faisant pas intervenir ce m$canisme.
La proc$d!re . !tiliser est9 elle9 -ien $videmment d$crite par !ne s!ite d(instr!ctions. Ces
instr!ctions sont plac$es entre accolades9 ce "!i a po!r effet de former !n -loc d(instr!ctions. Ce
-loc est appel$ le corps de la fonction.
La d$finition d(!ne fonction se compose donc a! minim!m de l($nonc$ de son t,pe et de son nom9
s!ivis d(!n co!ple de parent'ses9 p!is d(!n co!ple d(accolades. Les li#nes s!ivantes d$finissent de
faon parfaitement correcte !ne fonction C++ Bd(int$r@t trs disc!ta-le9 avo!ons-le9 p!is"!e l(a-sence
de to!te instr!ction dans son corps la prive a!ssi -ien d(effet "!e de r$s!ltatA :
void maFonction( ) //la fonction #$$ minimale
%
& //remar'ue( l'absence de point)vir"ule
3 - Le corps d(!ne fonction
o!r aller a!-del. de la fonction C++ minimale d$finie ci-dess!s9 il no!s fa!t @tre capa-les d(ins$rer
!n pe! de code dans le corps de la fonction.
J-L Pris - 27/01/06
1
2
1
2
3
C++ - Leon 3 Fonctions sans paramtres / ; 17
&$finition de varia-les . l(int$rie!r d(!n -loc
Le code d$crivant les traitements "!e doit effect!er !ne fonction est9 no!s l(avons v!9 plac$ entre
accolades9 ce "!i en fait !n -loc. Ce -loc pe!t comporter des d$finitions de varia-les.
Une varia-le dont la d$finition se sit!e dans !n -loc de code est locale . ce -loc9 c(est . dire "!(elle
n(est consid$r$e comme d$finie "!(. l(int$rie!r d! -loc.
Hn d(a!tres termes9 si des varia-les sont d$finies dans le corps d(!ne fonction9 il s(a#it de varia-les
appartenant en propre . cette fonction9 et a!c!ne a!tre fonction ne pe!t , acc$der. Les varia-les
locales . !ne fonction ont vocation . @tre !tilis$es9 lors des traitements effect!$s par la fonction9
po!r stocJer des r$s!ltats interm$diaires. Ces varia-les ne sont9 en #$n$ral9 "!e des varia-les
temporaires9 "!i cessent d(e)ister lors"!e l(e)$c!tion de la fonction s(ac've.
Lors"!(!ne varia-le cesse d(e)ister9 la <one de m$moire "!e son nom d$si#nait est consid$r$e
comme disponi-le po!r d(a!tres !sa#es. Les varia-les d$finies dans !n -loc sont donc recr$$es et
r$initialis$es c'a"!e fois "!e le -loc en "!estion est e)$c!t$.
L(op$rate!r d(affectation
*o!s savons d$:.9 #rFce . l(initialisation9 attri-!er !ne vale!r . !ne varia-le a! moment o> elle est
d$finie. ?l est $videmment possi-le d(attri-!er !ne vale!r . !ne varia-le aprs "!(elle a $t$ d$finie. ?l
s!ffit po!r cela d(!tiliser l(op$rate!r d(affectation9 repr$sent$ par le si#ne =.
bool il*leut = false; //dfinition et initialisation
il*leut = true ; //affectation
Le fait "!e l(affectation est repr$sent$e par !n s,m-ole "!i pe!t a!ssi @tre !tilis$ po!r l(initialisation
ne doit pas vo!s laisser croire "!(il s(a#it d(!ne se!le et m@me op$ration. Une constante9 par
e)emple9 &0?+ @tre initialis$e mais *H HU+ AD s!-ir d(affectation.
const double *+ = ,-./; //01 2 initialisation
*+ = ,-./.3; //ERRER 2 tentative de modification d'une constante 4
Lors"!(!ne e)pression impli"!ant !ne affectation est $val!$e9 les e)pressions sit!$es de part et
d(a!tre d! si#ne $#al sont d(a-ord $val!$es ind$pendamment l(!ne de l(a!tre. Le r$s!ltat de #a!c'e
doit d$si#ner !ne <one de m$moire poss$dant !n t,pe. Le r$s!ltat de droite est alors repr$sent$
conform$ment a!) r#les de ce t,pe9 p!is ran#$ dans la <one m$moire d$si#n$e.
Lors"!e l(e)pression de #a!c'e est le nom d(!ne varia-le9 le se!l pro-lme est la repr$sentation de
la vale!r de l(e)pression de droite dans le t,pe de cette varia-le. Hn cas d(impossi-ilit$9 le
compilate!r si#nalera !ne incompati-ilit$ de t,pes :
il*leut = 5-6; //*R078E9E 2 la valeur ne peut pas :tre
//reprsente dans le type de la variable
Di l(e)pression de #a!c'e est pl!s comple)e9 !n a!tre pro-lme se pose : cette e)pression
d$si#ne-t-elle !n o-:et non constant % Di ce n(est pas le cas9 votre compilate!r protestera en
r$clamant !ne ElvalueE9 c(est . dire "!el"!e c'ose po!vant fi#!rer . #a!c'e de l(op$rate!r
d(affectation B#a!c'e se dit left en an#lais9 d(o> le l initial de lvalueA.
5-6 = ,; //*R078E9E 2 lvalue re'uired 4
L($val!ation d(!ne e)pression comportant !n op$rate!r d(affectation a donc !n effet9 le c'an#ement
de vale!r de la varia-le concern$e9 "!i est en #$n$ral la se!le raison d(@tre de l(e)pression. ?l arrive
parfois "!(on !tilise a!ssi la vale!r d(!ne affectation9 "!i est identi"!e . celle re!e par la varia-le
affect$e. Ainsi9 dans
int x;
int y = x = /;
la li#ne 2 est anal,s$e comme ordonnant d(initialiser y avec la vale!r de l(e)pression d(affectation9
c(est . dire / Ben vert! de la r#le "!e no!s venons d($noncerA. A! passa#e9 l($val!ation de
l(e)pression x = / a9 -ien entend!9 po!r effet d(attri-!er a!ssi cette vale!r . la varia-le x.
J-L Pris - 27/01/06
1
2
3
4
1
2
C++ - Leon 3 Fonctions sans paramtres 1 ; 17
0p$rate!rs arit'm$ti"!es $l$mentaires
Les op$rate!rs d(addition9 so!straction9 m!ltiplication et division sont respectivement not$es $9 )9 ;
et /. L($val!ation de l(e)pression , $ / donne donc9 par e)emple9 le r$s!ltat 4.
Lors"!(!n nom de varia-le intervient dans !ne e)pression arit'm$ti"!e9 c(est la vale!r act!elle de
la varia-le "!i est !tilis$e po!r $val!er l(e)pression.
Lors"!(!n appel de fonction intervient dans !ne e)pression arit'm$ti"!e9 c(est la vale!r renvo,$e
par la fonction "!i est !tilis$e po!r $val!er l(e)pression.
Lors"!(il est appli"!$ . des op$randes de t,pe entier9 l(op$rate!r / prod!it le r$s!ltat de la division
entire. Le reste d(!ne telle division pe!t @tre o-ten! . l(aide de l(op$rate!r mod!lo9 not$ < :
= / 5; //cette expression a pour valeur 5
= < 5; //cette expression a pour valeur .
L($val!ation d(!ne e)pression arit'm$ti"!e cond!it . !n r$s!ltat mais reste9 sa!f cas partic!liers9
sans effet. Ainsi9 a!c!ne varia-le ne se tro!vant modifi$e9 les r$s!ltats o-ten!s lors d(!ne $vent!elle
e)$c!tion des de!) li#nes de code ci-dess!s cesseront d(@tre disponi-le ds l($val!ation de
l(e)pression s!ivante9 et a!ront donc $t$ calc!l$s en p!re perte. &ans la pl!part des cas9 vo!s
!tilisere< donc les e)pressions arit'm$ti"!es en tant "!(e)pression de droite dans !ne affectation.
double coteDu#arre = ,-6=;
double perimetre = >;
double surface = >;
//exemples de calculs lmentaires
perimetre = / ; coteDu#arre;
surface = coteDu#arre ; coteDu#arre;
Lors"!e la m@me li#ne de code e)i#e !n calc!l et l(affectation d! r$s!ltat . !ne varia-le9 le calc!l
est effect!$ ind$pendamment d! t,pe de la varia-le dans la"!elle le r$s!ltat va ens!ite @tre
transf$r$. Le t,pe !tilis$ po!r repr$senter le r$s!ltat d! calc!l ne d$pend donc pas de cel!i de la
varia-le "!i va @tre affect$e9 mais se!lement de cel!i des op$randes . Ainsi9 lors de
double x = = / 5; //?R*R+?E 2 x contient maintenant 5
le r$s!ltat de la division BentireA est repr$sent$ so!s forme d$cimale po!r @tre stocJ$ dans )9 mais
le t,pe de cette varia-le ne cond!it pas . refaire le calc!l avec !ne division d$cimale. Di c(est cette
op$ration "!i est so!'ait$e9 il fa!t "!(a! moins l(!n des op$randes soit d$cimal :
double y = = / 5->; //y contient maintenant 5-=
2et!rn
Lors"!(!ne fonction prod!it !n r$s!ltat9 elle s(ac've en Erenvo,antE le r$s!ltat en "!estion . l(aide
d(!ne instr!ction sp$ciale9 return.
int maFonction()//une fonction #$$ produisant un rsultat de type int
%
return .5; //.5 est une valeur convenable pour un int
&
La fonction d$finie ci-dess!s est d(!n int$r@t prati"!e a-sol!ment n!l9 p!is"!e son e)$c!tion ne
prod!ira "!(!ne vale!r imm!a-le et parfaitement pr$visi-le. &ans ces conditions9 $crire
int unEntier = maFonction();
n(est "!(!ne faon perverse d(o-tenir ce "!i po!rrait @tre directement o-ten! par
int unEntier = .5;
&ans !n pro#ramme r$el9 !ne fonction effect!e #$n$ralement des traitements "!i font de son appel
!ne op$ration int$ressante.
Lors"!(!ne fonction ne prod!it a!c!n r$s!ltat9 elle s(ac've soit par la fin d! -loc d(instr!ctions9
soit par !ne instr!ction return d$po!rv!e de vale!r. La d$finition s!ivante est $"!ivalente . celle
propos$e pl!s 'a!t po!r !ne fonction C++ minimale :
J-L Pris - 27/01/06
1
2
3
4
5
1
2
3
4
C++ - Leon 3 Fonctions sans paramtres 3 ; 17
void maFonction() //void@ puis'u'elle ne produit aucun rsultat
%
return; //cette instruction est facultative car@ de toute faAon@
& //cette accolade mar'ue la fin de la fonction
/ - ro-lmes de comm!nication entre fonctions
Les mo,ens de comm!nication entre fonctions dont no!s disposons po!r l(instant sont e)tr@mement
r$d!its9 p!is"!(ils se r$s!ment . la possi-ilit$ "!(a !ne fonction appel$e de renvo,er !n r$s!ltat . la
fonction appelante. Les e)emples s!ivants ont pr$cis$ment po!r o-:ectif d(ill!strer ces limitations en
essa,ant BvainementA de les conto!rner.
Les varia-les de la fonction appel$e sont inaccessi-les . la fonction appelante
?ma#inons "!e no!s avons . manip!ler des rectan#les9 et "!e le!r s!rface no!s pr$occ!pe
partic!lirement. ?l est facile d($crire !ne fonction calc!lant la s!rface d(!n rectan#le :
double calcule?urface()
%
double lar"eur = /;
double lon"ueur = ,;
return lar"eur ; lon"ueur;
&
0n pe!t9 certes9 appeler cette fonction . partir d(!ne a!tre :
void maFonction()
%
double surfaceDuRectan"le = calcule?urface();
&
Iais9 dans l($tat act!el des c'oses9 cet appel n(est "!(!ne faon compli"!$e d(o-tenir !n $tat "!i
po!rrait pl!s simplement @tre atteint par
double surfaceDuRectan"le = .5;
?l n(est en effet pas possi-le . maFonction() d(indi"!er . calcule?urface() les dimensions d!
rectan#le "!i l(int$resse9 p!is"!(elle n(a pas accs a!) varia-les lar"eur et lon"ueur B"!i sont
locales . calcule?urface()A.
Les varia-les de la fonction appelante sont inaccessi-les . la fonction appel$e
?l serait vain d(essa,er de r$so!dre ce pro-lme en d$finissant les varia-les lar"eur et lon"ueur
dans maFonction() pl!tKt "!e dans calcule?urface() :
void maFonction()
%
double lar"eur = =;
double lon"ueur = 3;
double surfaceDuRectan"le = calcule?urface(); //appel de l'autre fonction
&
double calcule?urface()
%
return lar"eur ; lon"ueur; //+9*0??+78E 2 lar"eur et lon"ueur n'existent pas ici 4
&
Les varia-les lar"eur et lon"ueur sont maintenant locales . maFonction(). La fonction
calcule?urface() ne pe!t donc pas les !tiliser Bli#ne 9A po!r faire son calc!l.
L('omon,mie entre varia-les est sans incidence s!r le fonctionnement d! pro#ramme
?l n(est pas non pl!s possi-le de faire comm!ni"!er les de!) fonctions en les dotant de varia-les
portant le m@me nom :
J-L Pris - 27/01/06
1
2
3
4
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
C++ - Leon 3 Fonctions sans paramtres 4 ; 17
double calcule?urface()
%
double lar"eur;
double lon"ueur;
return lar"eur ; lon"ueur;
&
void maFonction()
%
double lar"eur = /;
double lon"ueur = ,;
double surfaceDuRectan"le = calcule?urface(); //appel de l'autre fonction
&
Les de!) fonctions possdent maintenant c'ac!ne !n :e! de varia-les nomm$es lar"eur et
lon"ueur. Ces rapports d('omon,mie ne cr$ent a!c!n lien partic!lier entre les varia-les9 et les
vale!rs stocJ$es dans les varia-les locales . maFonction() ne sont $videmment pas disponi-les
Bpar ma#ie %A dans les varia-les locales . calcule?urface(). Cette dernire procde donc Bli#ne 5A
. la m!ltiplication de de!) vale!rs dont no!s i#norons to!t Bp!is"!e les varia-les !tilis$es n(ont
pas $t$ initialis$esA. Le r$s!ltat "!(elle renvoie Bli#ne 6A et "!e rec!eille Bli#ne 1A maFonction()
n(est donc sans do!te pas la s!rface rec'erc'$e...
*o!s devons donc concl!re "!e
La localit$ des varia-les d(!ne fonction s(oppose . le!r !tilisation po!r $ta-lir !n transfert
d(information entre fonctions.
Le passa#e de paramtres permet !ne comm!nication entre fonction appelante et fonction appel$e9
mais9 avant d($t!dier cette tec'ni"!e BLeon 1A9 no!s allons voir "!e9 lors"!e la fonction appel$e est
mem-re d(!ne classe9 elle dispose d(!n a!tre mo,en de comm!nication : elle pe!t acc$der .
certaines varia-les "!i ne l!i appartiennent pas.
1 - Fonctions mem-re
Le cas des fonctions mem-re pr$sente "!el"!es partic!larit$s s,nta)i"!es9 et il fa!t donc "!e no!s
apprenions d(!ne part . d$finir des classes comportant des fonctions mem-re9 et d(a!tre part .
d$finir des fonctions "!i sont mem-res d(!ne classe.
A!-del. de ces d$tails s,nta)i"!es9 la diff$rence essentielle entre !ne fonction mem-re et !ne
fonction "!i n(appartient . a!c!ne classe r$side dans la faon dont les fonctions mem-re sont
appel$es. C(est donc par ce point "!e no!s allons d$-!ter notre $t!de des fonctions mem-re.
Appeler !ne fonction mem-re
La n$cessit$ des fonctions mem-re s(est impos$e . no!s9 . la fin de la Leon 29 parce "!e !Pour que
"es or"res puissent #tre appliqus "irectement $ "es varia%les "ont le type est une classe& il faut que
la "finition "e cette classe in"ique comment ces or"res "oivent #tre e'cuts(!
La raison d(@tre d(!ne fonction mem-re est donc d(a#ir s!r !ne instance. Iais la"!elle %
La d$si#nation de l(o-:et Eci-leE de l(e)$c!tion d(!ne fonction mem-re pe!t9 selon les circonstances9
@tre e)plicite o! rester implicite. Le premier cas correspond . la sit!ation o! !ne fonction a en sa
possession !ne instance et so!'aite l!i appli"!er le traitement effect!$ par !ne fonction mem-re. Le
second correspond . la sit!ation o! !ne fonction mem-re a $t$ appel$e po!r a#ir s!r !ne instance et
so!'aite elle-m@me faire appel . !ne de ses coll#!es po!r a#ir s!r la m@me instance.
A#ir s!r !ne instance d$si#n$e e)plicitement
?ma#inons "!(il e)iste !ne classe nomm$e #Rectan"le et "!e cette classe comporte non se!lement
de!) varia-les mem-res nomm$es lon"ueur et lar"eur9 mais a!ssi !ne fonction mem-re nomm$e
calcule?urface() renvo,ant le prod!it des de!) varia-les mem-re.
?ma#inons $#alement "!(!ne fonction "!elcon"!e dispose de de!) varia-les locales de t,pe
#Rectan"le9 o-:ets a!)"!elles a!raient $t$ conf$r$es des dimensions :
J-L Pris - 27/01/06
1
2
3
4
5
6
7
8
9
10
11
12
C++ - Leon 3 Fonctions sans paramtres 5 ; 17
#Rectan"le salon;
salon-lar"eur = /;
salon-lon"ueur = =-3;
#Rectan"le cuisine;
cuisine-lar"eur = ,;
cuisine-lon"ueur = ,;
o!r donner !ne lar#e!r B2 et 5A o! !ne lon#!e!r B3 et 6A . !n #Rectan"le9 il est $videmment
n$cessaire de pr$ciser s!r "!el o-:et on a#it. Cette indication est donn$e en s$lectionnant le mem-re
concern$ de l(!ne des instances disponi-les.
o!r calc!ler !ne s!rface en !tilisant la fonction mem-re pr$v!e . cet effet9 il est $#alement
n$cessaire d(indi"!er s!r "!el #Rectan"le doit porter le calc!l. Cette indication est donn$e en
appelant la fonction mem-re a! titre de l(instance concern$e :
double surfaceBotale = salon-calcule?urface() $ cuisine-calcule?urface();
Les op$rate!rs de s$lection permettent d(appeler !ne fonction mem-re d(!ne classe a! titre d(!ne
instance de la classe en "!estion9 ce "!i d$si#ne cette instance comme $tant l(o-:et s!r le"!el doit
a#ir la fonction a! co!rs de l(e)$c!tion d$clenc'$e par cet appel.
Lors des de!) e)$c!tions s!ccessives d$clenc'$es par l(e)$c!tion de la li#ne 79 la fonction
calcule?urface()ne travaillera donc pas s!r le m@me rectan#le. 2emar"!e< "!e9 . la diff$rence
de la sit!ation e)plor$e pa#es 39 la fonction appelante pe!t ici fi)er elle-m@me les dimensions d!
rectan#le s!r le"!el calcule?urface() va op$rer. Les varia-les mem-re permettent donc !n
transfert d(information de l(appelant vers la fonction mem-re appel$e
2
.
*e pas d$si#ner e)plicitement l(instance s!r la"!elle on a#it
Les instr!ctions plac$es dans le corps de la fonction calcule?urface() vont donc devoir acc$der
tantKt a!) mem-res de la varia-le salon9 tantKt a!) mem-res de la varia-le cuisine9 sans parler de
to!s les a!tres #Rectan"le a! titre des"!els la fonction est s!scepti-le d(@tre appel$e. ?l est donc
totalement impossi-le "!e ces instr!ctions mentionnent le nom de l(instance concern$e B"!i n(est
pas to!:o!rs le m@me9 et a!"!el elles n(ont de to!te faon pas accs p!is"!(il s(a#it d(!ne varia-le
appartenant . la fonction appelanteA.
o!r conto!rner cette diffic!lt$9 les fonctions mem-re reoivent9 lors de c'a"!e e)$c!tion9 l(adresse
de l(instance a! titre de la"!elle elles sont appel$es9 et cette adresse est implicitement !tilis$e
lors"!e le code pr$sent dans le corps de la fonction mentionne le nom d(!n mem-re sans pr$ciser
"!elle est l(instance concern$e. Ainsi9 si l(instr!ction
return lon"ueur ; lar"eur;
fi#!re dans la fonction calcule?urface()9 elle donnera lie! a! calc!l de
(Csalon))Dlon"ueur ; (Csalon))Dlar"eur
lors"!e la fonction est appel$e a! titre de l(instance salon9 mais a! calc!l de
(Ccuisine))Dlon"ueur ; (Ccuisine))Dlar"eur
lors"!e la fonction est appel$e a! titre de l(instance cuisine.
Lors"!(!ne fonction mem-re mentionne le nom d(!n a!tre mem-re de la m@me classe sans dire de
"!elle instance elle parle9 elle accde implicitement . l(instance a! titre de la"!elle elle est en train
d(@tre e)$c!t$e.
Cette r#le s(appli"!e indiff$remment9 "!(il s(a#isse d(acc$der . !ne varia-le mem-re o! d(appeler
!ne a!tre fonction mem-re. Hn revanc'e9 de par sa nat!re m@me9 cette r#le ne concerne "!e le
code fi#!rant dans !ne fonction mem-re. Les fonctions "!i ne sont pas mem-re d(!ne classe ne
pe!vent acc$der . !n mem-re de celle-ci "!(en sp$cifiant e)plicitement l(instance vis$e.
2 &ans la mes!re o> les fonctions mem-re pe!vent modifier les varia-les mem-re de l(instance a! titre de la"!elle elles sont
appel$es9 il est a!ssi possi-le d(!tiliser ces varia-les po!r effect!er !n renvoi d(information vers la fonction appelante.
J-L Pris - 27/01/06
1
2
3
4
5
6
7
C++ - Leon 3 Fonctions sans paramtres 6 ; 17
&$finir !ne classe a,ant des fonctions mem-re
o!r incl!re !ne fonction mem-re dans la d$finition d(!ne classe9 il s!ffit d(, indi"!er son t,pe9 son
nom et la liste de ses paramtres. Htant donn$ "!e9 po!r l(instant9 no!s n(!tilisons pas le passa#e de
paramtres9 les parent'ses ento!rant cette liste restent vides.
*(o!-lie< pas ces parent'ses9 car9 comme l(ill!stre l(e)emple ci-desso!s9 elles se!les permettent
de faire la diff$rence entre !ne varia-le mem-re et !ne fonction mem-re.
class #Rectan"le //une classe comportant une fonction membre
%
public2
double lar"eur; //dclaration d'une variable membre
double lon"ueur; //dclaration d'une autre variable membre
double calcule?urface(); //dclaration d'une fonction membre
&;
Comme no!s l(avons v! a! co!rs d! +& 29 les classes sont 'a-it!ellement d$finies dans des fic'iers
portant l(e)tension .'. Cette d$finition est essentiellement la d$claration de l(ensem-le des mem-res
constit!ant la classe et9 par cons$"!ent9
Un fic'ier .' contient des d$finitions de t,pes et des d$clarations de fonctions et de varia-les.
Les fonctions "!i ne sont mem-res d(a!c!ne classe sont9 elles-a!ssi9 #$n$ralement d$clar$es dans
des fic'iers .' : la Einclusion de ces fic'iers permet de disposer des d$clarations n$cessaires po!r
appeler ces fonctions . partir d(a!tres fonctions d$finies dans diff$rents fic'iers .cpp.
&$finir !ne fonction mem-re d(!ne classe
La d$finition d(!ne fonction mem-re ne diffre en rien de la d$finition d(!ne fonction "!i n(est pas
mem-re d(!ne classe. La se!le c'ose . la"!elle il fa!t prendre #arde est "!e le nom complet de la
fonction incl!t cel!i de la classe9 et "!e c(est ce nom complet "!i doit @tre !tilis$ po!r d$finir la
fonction. Le nom complet est o-ten! simplement en liant le nom de la classe et cel!i de la fonction .
l(aide de l(op$rate!r 229 op$rate!r s!r le"!el no!s a!rons l(occasion de revenir.
double #Rectan"le22calcule?urface() // dfinition d'une fonction membre
%
return lar"eur ; lon"ueur;
&
L(int$r@t des noms complets est asse< facile . comprendre : si notre pro#ramme !tilise $#alement
!ne classe ##ercle "!i comporte9 elle a!ssi9 !ne fonction de calc!l de s!rface9 il sera possi-le de
d$finir !ne fonction cercle22calcule?urface()9 sans po!r a!tant cr$er la moindre am-i#!Lt$.
Cette possi-ilit$ d('omon,mie partielle pr$sente de!) avanta#es : lors"!e les classes sont con!es
de faon coordonn$e9 il est possi-le de d$c'ar#er les pro#ramme!rs "!i les !tiliseront de
l(o-li#ation de m$moriser des noms de fonctions diff$rents po!r des op$rations de m@me nat!re et9
lors"!e les classes sont con!es de faon ind$pendante9 elles ne co!rent pas le ris"!e d(interf$rer
les !nes avec les a!tres . ca!se de coLncidences malencontre!ses dans le c'oi) des noms.
La d$finition d(!ne fonction mem-re prend normalement place dans !n fic'ier .cpp portant le nom
de la classe.
Un fic'ier .cpp contient des d$finition de fonctions9 c(est . dire d! te)te "!e le compilate!r va
trad!ire en code e)$c!ta-le.
Lors"!e le corps de la fonction est trs -ref9 il est possi-le de l(incl!re directement "ans la d$finition
de la classe. &ans notre e)emple9 c'oisir cette option cond!irait . $crire :
class #Rectan"le
%
public2
double lar"eur; //dclaration d'une variable membre
double lon"ueur; //dclaration d'une autre variable membre
double calcule?urface() % return lar"eur ; lon"ueur; & //dfinition 4
&;
J-L Pris - 27/01/06
1
2
3
4
5
6
7
1
2
3
4
1
2
3
4
5
6
7
C++ - Leon 3 Fonctions sans paramtres 17 ; 17
2emar"!e< "!e cette faon de proc$der cond!it9 . titre d$ro#atoire9 . faire fi#!rer la d$finition
d(!ne fonction dans !n fic'ier .'. Di l(aspect #$n$ral de la d$finition de la classe est pe! modifi$ par
la pr$sence d! corps de la fonction9 on adopte #$n$ralement po!r celle-ci !ne pr$sentation en !ne
se!le li#ne9 "!i l!i confre !ne forme "!(il fa!t apprendre . reconnaCtre. 2emar"!e<9 en partic!lier9
"!e l(accolade de fermet!re d! -loc B6A n(est s!ivie d(a!c!n point vir#!le9 . la diff$rence de celle "!i
concl!t B7A la d$finition de la classe.
Fonctions mem-re constantes
Certaines fonctions mem-re ne modifient en a!c!ne faon l($tat de l(instance a! titre de la"!elle
elles sont e)$c!t$es. ?l est possi-le d(annoncer officiellement cette caract$risti"!e de la fonction en
a:o!tant le mot const aprs la liste de ses paramtres :
double calcule?urface() const % return lar"eur ; lon"ueur; &
2endre !ne fonction mem-re constante pr$sente de!) avanta#es principa!) : d(!ne part to!te
instr!ction "!i po!rrait cond!ire . !ne modification de l(o-:et a! titre d!"!el la fonction est
e)$c!t$e provo"!era !ne erre!r de compilation et d(a!tre part9 il devient possi-le d(e)$c!ter la
fonction a! titre d(!ne constante.
3 - 8on9 c(est #entil to!t a9 mais a fait d$:. 6 pa#es. Q!(est-ce "!e :e
dois vraiment en retenir %
1A C'a"!e fonction porte !n nom9 "!i permet de l(appeler.
2A Le passa#e de paramtres permet d(indi"!er . !ne fonction s!r "!elles donn$es elle doit op$rer9
mais on verra a pl!s tard.
3A Un fra#ment de te)te so!rce plac$ entre accolades constit!e !n -loc d(instr!ctions.
/A Les op$rations "!(!ne fonction doit effect!er sont d$crites par !n -loc d(instr!ctions appel$ le
corps de la fonction.
1A Lors"!(!ne fonction est appel$e9 les instr!ctions "!i la d$finissent sont e)$c!t$es avant "!e
l(instr!ction "!i s!it l(appel ne le soit.
3A L(e)$c!tion d(!ne fonction prod!it soit !n effet9 soit !n r$s!ltat9 soit les de!).
4A Le Et,peE d(!ne fonction est le t,pe d! r$s!ltat "!(elle prod!it.
5A Di !ne fonction ne prod!it a!c!n r$s!ltat9 elle est de t,pe void.
6A Une fonction renvoie son r$s!ltat . l(aide de l(instr!ction return.
17A L(affectation d(!ne vale!r . !ne varia-le est o-ten!e . l(aide de l(op$rate!r M.
11A Les op$rations arit'm$ti"!es !s!elles sont not$es comme d('a-it!de.
12A La division de de!) vale!rs de t,pe entier donne to!:o!rs !n r$s!ltat entier.
13A Lors"!e le nom d(!ne varia-le o! l(appel d(!ne fonction fi#!re dans !ne e)pression arit'm$ti"!e9
celle-ci est $val!$e en !tilisant la vale!r co!rante de la varia-le o! le r$s!ltat renvo,$ . l(iss!e de
l(e)$c!tion de la fonction.
1/A Les varia-les d$finies dans !n -loc de code sont locales . ce -loc Bc(est . dire "!(elles ne sont
!tilisa-les "!e par des instr!ctions fi#!rant dans le -loc en "!estionA.
11A Les fonctions mem-re d(!ne classe sont appel$es a! titre d(!ne instance de cette classe.
13A Les fonctions mem-re d(!ne classe accdent implicitement Bc(est . dire sans avoir -esoin de
pr$ciser de nom d(instanceA a!) mem-res de l(instance a! titre de la"!elle elles sont en co!rs
d(e)$c!tion.
14A Les fonctions mem-re constantes ne pe!vent pas modifier l(instance a! titre de la"!elle elles sont
e)$c!t$es.
15A *ormalement9 les fic'iers .cpp contiennent d! te)te "!e le compilate!r va trad!ire en code
e)$c!ta-le9 alors "!e les .' ne contiennent "!e des consi#nes indi"!ant a! compilate!r
comment faire cette trad!ction.
J-L Pris - 27/01/06