copie de secours de chapitre2.doc
TRANSCRIPT
-
8/17/2019 Copie de secours de chapitre2.doc
1/35
Chapitre 2 : Boucles, adresses et pointeurs, fonctions
A) Les 3 boucles en C :
1) Boucle do ... while ... (Répéter .... Tant que) :
1.a) Syntaxe :
do
instruction à répéter
while (condition de continuer à répéter (boucler) encore);
L'instruction à répéter peut être simple (une seule action), structurée (une autre instruction de contrôle) ou composée (c'est le cas le plus fréquent).
1.b) onctionne!ent :
Étape 1 : effectuer (d'abord) l'instruction à répéter
Étape : !érifier (apr"s) la condition de continuer :
a) si la condition est !raie, on re!ient à l'étape 1
b) si non (la condition est fausse), on termine la boucle
Attention :
#ontrairement au lan$a$e %&#&L, la condition de cette boucle
est la condition pour continuer à répéter encore. n %ascal, c'est la condition d'arrêter la boucle.
1.c) "o!aines d#utilisation :
n utilise la boucle do ... *+ile ... quand on ne sait pas à l'a!ance, le nombre de fois qu'on doit répéter le même traitement. Les eemples sui!ants permettent de !oir quelques
Chapitre 2 : Boucles de répétitions et fonctions Page 27
-
8/17/2019 Copie de secours de chapitre2.doc
2/35
applications possibles a!ec cette boucle.
1. Répéter le même traitement en mode conversationnel :
Écrire un bloc d'instructions permettant de saisir l'-$e et le see d'une personne. nsuite, on affic+e un messa$e
du $enre :
#'est un enfant de see masculin
n rép"te le même traitement usqu'à ce que l'usa$er décide de quitter.
olution :
int a$e / c+ar see, reponse / 0 ui ou 2on l'usa$er !eut continuer 0
do 3 printf(45nntre6 le see et l'-$e 4)/
scanf(47c7d4, 8see, 8a$e)/
printf(4#'est un 4)/
if (a$e 9 11) printf(4enfant 4)/ else if (a$e 9 1; ) printf(4adolescent 4) / else printf(4adulte 4)/
if ( toupper(see) '
-
8/17/2019 Copie de secours de chapitre2.doc
3/35
2. Validation de données :
Écrire un bloc d'instructions permettant de saisir et !alider l'-$e d'une personne (un entier situé entre 1 et 1A).
olution :
const int B&CD 1A /
int a$e, !alide / 0 ui ou non l'-$e est !alide 0
do 3 printf(4ntre6 l'-$e entre 1 et 7d 4, B&CD)/
scanf(47d4, 8a$e)/
!alide (a$e E 1 88 a$e 9 B&CD) /
if ( F!alide ) printf(4a$e lu est +ors inter!alle, retape6 .=.%.5n4)/ @ *+ile (F!alide)/
Attention :
La !alidation d'un tGpe (entier ou non, réel ou non) sera présentée au c+apitre H (c+aInes des caract"res).
3. Calcul scientifique :
emple 1 :
Écrire un bloc d'instructions permettant de calculer et d'affic+er la somme sui!ante :
somme 1J K 1A K J K A K ... K AJ
olution :
const int M21 1J ,
M2 AJ , LN%& A /
int terme, somme /
somme J / terme M21 /
Chapitre 2 : Boucles de répétitions et fonctions Page 29
-
8/17/2019 Copie de secours de chapitre2.doc
4/35
do 3 somme K terme / terme K LN%&/ @ *+ile (terme 9 M2)/
printf(4La somme calculée est : 7d5n4, somme)/
emple :
Écrire un pro$ramme permettant d'estimer la !aleur de %D (H.1O1....) selon la formule sui!ante :
%D >>>>> 1 > 10H K 10A > 10P K 10Q K .... 10QQQQ O
olution :
0 si$ne / 0 c+an$er de si$ne 0 denominateur K LN%& / @ *+ile ( denominateur 9 LDBDS ) /
printf(4La !aleur estimée de %D est 71.Tf5n4,O piurO)/
printf(45n&ppuGe6 sur ntrée 4)/ $etc+ar()/ @
écution :
La !aleur estimée de %D est H.1O1HQP
&ppuGe6 sur ntrée
Chapitre 2 : Boucles de répétitions et fonctions Page 30
-
8/17/2019 Copie de secours de chapitre2.doc
5/35
Attention :
n utilise sou!ent cette boucle pour estimer une racine de l'équation f() J, pour la rec+erc+e séquentielle d'un élément dans un tableau (plus tard dans le cours), etc ....
1.d) $xercices :
ercice 1 :
Écrire un pro$ramme permettant de saisir et de !alider si un entier lu est positif ou non. nsuite, on affic+e l'entier tel que lu et à l'en!ers (ici OHP).
olution :
0
-
8/17/2019 Copie de secours de chapitre2.doc
6/35
écution :
ntre6 un entier positif >;PO n >;PO est né$atif ntre6 un entier positif AHQ L'entier lu : AHQ & l'en!ers : QHA
&ppuGe6 sur ntrée
ercice :
Écrire un pro$ramme permettant de saisir un entier positif (eemple AOT). Dl calcule l'en!ers du nombre lu (ici TOA) et affic+e ces deu !aleurs.
olution :
0
-
8/17/2019 Copie de secours de chapitre2.doc
7/35
écution :
ntre6 un entier positif 1HO L'entier lu n 1HO & l'en!ers : OH1
&ppuGe6 sur ntrée
ercice H :
Écrire un pro$ramme permettant de saisir les informations d'un placement :
> le capital (un réel) > le tau d'intérêt (composé) annuel en 7 > la durée du placement en nombre de mois.
Le pro$ramme calcule et affic+e le capital à la fin du terme. Dl fonctionne aussi pour plusieurs clients usqu'à ce que l'usa$er décide de quitter.
ercice O :
Écrire un pro$ramme permettant de saisir et de !alider d'un entier positif (eemple n TO). Le pro$ramme calcule et affic+e à l'écran la somme des c+iffres qui forment l'entier lu (ici, la somme des c+iffres est 1 T K K O).
ercice A (scientifique) :
Écrire un pro$ramme permettant de trou!er toutes les racines de l'équation f() J, oU :
H f() > 1Q K HJ
( S+éor"me en mat+ématique :
i f est continue dans l'inter!alle Va, bW (eemple :VJ, .AW) et f(a) f(b) 9 J, alors : il G a au moins une racine de f() J dans Va, bW )
2) Boucle while ... :
2.a) Syntaxe :
while (condition) instruction
Chapitre 2 : Boucles de répétitions et fonctions Page 33
-
8/17/2019 Copie de secours de chapitre2.doc
8/35
L'instruction à répéter peut être simple (une seule action), structurée (une autre instruction de contrôle) ou composée (c'est le cas le plus fréquent).
Dl n'G a pas de 4do4 (faire) comme le %&#&L.
2.b) onctionne!ent :
Étape 1 : !érifier d'abord la condition
Étape : si la condition !aut !raie alors a) on effectue l'instruction à répéter b) on re!ient à l'étape 1 si non, on quitte la boucle
2.c) "o!aines d#utilisation :
n utilise la boucle *+ile ... quand on ne sait pas à l'a!ance le nombre de fois qu'on doit répéter le même traitement. n l'utilise surtout pour la lecture d'un fic+ier, la rec+erc+e d'un élément dans un tableau, les calculs scientifiques.
1. a lecture d!un fichier :
upposons qu'on dispose du fic+ier nommé 4ntiers.Xta4 qui contient un entier par li$ne, eemple :
TA >1 ; HP etc ...
Écrire un pro$ramme permettant de lire le fic+ier, d'affic+er son contenu, de compter et d'affic+er le nombre d'entiers lus dont la !aleur est supérieur à 1J.
"otes sur la lecture d!un fichier te#te :
. Xéclarer :
-
8/17/2019 Copie de secours de chapitre2.doc
9/35
olution :
0
-
8/17/2019 Copie de secours de chapitre2.doc
10/35
3. 'uelques e#ercices de calcul :
ercice 1 :
Écrire un pro$ramme permettant de saisir et de !alider d'un entier positif (eemple n TO). Le pro$ramme calcule et
affic+e à l'écran la somme des c+iffres qui forment l'entier lu (ici, la somme des c+iffres est 1 T K K O).
olution :
0
-
8/17/2019 Copie de secours de chapitre2.doc
11/35
écution :
ntre6 un entier supérieur à 6éro >ATP; !aleur né$ati!e, retape6, .=.%.
ntre6 un entier supérieur à 6éro ;PHT L'entier lu est ;PHT La somme des c+iffres de n ;PHT est O
&ppuGe6 sur ntrée
ercice :
Écrire un bloc d'instruction permettant de calculer et d'affic+er la somme sui!ante :
somme 1 K 10H K 10A K 10P K ... K 10QQQ
olution :
const int M21 1 , M2 QQQ /
float denominateur M21, somme J /
*+ile ( denominateur 9 M2 ) 3 somme K 1 0 denominateur / denominateur K / @
printf(4La somme demandée : 71J.Tf5n4, somme)/
ercice H :
Écrire un bloc d'instructions utilisant la boucle *+ile qui permet d'estimer la !aleur de %D selon la formule sui!ante :
%D >>>>> 1 > 10H K 10A > 10P K 10Q K .... 10QQQQ O
Chapitre 2 : Boucles de répétitions et fonctions Page 37
-
8/17/2019 Copie de secours de chapitre2.doc
12/35
3) Boucle for ... :
3.a) Syntaxe :
for (;;) instruction
> l'instruction à répéter peut être simple ou composée (bloc)
> l'epression 1 (ep1) : initialisation
l'epression (ep) : condition de continue qui est é!aluée a!ant c+aque itération
l'epression H (epH) : l'incrémentation ou la décrémentation (instruction de fin d[itération)
emple de sGntae :
for ( i 1 / i 9 1J / i i K 1 )
printf(4onsoirF5n4)/
#ette boucle fait affic+er 1J li$nes qui contient le messa$e onsoirF
3.b) onctionne!ent :
Dnitialiser la !ariable de contrôle de la boucle
Sant que la condition de continue !aut !raie effectuer l'instruction à répéter > incrémenter ou décrémenter la !ariable de contrôle
3.c) "o!aines d#utilisation :
n utilise la boucle for quand on sait à l'a!ance le nombre de
fois qu'on rép"te le même traitement. #'est le cas des !aleurs consécuti!es entre deu bornes données. n l'utilise aussi sou!ent pour parcourir les indices d'un tableau.
Chapitre 2 : Boucles de répétitions et fonctions Page 38
-
8/17/2019 Copie de secours de chapitre2.doc
13/35
1. e no)*re de fois de la répétition est connue :
ercice 1 :
Écrire un bloc d'instruction permettant d'affic+er les T lettres mauscules à l'écran :
&#X
-
8/17/2019 Copie de secours de chapitre2.doc
14/35
olution :
const int M21 1 , M2 QQQ /
int denominateur/ float somme J /
for ( denominateur M21 / denominateur 9 M2 / denominateur denominateur K 1 )
somme K 1.J 0 denominateur /
printf(4La somme demandée : 71J.Tf5n4, somme)/
ercice A :
Écrire un bloc d'instructions utilisant la boucle for qui permet d'estimer la !aleur de %D selon la formule sui!ante :
%D >>>>> 1 > 10H K 10A > 10P K 10Q K .... 10QQQQ O
bser!ations :
n premi"re !ue, les dénominateurs ne sont pas consécutifs :
1 H A P Q ... QQQQ
%ar contre, on peut les écrire différemment :
( J K 1) ( 1 K 1) ( K 1) .... ( OQQQ K 1) 1 H A QQQQ
Xans cette nou!elle écriture, les !aleurs J, 1, , ... OQQQ sont consécuti!es, on peut utiliser la boucle for.
olution :
const int LDBDS QQQQ /
float piurO J.J, si$ne 1.J /
int /
for ( J / 9 LDBDS 0 / KK ) 3 piurO K si$ne 0 ( K 1) /
si$ne > si$ne / @
printf(4La !aleur estimée de %D est 71.Tf 4,O %DNurO)/
Chapitre 2 : Boucles de répétitions et fonctions Page $0
-
8/17/2019 Copie de secours de chapitre2.doc
15/35
2otes :
Xans l'incrémentation de la !ariable de la boucle for, on utilise tr"s sou!ent KK à la place de K 1.
KK est l'opérateur de post>incrémentation (utiliser d'abord la !aleur, incrémenter apr"s a!oir utilisé la !aleur) :
emples :
1. int A / printf(4 7d5n4, )/ 0 affic+er A 0
KK / 0 incrémenter , !aut T 0 printf(4 7d5n4, )/ 0 affic+er T 0
. int A / if ( KK ) printf(4 7d5n4, )/
#ette instruction affic+e T à l'écran.
n effet, a!ec if ( KK ) on a actions : a) if (A) , comme A est non nul E if (!rai) b) est incrémenté E !aut T
L'instruction printf... fait affic+er la !aleur T de .
n utilise sou!ent l'opérateur KK pour l'incrémentation dans la boucle for et dans la manipulation des pointeurs (c+apitre H).
L'opérateur >> pour la décrémentation est aussi utile pour la boucle for (!oir eercice sui!ant).
ercice T :
Écrire un bloc d'instruction permettant d'affic+er les A li$nes sui!antes à l'écran :
A O H 1 O H 1 H 1 1 1
olution :
Rdefine 2NLD\2 A
int L, # /
0 %our L !arie de A en descendant à 1 faire 0 for ( L 2NLD\2 / L E 1 / L>> )
3 for ( # L / # E 1 / #>> ) printf(47d4, #)/ printf(45n4)/ @
Chapitre 2 : Boucles de répétitions et fonctions Page $1
-
8/17/2019 Copie de secours de chapitre2.doc
16/35
ercice 1(application scientifique) :
#alcul de l'inté$rale définie :
oit f une fonction inté$rable dans l'inter!alle Va, bW. `ne mét+ode permet d'estimer l'inté$rale de f() d dans Va, bW s'appelle la mét+ode des trap"6es : n di!ise Va, bW en n sous>inter!alles de même lon$ueur + ( + (b>a) 0 n ). &pr"s certains dé!eloppements mat+ématiques, on arri!e à la formule sui!ante:
f(&) K f() n>1 Dnté$rale + W >>>>>>>>>>>> K Σ f( & K i+ ) V i 1
Écrire un pro$ramme permettant de tester cette mét+ode en estimant : e 1
>>> d 1 e (S+éoriquement, c'est Lo$() Lo$(e) > Lo$(1) 1 > J 1) 1
ercice ; :
%armi les entiers entre 1JJ et AJJ, seuls O nombres peu!ent être représentés par la somme des cubes de leurs c+iffres.
Écrire un bloc d'instructions pour décou!rir et affic+er ces nombres.
olution :
Rdefine M21 1JJ Rdefine M2 AJJ
int nombre, somme#ube , !aleur, #+iffre /
for ( nombre M21 / nombre 9 M2 / nombreKK ) 3 !aleur nombre / somme#ube J /
*+ile ( !aleur E J ) 3 #+iffre !aleur 7 1J / somme#ube somme#ube K #+iffre #+iffre #+iffre / !aleur !aleur 0 1J / @
if ( nombre somme#ube ) printf(4nombre 7Ad, somme des cubes de ses c+iffres 7Ad5n4, nombre, somme#ube)/ @
Chapitre 2 : Boucles de répétitions et fonctions Page $2
-
8/17/2019 Copie de secours de chapitre2.doc
17/35
-
8/17/2019 Copie de secours de chapitre2.doc
18/35
B) Adresses %s &ointeurs :
1) Domaines dutilisation :
n utilise tr"s sou!ent les adresses dans :
1. la saisie des données a!ec scanf /
. les appels des fonctions pour rece!oir des !aleurs retournées /
n utilise des pointeurs dans :
1. la transmission des ar$uments par pointeurs (résultats de retour) /
. la manipulation des tableau /
H. les fic+iers :
-
8/17/2019 Copie de secours de chapitre2.doc
19/35
2. a) Les adresses :
n #, on aoute un caractéristique de plus à une !ariable :
son adresse (son emplacement en mémoire) déterminée par l'opérateur 8 (adresse de)
L'adresse d'une !ariable est déterminée sou!ent à la compilation de la mani"re séquentielle :
+#e)ple d!illustration des adresses :
oit le pro$ramme sui!ant :
0 >> >>>>>>> >>>>>>>>>> >>>>>>>>>>> >>>>>>>>5n4)/
printf(4 a int 7d 7u 7d5n4, si6eof(a), 8a, a)/
printf(4 b int 7d 7u 7d5n4, si6eof(b), 8b, b)/
printf(4 float 7d 7u 7T.f5n4, si6eof(), 8, )/
printf(4 d c+ar 7d 7u 7c5n4, si6eof(c+ar), 8d, d)/
printf(4 c int 7d 7u 7d5n4, si6eof(int), 8c, c)/
printf(45n5nL'opérateur (contenu de l'adresse) :5n4)/ printf(4Le contenu à l'adresse 7u est 7d5n4, 8b, (8b))/ printf(4Le contenu à l'adresse 7u est 7T.f5n4, 8, (8))/
printf(45n5n&ppuGe6 sur ntrée 4)/ $etc+ar()/ @
Chapitre 2 : Boucles de répétitions et fonctions Page $&
-
8/17/2019 Copie de secours de chapitre2.doc
20/35
écution :
L'eécution du pro$ramme a!ec S`M #KK sur un DB %0 donne ce qui suit :
2om SGpe 2b. octets &dresse !aleur >>> >>>>>>> >>>>>>>>>> >>>>>>>>>>> >>>>>>>> a int 1PJ A b int 1P H float O 1PO 1H.OJ d c+ar 1 1P; = c int 1PQ 1JJ
L'opérateur (contenu de l'adresse) :
Le contenu à l'adresse 1P est H Le contenu à l'adresse 1PO est 1H.OJ
&ppuGe6 sur ntrée
c+émas d'eplication :
`ne case d'un octet dispose d'une adresse en mémoire. Xépendant du tGpe de la !ariable le compilateur alloue un nombre de cases ( dans cet en!ironnement de tra!ail : cases pour un entier (maintenant, les entiers sont sur O octets),O pour un réel, 1 pour un caract"re, etc.).
Les !aleurs sont codées en binaire. %our une meilleure compré+ension, on représente ici comme des !aleurs usuelles (entier, réel, caract"re).
!aleur 2om (en binaire) &dresse gggggggggggggggh a 1PJ (adresse du début de a) g A ggh 1P1 gggggggggggggggh b 1P (adresse du début de b) g H ggh 1PH gggggggggggggggh 1PO (adresse du début de ) gg ggh 1PA gg 1H.O ggh 1PT
gg ggh 1PP gggggggggggggggh d '=' 1P; (adresse du début de d) gggggggggggggggh c 1PQ (adresse du début de c) gg 1JJ ggh 1;J gggggggggggggggh
Chapitre 2 : Boucles de répétitions et fonctions Page $(
-
8/17/2019 Copie de secours de chapitre2.doc
21/35
n !oit aussi l'opérateur 44 dont :
(adresse) 9E le contenu (la !aleur) qui se trou!e à cette adresse
&insi : (8b) 9E le contenu à l'adresse 1P 9E H (!aleur de b)
(8) 9E le contenu à l'adresse 1PO 9E 1H.OJ (!aleur de )
n re!ient maintenant à la lecture de la premi"re semaine :
printf(4ntre6 la !aleur de b 4)/ scanf(47d4, 8b)/
n interpr"te scanf(47d4, 8b)/ comme suit :
Lire la !aleur tapée et déposer cette !aleur à l'adresse 1P (l'adresse de b) E b !aut la !aleur saisie.
2. b) Les pointeurs :
La !aleur d'une !ariable enti"re est un entier : int a$e H /
La !aleur d'une !ariable de tGpe réel est un réel : float %oids T.J /
La !aleur d'un pointeur est une adresse.
Pre)ier e#e)ple d!illustration des pointeurs : oit le pro$ramme sui!ant : 0
-
8/17/2019 Copie de secours de chapitre2.doc
22/35
!oid Xemo1() 3
printf(4%remi"re démonstration:5n5n4)/
printf(42om SGpe 2b. octets &dresse !aleur5n4)/ printf(4>>> >>>>>>> >>>>>>>>>> >>>>>>>>>>> >>>>>>>>5n4)/
printf(4 b int 7d 7u 7d5n4, si6eof(b), 8b, b)/
printf(4 % int 7d 7u 7u5n5n4, si6eof(%), 8%, %)/
printf(4 float 7d 7u 7T.f5n4, si6eof(), 8, )/
printf(4 float 7d 7u 7u5n4, si6eof(), 8, )/
printf(45constatations :5n5n4)/
printf(4 1. !aleur d'un pointeur est une adresse :5n4)/ printf(4 > !aleur du pointeur % (7u) est l'adresse de b (7u)5n4, %, 8b)/ printf(4 > !aleur du pointeur (7u) est l'adresse de (7u)5n5n4, , 8)/
printf(4 . %lusieurs mani"res pour les !aleurs de % et de :5n5n4)/ printf(4 % Le contenu à l'adresse 7u 7d5n4, %, %)/ printf(4 Le contenu à l'adresse 7u 7T.f5n4, , )/ printf(4 % 7Td (8b) 7Td b 7Td5n4, %, (8b), b)/ printf(4 7T.f (8) 7T.f 7T.f5n4, , (8), )/
#ontinuer()/ @
!oid main() 3 Xemo1()/ @
+#écution :
L'eécution du pro$ramme a!ec S`M #KK sur un DB %0 donne ce qui suit :
%remi"re démonstration:
2om SGpe 2b. octets &dresse !aleur >>> >>>>>>> >>>>>>>>>> >>>>>>>>>>> >>>>>>>> b int 1P H % int 1PO 1P
float O 1P; 1H.OJ float 1; 1P;
Chapitre 2 : Boucles de répétitions et fonctions Page $8
-
8/17/2019 Copie de secours de chapitre2.doc
23/35
-
8/17/2019 Copie de secours de chapitre2.doc
24/35
1.a) Syntaxe :
tGpe du résultat de retour nom de la fonction( liste de paramètre(s)) 3 déclarations locales si nécessaire
calcule et retourne (avec return) le résultat calculé @
emple d'illustration de la sGntae :
La fonction sui!ante permet de calculer et de retourner la plus $rande !aleur parmi deu réels.
float plus\rand ( float , float G ) 3 if ( E G ) return / else return G / @
1.b) 'e!ar(ues :
1. Le nom de la fonction ne contient pas de résultat de retour comme le %&#&L.
. Dl faut utiliser le résultat retourné dans un bon contete (affic+a$e, affectation, comparaison, ...).
H. L'instruction 4return4 pro!oque la fin de la fonction, on re!ient à la place qui appelle la fonction.
O. ur l'en>tête, on ne peut pas $rouper les param"tres de même tGpe :
float plus\rand ( float , G ) 0 erronéF 0
A. 2e pas terminer l'en>tête par le point !ir$ule :
float plus\rand ( float , float G ) / 0 erronéF 0
1.c) $xe!ples : emple 1 (fonction qui retourne un entier comme résultat) :
Écrire un pro$ramme permettant de saisir un entier 2 supérieur à 6éro. Le pro$ramme calcule (par les fonctions) et affic+e à l'écran : > la somme des c+iffres du nombre n > l'en!ers du nombre n
Chapitre 2 : Boucles de répétitions et fonctions Page &0
-
8/17/2019 Copie de secours de chapitre2.doc
25/35
olution :
0
-
8/17/2019 Copie de secours de chapitre2.doc
26/35
olution :
float bonus ( c+ar poste ) 3 float boni /
s*itc+ ( toupper(poste) ) 3 case '&' : boni HO.A / brea /
case '%' : boni 1J.Q / brea /
case '' : boni 1;Q.J / @
return boni / @
_uelques utilisations !alides :
1. dans l'affic+a$e (plus courant)
printf(4onus d'un analGste : 7T.f5n4, bonus('&') )/
. dans une affectation :
float salaireZebdo, salaireSotal / c+ar poste /
.......
salaireSotal salaireZebdo K onus(poste)/
H. dans une comparaison :
if ( onus (poste) E JJ.J ) printf(4%as si mal5n4)/
float salaireZebdo, salaireSotal / c+ar poste /
.......
salaireSotal salaireZebdo K bonus(poste)/
emple H (fonction qui retourne un caract"re comme résultat) :
Écrire une fonction permettant de ouer le même rôle que 4toupper4 (con!ersion en B&]`#`L).
Écrire une utilisation !alide de cette fonction.
Chapitre 2 : Boucles de répétitions et fonctions Page &2
-
8/17/2019 Copie de secours de chapitre2.doc
27/35
olution :
c+ar mauscule ( c+ar c ) 3 if ( c E 'a' 88 c 9 '6' ) 0 lette minuscule 0
return c K '&' > 'a' / 0 code &#DD 0
else return c /
@
`ne utilisation !alide :
printf(4Le caract"re 7c en mauscule est 7c5n4, 'e', mauscule ('e') )/
emple O (fonction qui retourne !rai ou fau comme résultat) :
Écrire une fonction permettant de retourner !rai (1) ou fau (J) selon qu'un caract"re est une !oGelle ou non.
Écrire une instruction utilisant cette fonction pour affic+er les J consonnes en mauscules à l'écran.
olution :
int !oGelle ( c+ar lettre ) 3 int reponse /
s*itc+ ( toupper(lettre) ) 3 case '&' : case '' : case 'D' : case '' : case '`' : case '' : reponse 1 / 0 =M&D 0 brea / default : reponse J / 0
-
8/17/2019 Copie de secours de chapitre2.doc
28/35
Memarque :
%our la clarté, on peut aussi utiliser les Rdefine dans le cas des fonctions booléennes. emple : écrire une fonction qui retourne !rai ou fau selon qu'un entier n E est premier (a di!iseurs seulement : 1 et n) ou non.
int %remier ( int n ) 3 Rdefine =M&D 1 Rdefine
-
8/17/2019 Copie de secours de chapitre2.doc
29/35
int main() 3 ........
return 1 / @
#ette mani"re permet d'é!iter des a!ertissements (*arnin$) à la compilation mais n'est pas tr"s compré+ensi!e. Dl est préférable, d'utiliser une fonction de tGpe !oid :
void !in() "# rien à retourner #" 3
....... @
2.a) Syntaxe :
!oid nom de la fonction ( liste de param"tre(s) ) 3 déclarations locales
réaliser l'action confiée (s'il G a des résultats de retour, ce sont des param"tres transmis par pointeurs ou par référence(plus loin)) @
]e su$$"re d'utiliser le nom d'un !erbe qui résume la t-c+e de la fonction pour nommer la fonction :
!oid calculer( .... )
!oid trier ( .... )
etc ....
2.b) $xe!ples :
#as 1 :
_uand on utilise des résultats à l'intérieur du corps d'une fonction, on n'a que des param"tres transmis par !aleur.
emple :
Écrire une fonction permettant de compter et d'affic+er le nombre de di!iseurs d'un entier n positif donné. Écrire appels permettant d'affic+er le nombre de di!iseurs de PJ et Q;O.
Chapitre 2 : Boucles de répétitions et fonctions Page &&
-
8/17/2019 Copie de secours de chapitre2.doc
30/35
-
8/17/2019 Copie de secours de chapitre2.doc
31/35
-
8/17/2019 Copie de secours de chapitre2.doc
32/35
-
8/17/2019 Copie de secours de chapitre2.doc
33/35
emples d'illustration :
1. !oid calculer ( float a, float b, float % ) 0 #alculer et retourner la plus petite !aleur 0 3 if ( a 9 b ) % a / else % b / @
`tilisation :
float , G , plus%etit /
printf(4ntre6 réels 4)/ scanf(8, 8G)/
calculer (, G, 8plus%etit)/
printf(4La plus petite !aleur est 7;.f5n4, plus%etit)/
plications :
upposons que !aut A., G !aut H.O et l'adresse de plus%etit est AJJJJ.
&!ec l'appel : #alculer (, G, 8plus%etit)/
n transmet à la fonction :
!oid calculer ( float a, float b, float % )
1. la !aleur A. à a . la !aleur H.O à b H. la !aleur AJJJJ à % :
gggggggh gggggggh &dresse AJJJ ??? AJJJ kggggggg kggggggg % plus%etit
n eécute la fonction :
if ( a 9 b ) % a / else % b /
#omme a 9 b est fau, on a : % b /
#'est>à>dire : déposer à l'adresse 4AJJJ4 la !aleur H.O.
gggggggh H.O kggggggg plus%etit
Chapitre 2 : Boucles de répétitions et fonctions Page &9
-
8/17/2019 Copie de secours de chapitre2.doc
34/35
#'est la fin de la fonction, on re!ient à la fin d'appel. n rencontre :
printf(4La plus petite !aleur est 7;.f5n4, plus%etit)/
lle fait affic+er la !aleur H.O à l'écran.
. !oid ec+an$er ( int p, int s ) 0 Éc+an$er le contenu de entiers 0 3 int temporaire /
temporaire p / p s / s temporaire / @
`tilisation :
int a, b /
printf(4ntre6 entiers 4)/ scanf(47d7d4,8a, 8b)/ printf(4&!ant l'éc+an$e, a 7Hd, b 7Hd5n4, a, b)/
ec+an$er (8a, 8b ) /
printf(4&pr"s l'éc+an$e, a 7Hd, b 7Hd5n4, a, b)/
plications :
upposons que a !aut 1A, b !aut P et l'adresse de a est O;JJJ et l'adresse de b est O;JJ.
&!ec l'appel : ec+an$er (8a, 8b ) /
n transmet à la fonction : !oid ec+an$er ( int p, int s )
1. la !aleur O;JJJ à % (a!ec % !aut 1A) . la !aleur O;JJ à (a!ec !aut P)
gggggggh gggggggh O;JJJ O;JJ kggggggg kggggggg p s
n eécute la fonction :
temporaire p / E temporaire !aut 1A p s / E Le contenu à l'adresse O;JJJ est celui à l'adresse O;JJ
&dresse gggggggh &dresse gggggggh O;JJJ P O;JJ P kggggggg kggggggg a b
Chapitre 2 : Boucles de répétitions et fonctions Page (0
-
8/17/2019 Copie de secours de chapitre2.doc
35/35
s temporaire / E Le contenu à l'adresse O;JJ !aut 1A :
gggggggh &dresse 1A O;JJ kggggggg b
& la fin de la fonction, les !aleurs de a et b sont éc+an$ées.
ercice :
Écrire une fonction qui reoit deu réels a et b comme param"tres d'entrée. lle calcule et retourne (par pointeurs) les résultats sui!ants :
> la plus $rande !aleur parmi a et b > la plus petite !aleur parmi a et b > la différence positi!e entre a et b
(absolue de (a>b)).
2) #onctions prédéfinies (implantées) dans les fichiers den'tte :
#+aque fonction réalise sou!ent une t-c+e (eemple : con!ersion une c+aIne de caract"res en entier), elle si$nale aussi le résultat de la réalisation (faisable ou non) :
emple :
int , !aleur / c+ar c+aine / 0 une c+aIne des caract"res 0
c+aine 4abcdef4 /
!aleur atoi(c+aine) / 0 alp+abetic to inte$er 0
printf(4!aleur 7d5n4, !aleur) / 0 !aleur !aut 6éro, éc+oueF 0
c+aine 4APH4 /
!aleur atoi(c+aine) / 0 alp+abetic to inte$er 0
printf(4!aleur 7d5n4, !aleur) / 0 !aleur !aut APH, correctF 0