copie de secours de chapitre2.doc

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


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) '


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 /



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



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


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


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



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.


É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


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 :


9/35

olution :

0


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


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



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


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


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.



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


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


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)/ @



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)/ @



17/35


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 :


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 $&


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 $(


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


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;



23/35


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


25/35

olution :

0


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.



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


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


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 &&


30/35


31/35


32/35


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



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


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

copie de secours de chapitre2.doc

Documents