Exercices en Langage C Delannoy

/* cas 1 */ q = %d\n", n, p, q) ; /* cas 2 */ q = %d\n", n, p, q) ; /* cas 3 */

9

10

Exe rcice s e n langage C q = ++n == 3 && ++p == 3 ; printf ("C : n = %d p = %d n = 5 ; p = 2 ; q = ++n == 6 && ++p == 3 ; printf ("D : n = %d p = %d

q = %d\n", n, p, q) ; /* cas 4 */ q = %d\n", n, p, q) ;

}

___________________________________________________________________________

Sol ution Ilne faut pas oublie r q ue les opé rate urs & & e t || n'é value nt leur de uxiè m e opé rande q ue lors q ue ce la e s t né ce s s aire . Ainsi, ici, iln'e s t pas é valué dans les cas 1 et 3. Voici les ré s ultats fournis par le program m e : A B C D

: : : :

n n n n

= = = =

6 6 6 6

p p p p

= = = =

2 3 2 3

q q q q

= = = =

1 1 0 1

II : LES ENTREES-SO RTIES CO NVERSA TIO NNELLES

Exe rcice II.1 ___________________________________________________________________________

Enoncé Quels s e ront les ré s ultats fournis par ce program m e : #include main () { int n = 543 ; int p = 5 ; float x = 34.5678; printf ("A : %d %f\n", n, x) ; printf ("B : %4d %10f\n", n, x) ; printf ("C : %2d %3f\n", n, x) ; printf ("D : %10.3f %10.3e\n", x, x) ; printf ("E : %-5d %f\n", n, x) ; printf ("F : %*d\n", p, n) ; printf ("G : %*.*f\n", 12, 5, x) ; printf ("H : %x : %8x :\n", n, n) ; printf ("I : %o : %8o :\n", n, n) ; }

_______________________________________________________________

Sol ution A : 543 34.567799 B : 543 34.567799

12

Exe rcice s e n langage C C D E F G H I

: : : : : : :

543 34.567799 34.568 3.457e+01 543 34.567799 543 34.56780 21f : 21f : 1037 : 1037 :

Exe rcice II.2 ___________________________________________________________________________

Enoncé Quels s e ront les ré s ultats fournis par ce program m e : #include main() { char c ; int n ; c = 'S' ; printf ("A : %c\n", c) n = c ; printf ("B : %c\n", n) printf ("C : %d %d\n", printf ("D : %x %x\n", }

; ; c, n) ; c, n) ;

_______________________________________________________________

Sol ution A B C D

: : : :

S S 83 83 53 53

II. Le s e ntré e s -sortie s conve rsationne lles

13

Exe rcice II.3 ___________________________________________________________________________

Enoncé Quelles s e ront les valeurs lues dans les variables n e t p (de type int), par l'instruction suivante : scanf ("%d %d", &n, &p) ;

lors q u'on lui fournit les données suivante s (le sym bole ^ re pré s e nte un e s pace e t le sym bole @ re pré s e nte une fin de ligne , c'e s t-à -dire une "validation") : a) 253^45@

b) ^253^@ ^^ 4 ^ 5 @

_______________________________________________________________

Sol ution a) n = 243, p = 45 b) n = 253, p = 4 (les dernie rs caractè res de la deuxiè m e ligne pourront é ve ntue llem e nt ê tre utilisés par une instruction de lecture ulté rie ure ).

Exe rcice II.4 ___________________________________________________________________________

Enoncé Quelles s e ront les valeurs lues dans les variables n e t p (de type int), par l'instruction suivante : scanf ("%4d %2d", &n, &p) ;

lors q u'on lui fournit les données suivante s (le sym bole ^ re pré s e nte un e s pace e t le sym bole @ re pré s e nte une fin de ligne , c'e s t-à -dire une "validation") :

14 a)

Exe rcice s e n langage C 12^45@

b) 123456@

c) 123456^7@

d) 1^458@

e) ^^^4567^^8912@

_______________________________________________________________

Sol ution R appe lons q ue lors q u'une indication de longue ur e s t pré s e nte dans le code form at fourni à scanf (com m e , par e xe m ple, le 4 de %4d), scanf inte rrom pt son exploration si le nom bre corre s pondant de caractè re s a é té e xploré , sans q u'un s é parate ur (ou "e s pace blanc") n'ait é té trouvé . Note z bie n, ce pe ndant, q ue les é ve ntue ls caractè re s s é parate urs "sauté s " auparavant ne s ont pas considérés dans ce com pte . Voici les ré s ultats obte nus : a) n=12, p=45 b) n=1234, p=56 c) n=1234, p=56 d) n=1, p=45 e) n=4567, p=89 En a, on obtie ndrait e xacte m e nt les m ê m e s ré s ultats sans indication de longue ur (c'e s t-à -dire ave c %d %d). En b, e n re vanch e , sans l'indication de longue ur 4, les ré s ultats s e raie nt diffé re nts (n vaudrait 123456, tandis q u'ilm anq ue rait des inform ations pour p). En c, les inform ations ^ et 7 ne s ont pas prises en com pte par scanf (e lles le s e ront é ve ntue llem e nt par une proch aine lecture !) ;sans la pre m iè re indication de longue ur, les ré s ultats s e raie nt diffé re nts : 123456 pour n (e n supposant q ue ce la ne conduis e pas à une valeur non re pré s e ntable dans le type int) e t 7 pour p. En d, ce tte fois, c'e s t l'indication de longue ur 2 q ui a de l'im portance ;e n son abscence, n vaudrait e ffe ctive m e nt 1, m ais p vaudrait 458. Enfin, e n e , les deux indications de longue ur sont im portante s ;note z bie n q ue les trois e s pace s placé s avant les caractè re s pris e n com pte pour n, ainsi que les 2 e s pace s placé s avant les caractè re s pris e n com pte pour p ne s ont pas com ptabilisés dans la longue ur im pos é e .

Exe rcice II.5 ___________________________________________________________________________

II. Le s e ntré e s -sortie s conve rsationne lles

15

Enoncé Soit le program m e s uivant : #include main() { int n, p ; do { printf ("donnez 2 entiers (0 pour finir) : ") ; scanf("%4d%2d", &n, &p) ; printf ("merci pour : %d %d\n", n, p) ; } while (n) ; }

Quels ré s ultats fournira-t-il, e n supposant q u'on lui e ntre les données suivante s (atte ntion, on supposera q ue les données sont frappé e s au clavie r e t les ré s ultats affich é s à l'é cran, ce q ui signifie q u'ily aura "m ixage " e ntre ces deux sorte s d'inform ations) : 1 2 3 4 123456 78901234 5 6 7 8 9 10 0 0 12

_______________________________________________________________

Sol ution Ici, on re trouve le m é canism e lié à l'indication d'une longue ur m axim ale dans le code form at, com m e dans l'e xe rcice pré cédent. De plus, on e xploite le fait q ue les inform ations d'une ligne q ui n'ont pas é té pris e s e n com pte lors d'une lecture re s te nt disponibles pour la lecture s uivante . Enfin, rappe lons q ue , tant q ue scanf n'a pas re çu suffisam m e nt d'inform ation, com pte te nu des diffé re nts code s form at spécifié s (e t non pas des variables indiq ué e s ), e lle e n atte nd de nouve lles . Voici finalem e nt les ré s ultats obte nus : donnez 2 entiers (0 pour finir) 1 2 merci pour : 1 2

16

Exe rcice s e n langage C donnez 2 entiers (0 pour 3 4 merci pour : 3 4 donnez 2 entiers (0 pour 123456 merci pour : 1234 56 donnez 2 entiers (0 pour 78901234 5 merci pour : 7890 12 donnez 2 entiers (0 pour merci pour : 34 5 donnez 2 entiers (0 pour 6 7 8 9 10 merci pour : 6 7 donnez 2 entiers (0 pour merci pour : 8 9 donnez 2 entiers (0 pour 0 merci pour : 10 0 donnez 2 entiers (0 pour 0 12 merci pour : 0 12

finir)

finir)

finir)

finir) finir)

finir) finir)

finir)

III : LES INSTRUCTIO NS D E CO NTRO LE

Exe rcice III.1 ___________________________________________________________________________

Enoncé Quelles e rre urs ont é té com m ises dans ch acun de s groupes d'instructions suivants : 1) if (a
2) int n ; ... switch (2*n+1) { case 1 : printf ("petit") ; case n : printf ("moyen") ; }

3) #define LIMITE 100 int n ; ... switch (n) { case LIMITE-1 : printf ("un peu moins") ; case LIMITE : printf ("juste") ; case LIMITE+1 : printf ("un peu plus") ; }

4) const int LIMITE=100 int n ;

18

Exe rcice s e n langage C ... switch { case case case }

(n) LIMITE-1 : printf ("un peu moins") ; LIMITE : printf ("juste") ; LIMITE+1 : printf ("un peu plus") ;

_______________________________________________________________

Sol ution 1) Ilm anq ue un point-virgule à la fin du pre m ie r printf : if (a
2) Le s valeurs suivant le m ot cas e doive nt obligatoire m e nt ê tre des "e xpre s s ions constante s ", c'e s t-à -dire d e s e xpre s s ions calculables par le com pilate ur lui-m ê m e . Ce n'e s t pas le cas de n. 3) Aucune e rre ur, les e xpre s s ions te lles q ue LIM ITE-1 é tant bien des expressions constante s . 4) Ici, les e xpre s s ions suivant le m ot cas e ne s ont plus des expre s s ions constante s , car le sym bole LIM ITE a é té défini sous form e d'une "constante sym boliq ue " (e n C+ + , ce pe ndant, ce s instructions s e ront corre cte s ).

Exe rcice III.2 ___________________________________________________________________________

Enoncé Soit le program m e s uivant : #include main() { int n ; scanf ("%d", &n) ; switch (n) { case 0 : printf ("Nul\n") ; case 1 :

III. Le s instructions de contrôle case 2 : printf ("Petit\n") ; break ; case 3 : case 4 : case 5 : printf ("Moyen\n") ; default : printf ("Grand\n") ; } }

Quels ré s ultats affich e -t-illors q u'on lui fournit e n donné e : a) 0 b) 1 c) 4 d) 10 e) -5 ___________________________________________________________________________

Sol ution a) Nul Petit

b) Petit

c) Moyen Grand

d) Grand

e) Grand

Exe rcice III.3 ___________________________________________________________________________

19

20

Exe rcice s e n langage C

Enoncé Quelles e rre urs ont é té com m ises dans ch acune des instructions suivante s : a) do c = getchar() while (c != '\n') ;

b) do while ( (c = getchar()) != '\n') ;

c) do {} while (1) ;

___________________________________________________________________________

Sol ution a) Ilm anq ue un point-virgule : do c = getchar() ; while (c != '\n') ;

b) Ilm anq ue une instruction (é ve ntue llem e nt "vide") aprè s le m ot do. O n pourrait é crire , par e xe m ple : do {} while ( (c = getchar()) != '\n') ;

ou : do ; while ( (c = getchar()) != '\n') ;

c) Iln'y aura pas d'erreur de com pilation ;toute fois, ils'agit d'une "boucle infinie ".

Exe rcice III.4 ___________________________________________________________________________

Enoncé Ecrire plus lisiblem e nt : do {} while (printf("donnez un nombre >0 "), scanf ("%d", &n), n<=0) ;

___________________________________________________________________________

III. Le s instructions de contrôle

21

Sol ution Plusieurs possibilité s e xiste nt, puis q u'il "suffit" de re porte r, dans le corps de la boucle, des instructions figurant "artificie llem e nt" sous form e d'expressions dans la condition de poursuite : do printf("donnez un nombre >0 ") ; while (scanf ("%d", &n), n<=0) ;

ou, m ie ux : do { printf("donnez un nombre >0 ") ; scanf ("%d", &n) ; } while (n<=0) ;

Exe rcice III.5 ___________________________________________________________________________

Enoncé Soit le pe tit program m e s uivant : #include main() { int i, n, som ; som = 0 ; for (i=0 ; i<4 ; i++) { printf ("donnez un entier ") ; scanf ("%d", &n) ; som += n ; } printf ("Somme : %d\n", som) ; }

Ecrire un program m e ré alisant e xacte m e nt la m ê m e ch os e , e n e m ployant, à la place de l'instruction for :

22 Exe rcice s e n langage C a) une instruction w h ile, b) une instruction do ... w h ile. ___________________________________________________________________________

Sol ution a) #include main() { int i, n, som ; som = 0 ; i = 0 ; /* ne pas oublier cette "initialisation" */ while (i<4) { printf ("donnez un entier ") ; scanf ("%d", &n) ; som += n ; i++ ; /* ni cette "incrémentation" */ } printf ("Somme : %d\n", som) ; }

b) #include main() { int i, n, som ; som = 0 ; i = 0 ; /* ne pas oublier cette "initialisation" */ do { printf ("donnez un entier ") ; scanf ("%d", &n) ; som += n ; i++ ; /* ni cette "incrémentation" */ } while (i<4) ; /* attention, ici, toujours <4 */ printf ("Somme : %d\n", som) ; }

III. Le s instructions de contrôle

Exe rcice III.6 ___________________________________________________________________________

Enoncé Quels ré s ultats fournit le program m e s uivant : #include main() { int n=0 ; do { if (n%2==0) { printf ("%d est pair\n", n) ; n += 3 ; continue ; } if (n%3==0) { printf ("%d est multiple de 3\n", n) ; n += 5 ; } if (n%5==0) { printf ("%d est multiple de 5\n", n) ; break ; } n += 1 ; } while (1) ; }

___________________________________________________________________________

Sol ution

0 est pair 3 est multiple de 3 9 est multiple de 3 15 est multiple de 3 20 est multiple de 5

23

24

Exe rcice s e n langage C

Exe rcice III.7 ___________________________________________________________________________

Enoncé Quels ré s ultats fournit le program m e s uivant : #include main() { int n, p ; n=0 ; while (n<=5) n++ ; printf ("A : n = %d\n", n) ; n=p=0 ; while (n<=8) n += p++ ; printf ("B : n = %d\n", n) ; n=p=0 ; while (n<=8) n += ++p ; printf ("C : n = %d\n", n) ; n=p=0 ; while (p<=5) n+= p++ ; printf ("D : n = %d\n", n) ; n=p=0 ; while (p<=5) n+= ++p ; printf ("D : n = %d\n", n) ; }

___________________________________________________________________________

Sol ution A B C D

: : : :

n n n n

= = = =

6 10 10 15

III. Le s instructions de contrôle D : n = 21

Exe rcice III.8 ___________________________________________________________________________

Enoncé Quels ré s ultats fournit le program m e s uivant : #include main() { int n, p ; n=p=0 ; while (n<5) n+=2 ; p++ ; printf ("A : n = %d, p = %d \n", n, p) ; n=p=0 ; while (n<5) { n+=2 ; p++ ; } printf ("B : n = %d, p = %d \n", n, p) ; }

___________________________________________________________________________

Sol ution A : n = 6, p = 1 B : n = 6, p = 3

Exe rcice III.9 ___________________________________________________________________________

25

26

Exe rcice s e n langage C

Enoncé Quels ré s ultats fournit le program m e s uivant : #include main() { int i, n ; for (i=0, n=0 ; i<5 ; i++) n++ ; printf ("A : i = %d, n = %d\n", i, n) ; for (i=0, n=0 ; i<5 ; i++, n++) {} printf ("B : i = %d, n = %d\n", i, n) ; for (i=0, n=50 ; n>10 ; i++, n-= i ) {} printf ("C : i = %d, n = %d\n", i, n) ; for (i=0, n=0 ; i<3 ; i++, n+=i, printf ("D : i = %d, n = %d\n", i, n) ) ; printf ("E : i = %d, n = %d\n", i, n) ; }

___________________________________________________________________________

Sol ution A B C D D D E

: : : : : : :

i i i i i i i

= = = = = = =

5, 5, 9, 1, 2, 3, 3,

n n n n n n n

= = = = = = =

5 5 5 1 3 6 6

III. Le s instructions de contrôle

27

Exe rcice III.10 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui calcule les racine s carré e s d e nom bre s fournis e n donné e . Ils'arrê te ra lorq u'on lui fournira la valeur 0. Ilre fus e ra les valeurs négative s . Son e xé cution s e pré s e nte ra ainsi : donnez un nombre sa racine carrée donnez un nombre svp positif donnez un nombre sa racine carrée donnez un nombre

positif : 2 est : 1.414214e+00 positif : -1 positif : 5 est : 2.236068e+00 positif : 0

R appe lons q ue la fonction s q rt fournit la racine carré e (double) de la valeur (double) q u'on lui fournit e n argum e nt. ___________________________________________________________________________

Sol ution Ile xiste beaucoup de "rédactions possibles " ;e n voici 3 : #include #include

/* indispensable pour sqrt (qui fourni un résultat */ /* de type double */

main() { double x ; do { printf ("donnez un nombre positif : ") ; scanf ("%le", &x) ; if (x < 0) printf ("svp positif \n") ; if (x <=0) continue ; printf ("sa racine carrée est : %le\n", sqrt (x) ) ; } while (x) ; }

28

Exe rcice s e n langage C #include #include main() { double x ; do { printf ("donnez un nombre positif : ") ; scanf ("%le", &x) ; if (x < 0) { printf ("svp positif \n") ; continue ; } if (x>0) printf ("sa racine carrée est : %le\n", sqrt (x) ) ; } while (x) ; }

#include #include main() { double x ; do { printf ("donnez un nombre positif : ") ; scanf ("%le", &x) ; if (x < 0) { printf ("svp positif \n") ; continue ; } if (x>0) printf ("sa racine carrée est : %le\n", sqrt (x) ) ; if (x==0) break ; } while (1) ; }

R e m arque : Ilne faut surtout pas oublie r #include < m ath .h > car, sinon, le com pilate ur considè re (e n l'absce nce du prototype ) q ue s q rt fournit un ré s ultat de type int.

III. Le s instructions de contrôle

Exe rcice III.11 ___________________________________________________________________________

Enoncé Calculer la som m e des n pre m ie rs te rm es de la "s é rie h arm oniq ue ", c'e s t-à -dire la som m e : 1 + 1/2 + 1/3 + 1/4 + ..... + 1/n La valeur de n s e ra lue e n donné e . ___________________________________________________________________________

Sol ution

#include main() { int nt ; float som ; int i ;

/* nombre de termes de la série harmonique */ /* pour la somme de la série */

do { printf ("combien de termes : ") ; scanf ("%d", &nt) ; } while (nt<1) ; for (i=1, som=0 ; i<=nt ; i++) som += (float)1/i ; printf ("Somme des %d premiers termes = %f", nt, som) ; }

R e m arques : 1) R appe lons q ue dans : som += (float)1/i

l'e xpre s s ion de droite e s t é valué e e n conve rtissant d'abord 1 e t i e n float.

29

30

Exe rcice s e n langage C Ilfaut é vite r d'é crire : som += 1/i

auq ue lcas, les valeurs de 1/i seraient toujours nulles (sauf pour i=1) puiq ue l'opé rate ur /, lors q u'ilporte s ur de s e ntie rs, corre s pond à la division e ntiè re . D e m ê m e , e n é crivant : som += (float) (1/i)

le ré s ultat ne s e rait pas plus satisfaisant puis q ue la conve rsion en flottant n'aurait lie u q u'aprè s la division (e n e ntie r). En re vanch e , on pourrait é crire : som += 1.0/i ;

2) Si l'on ch e rch ait à e xé cute r ce program m e pour de s valeurs é levé e s d e n (e n pré voyant alors une variable de type float ou double), on constate rait q ue la valeur de la som m e s e m ble "conve rge r" ve rs une lim ite (bie n q u'e n th é orie la s é rie h arm oniq ue "dive rge "). Ce la provie nt tout sim plem e nt de ce q ue , dè s q ue la valeur de 1/i e s t "pe tite " devant som , le ré s ultat de l'addition de 1/i e t de som e s t exactem ent som . O n pourrait toute fois am é liore r le ré s ultat e n e ffe ctuant la som m e "à l'e nve rs" (e n e ffe t, dans ce cas, le rapport e ntre la valeur à ajoute r e t la som m e courante s e rait plus faible q ue pré cédem m e nt)..

Exe rcice III.12 ___________________________________________________________________________

Enoncé Affich e r un triangle isocè le form é d'étoiles . La h aute ur du triangle (c'e s t-à -dire le nom bre de ligne s ) s e ra fourni e n donné e , com m e dans l'e xe m ple ci-de s s ous. O n s'arrange ra pour q ue la derniè re ligne du triangle s 'affich e s ur le bord gauch e de l'é cran. combien de lignes ? 10 * *** ***** ******* ********* *********** ************* ***************

III. Le s instructions de contrôle

31

***************** *******************

___________________________________________________________________________

Sol ution #include #define car '*'

/* caractère de remplissage */

main() { int int int int

/* nombre total de lignes */ /* compteur de ligne */ /* nombre d'espaces précédent une étoile */

nlignes ; nl ; nesp ; j ;

printf ("combien de lignes ? ") ; scanf ("%d", &nlignes) ; for (nl=0 ; nl
Exe rcice III.13 ___________________________________________________________________________

Enoncé Affich e r toute s les m aniè re s possibles d'obte nir un franc ave c des piè ces de 2 ce ntim e s , 5 ce ntim e s e t 10 ce ntim e s . Dire com bien de possibilité s ont é té ainsi trouvé e s . Le s ré s ultats s e ront affich é s com m e s uit : 1 F = 50 X 2c

32

Exe rcice s e n langage C 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

F F F F F F F F F F F F F F F F F F F F F F

= = = = = = = = = = = = = = = = = = = = = =

45 40 35 30 25 20 15 10 5 20 45 40 35 10 5 6 10 5 4 5 2 10

X X X X X X X X X X X X X X X X X X X X X X

2c 2 2c 4 2c 6 2c 8 2c 10 2c 12 2c 14 2c 16 2c 18 5c 2c 1 2c 2 2c 4 2c 2 2c 4 5c 7 2c 8 2c 2 5c 8 2c 9 5c 9 10c

X X X X X X X X X

5c 5c 5c 5c 5c 5c 5c 5c 5c

X X X X X X X X X X X

10c 5c 5c 5c 5c 10c 10c 5c 10c 10c 10c

1 1 7 7

X X X X

10c 10c 10c 10c

8 X 10c

En tout, il y a 66 façons de faire 1 F

___________________________________________________________________________

Sol ution

#include main() { int nbf ; int n10 ; int n5 ; int n2 ;

/* /* /* /*

compteur du nombre de façons de faire 1 F */ nombre de pièces de 10 centimes */ nombre de pièces de 5 centimes */ nombre de pièces de 2 centimes */

nbf = 0 ; for (n10=0 ; n10<=10 ; n10++) for (n5=0 ; n5<=20 ; n5++) for (n2=0 ; n2<=50 ; n2++)

III. Le s instructions de contrôle if ( 2*n2 + 5*n5 + 10*n10 == { nbf ++ ; printf ("1 F = ") ; if (n2) printf ("%2d X if (n5) printf ("%2d X if (n10) printf ("%2d X printf ("\n") ; }

33

100)

2c ", n2 ) ; 5c ", n5 ) ; 10c", n10) ;

printf ("\nEn tout, il y a %d façons de faire 1 F\n", nbf) ; }

Exe rcice III.14 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui dé te rm ine la nie m e valeur un (n é tant fourni e n donné e ) de la "suite de Fibonacci" dé finie com m e s uit : u1 = 1 u2 = 1 un = un-1 + un-2

pour n> 2

_______________________________________________________________

Sol ution #include main() { int u1, u2, u3 ; int n ; int i ;

/* pour "parcourir" la suite */ /* rang du terme demandé */ /* compteur */

34

Exe rcice s e n langage C do { printf ("rang du terme demandé (au moins 3) ? ") ; scanf ("%d", &n) ; } while (n<3) ; u2 = u1 = 1 ; i = 2 ; while (i++ < n) { u3 = u1 + u2 ; u1 = u2 ; u2 = u3 ; }

/* les deux premiers termes */ /* attention, l'algorithme ne fonctionne */ /* que pour n > 2 */

/* autre formulation possible : /* for (i=3 ; i<=n ; i++, u1=u2, u2=u3) u3 = u1 + u2 ;

*/ */

printf ("Valeur du terme de rang %d : %d", n, u3) ; }

Note z q ue , com m e à l'accoutum é e e n C, be aucoup de form ulations sont possibles . Nous e n avons d'ailleurs placé une s e conde e n com m e ntaire de notre program m e .

Exe rcice III.15 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui trouve la plus grande e t la plus petite valeur d'une s ucce s s ion de note s (nom bre s e ntie rs e ntre 0 e t 20) fournie s e n donné e s , ainsi que le nom bre de fois où ce m axim um e t ce m inim um ont é té attribué s . O n supposera q ue les note s , e n nom bre non connu à l'avance , s e ront te rm iné e s par une valeur né gative . O n s'astre indra à ne pas utiliser de "tableau". L'e xé cution du program m e pourra s e pré s e nte r ainsi : donnez donnez donnez donnez

une une une une

note note note note

(-1 (-1 (-1 (-1

pour pour pour pour

finir) finir) finir) finir)

: : : :

12 8 13 7

III. Le s instructions de contrôle donnez donnez donnez donnez donnez

une une une une une

note note note note note

(-1 (-1 (-1 (-1 (-1

pour pour pour pour pour

finir) finir) finir) finir) finir)

: : : : :

11 12 7 9 -1

note maximale : 13 attribuée 1 fois note minimale : 7 attribuée 2 fois

_______________________________________________________________

Sol ution #include main() { int int int int int

note ; max ; min ; nmax ; nmin ;

/* /* /* /* /*

note "courante" */ note maxi */ note mini */ nombre de fois où la note maxi a été trouvée */ nombre de fois où la note mini a été trouvée */

max = -1 ; /* initialisation max (possible car toutes notes >=0 */ min = 21 ; /* initialisation min (possible car toutes notes < 21) */ while (printf ("donnez une note (-1 pour finir) : "), scanf ("%d", ¬e), note >=0) { if (note == max) nmax++ ; if (note > max) { max = note ; nmax = 1 ; } if (note == min) nmin++ ; if (note < min) { min = note ; nmin = 1 ; } } /* attention, si aucune note (cad si max<0) */ /* les résultats sont sans signification */ if (max >= 0) { printf ("\nnote maximale : %d attribuée %d fois\n", max, nmax) ;

35

36

Exe rcice s e n langage C printf

("note minimale : %d attribuée %d fois\n", min, nmin) ;

} }

Exe rcice III.16 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui affich e la "table de m ultiplication" de s nom bres de 1 à 10, sous la form e s uivante : I 1 2 3 4 5 6 7 8 9 10 ----------------------------------------------1 I 1 2 3 4 5 6 7 8 9 10 2 I 2 4 6 8 10 12 14 16 18 20 3 I 3 6 9 12 15 18 21 24 27 30 4 I 4 8 12 16 20 24 28 32 36 40 5 I 5 10 15 20 25 30 35 40 45 50 6 I 6 12 18 24 30 36 42 48 54 60 7 I 7 14 21 28 35 42 49 56 63 70 8 I 8 16 24 32 40 48 56 64 72 80 9 I 9 18 27 36 45 54 63 72 81 90 10 I 10 20 30 40 50 60 70 80 90 100

_______________________________________________________________

Sol ution #include #define NMAX 10

/* nombre de valeurs */

main() { int i, j ; /* affichage ligne en-tête */ printf (" I") ; for (j=1 ; j<=NMAX ; j++) printf ("%4d", j) ;

III. Le s instructions de contrôle printf ("\n") ; printf ("-------") ; for (j=1 ; j<=NMAX ; j++) printf ("----") ; printf ("\n") ; /* affichage des différentes lignes */ for (i=1 ; i<=NMAX ; i++) { printf ("%4d I", i) ; for (j=1 ; j<=NMAX ; j++) printf ("%4d", i*j) ; printf ("\n") ; }

37

IV : LES FO NCTIO NS

N.B. Ici, on ne trouve ra aucun e xe rcice faisant inte rve nir de s pointe urs, e t par cons é q ue nt aucun e xe rcice m e ttant e n oe uvre une transm ission d'argum e nts par adre s s e . De te ls e xe rcice s apparaî tront dans le ch apitre s uivant.

Exe rcice IV.1 ___________________________________________________________________________

Enoncé a) Que fournit le program m e s uivant : #include main() { int n, p=5 ; n = fct (p) ; printf ("p = %d, n = %d\n", p, n) ; } int fct (int r) { return 2*r ; }

b) Ajoute r une déclaration conve nable de la fonction fct : - sous la form e la plus brè ve possible (suivant la norm e ANSI),

40

Exe rcice s e n langage C - sous form e d'un "prototype ".

_______________________________________________________________

Sol ution a) Bie n q u'ilne possè de pas de déclaration de la fonction fct, le program m e m ain e s t corre ct. En e ffe t, la norm e ANSI autoris e q u'une fonction ne s oit pas déclaré e , auq ue lcas e lle e s t considérée com m e fournissant un ré s ultat de type int. Ce tte facilité e s t toute fois forte m e nt décons e illée (e t e lle ne s e ra plus acce pté e d e C+ + ). Voici les ré s ultats fournis par le program m e : p = 5, n = 10

b) La déclaration la plus brè ve s e ra : int fct () ;

La déclaration (vive m e nt cons e illée ), sous form e de prototype s e ra : int fct (int) ;

ou, é ve ntue llem e nt, sous form e d'un prototype "com plet" : int fct (int r) ;

D ans ce dernie r cas, le nom r n'a aucune s ignification : on utilise souve nt le m ê m e nom (lors q u'on le connaî t!) q ue dans l'e n-tê te de la fonction, m ais ilpourrait s'agir de n'im porte q ue lautre nom de variable).

Exe rcice IV.2 ___________________________________________________________________________

Enoncé Ecrire :

IV. Le s fonctions 41 - une fonction, nom m é e f1, s e conte ntant d'affich e r "bonjour" (e lle ne possédera aucun argum e nt, ni valeur de re tour), - une fonction, nom m é e f2, q ui affich e "bonjour" un nom bre de fois é galà la valeur re çue e n argum e nt (int) e t q ui ne re nvoie aucune valeur, - une fonction, nom m é e f3, q ui fait la m ê m e ch os e q ue f2, m ais q ui, de plus, re nvoie la valeur (int) 0. Ecrire un pe tit program m e appe lant succe s s ive m e nt ch acune de ce s 3 fonctions, aprè s les avoir conve nablem e nt déclaré e s sous form e d'un prototype . _______________________________________________________________

Sol ution #include void f1 (void) { printf ("bonjour\n") ; } void f2 (int n) { int i ; for (i=0 ; i
42

Exe rcice s e n langage C }

Exe rcice IV.3 ___________________________________________________________________________

Enoncé Quels ré s ultats fournira ce program m e : #include int n=10, q=2 ; main() { int fct (int) ; void f (void) ; int n=0, p=5 ; n = fct(p) ; printf ("A : dans main, n = %d, p = %d, q = %d\n", n, p, q) ; f() ; } int fct (int p) { int q ; q = 2 * p + n ; printf ("B : dans fct, return q ; } void f (void) { int p = q * n ; printf ("C : dans f, }

n = %d, p = %d, q = %d\n", n, p, q) ;

n = %d, p = %d, q = %d\n", n, p, q) ;

_______________________________________________________________

IV. Le s fonctions

43

Sol ution B : dans fct, n = 10, p = 5, q = 20 A : dans main, n = 20, p = 5, q = 2 C : dans f, n = 10, p = 20, q = 2

Exe rcice IV.4 ___________________________________________________________________________

Enoncé Ecrire une fonction q ui re çoit e n argum e nts 2 nom bre s flottants e t un caractè re e t q ui fournit un ré s ultat corre s pondant à l'une des 4 opé rations appliq ué e s à ses deux pre m ie rs argum e nts, e n fonction de la valeur du de rnie r, à savoir : addition pour le caractè re + , soustraction pour -, m ultiplication pour *e t division pour / (tout autre caractè re q ue l'un de s 4 cité s s e ra inte rpré té com m e une addition). O n ne tie ndra pas com pte des ris q ues de division par zé ro. Ecrire un pe tit program m e (m ain) utilisant ce tte fonction pour e ffe ctue r les 4 opé rations sur de ux nom bre s fournis e n donné e . _______________________________________________________________

Sol ution #include float oper (float v1, float { float res ; switch (op) { case '+' : res = v1 + break ; case '-' : res = v1 break ; case '*' : res = v1 * break ; case '/' : res = v1 /

v2, char op)

v2 ; v2 ; v2 ; v2 ;

44

Exe rcice s e n langage C default

break ; : res = v1 + v2 ;

} return res ; }

main() { float oper (float, float, char) ; float x, y ;

/* prototype de oper */

printf ("donnez deux nombres réels : ") ; scanf ("%e %e", &x, &y) ; printf printf printf printf

("leur ("leur ("leur ("leur

somme est : %e\n", oper différence est : %e\n", oper produit est : %e\n", oper quotient est : %e\n", oper

(x, (x, (x, (x,

y, y, y, y,

'+') '-') '*') '/')

) ) ) )

; ; ; ;

}

Exe rcice IV.5 ___________________________________________________________________________

Enoncé Transform e r le program m e (fonction + m ain) é crit dans l'e xe rcice pré cédent de m aniè re à ce q ue la fonction ne dispose plus q ue de 2 argum e nts, le caractè re indiq uant la nature de l'opé ration à e ffe ctue r é tant pré cis é , ce tte fois, à l'aide d'une variable globale. _______________________________________________________________

Sol ution #include

IV. Le s fonctions char op ;

45

/* variable globale pour la nature de l'opération */ /* attention : doit être déclarée avant d'être utilisée */

float oper (float v1, float { float res ; switch (op) { case '+' : res = v1 + break ; case '-' : res = v1 break ; case '*' : res = v1 * break ; case '/' : res = v1 / break ; default : res = v1 + } return res ; }

v2)

v2 ; v2 ; v2 ; v2 ; v2 ;

main() { float oper (float, float) ; /* prototype de oper */ float x, y ; printf ("donnez deux nombres réels : ") ; scanf ("%e %e", &x, &y) ; op = '+' ; printf ("leur somme est : %e\n", oper (x, y) ) ; op = '-' ; printf ("leur différence est : %e\n", oper (x, y) ) ; op = '*' ; printf ("leur produit est : %e\n", oper (x, y) ) ; op = '/' ; printf ("leur quotient est : %e\n", oper (x, y) ) ; }

R e m arque : Ils'agissait ici d'un e xe rcice d'"é cole" destiné à force r l'utilisation d'une variable globale. Dans la pratiq ue , on é vite ra le plus possible ce ge nre de program m ation q ui favoris e trop large m e nt les ris q ues d'"e ffe ts de bord".

46

Exe rcice s e n langage C

Exe rcice IV.6 ___________________________________________________________________________

Enoncé Ecrire une fonction, sans argum e nt ni valeur de re tour, q ui s e conte nte d'affich e r, à ch aq ue appe l, le nom bre totalde fois où e lle a é té appe lée s ous la form e : appel numéro 3

_______________________________________________________________

Sol ution La m e illeure s olution consiste à pré voir, au s e in de la fonction e n q ue s tion, une variable de clas s e s tatiq ue . Elle s e ra initialisée une seule fois à zé ro (ou à toute autre valeur é ve ntue llem e nt e xplicité e ) au début de l'e xé cution du program m e . Ici, nous avons, de plus, pré vu un pe tit program m e d'essai. #include void fcompte (void) { static int i ; /* il est inutile, mais pas défendu, d'écrire i=0 */ i++ ; printf ("appel numéro %d\n", i) ; } /* petit programme d'essai de fcompte */ main() { void fcompte (void) ; int i ; for (i=0 ; i<3 ; i++) fcompte () ; }

Là e ncore , la dém arch e consistant à utiliser com m e com pte ur d'appe ls une variable globale (q ui de vrait alors ê tre connue du program m e utilisate ur) e s t à proscrire .

IV. Le s fonctions

47

Exe rcice IV.7 ___________________________________________________________________________

Enoncé Ecrire 2 fonctions à un argum e nt e ntie r e t une valeur de re tour e ntiè re pe rm e ttant de préciser si l'argum e nt re çu e s t m ultiple de 2 (pour la pre m iè re fonction) ou m ultiple de 3 (pour la s e conde fonction). Utiliser ces deux fonctions dans un pe tit program m e q ui lit un nom bre e ntie r e t q ui pré cis e s 'ile s t pair, m ultiple de 3 e t/ou m ultiple de 6, com m e dans ce t e xe m ple (ily a de ux e xé cutions) : donnez un entier : 9 il est multiple de 3 _______________ donnez il est il est il est

un entier : 12 pair multiple de 3 divisible par 6

_______________________________________________________________

Sol ution #include int mul2 (int n) { if (n%2) return 0 ; else return 1 ; } int mul3 (int n) { if (n%3) return 0 ; else return 1 ; } main() { int mul2 (int) ;

48

Exe rcice s e n langage C int mul3 (int) ; int n ; printf ("donnez un entier : ") scanf ("%d", &n) ; if (mul2(n)) printf if (mul3(n)) printf if (mul2(n) && mul3(n)) printf }

; ("il est pair\n") ; ("il est multiple de 3\n") ; ("il est divisible par 6\n") ;

V : TA BLEAUX ET PO INTEURS

Exe rcice V.1 ___________________________________________________________________________

Enoncé Quels ré s ultats fournira ce program m e : #include main() { int t [3] ; int i, j ; int * adt ; for (i=0, j=0 ; i<3 ; i++) t[i] = j++ + i ;

/* 1 */

for (i=0 ; i<3 ; i++) printf ("%d ", t[i]) ; printf ("\n") ;

/* 2 */

for (i=0 ; i<3 ; i++) printf ("%d ", *(t+i)) ; printf ("\n") ;

/* 3 */

for (adt = t ; adt < t+3 ; adt++) printf ("%d ", *adt) ; printf ("\n") ;

/* 4 */

for (adt = t+2 ; adt>=t ; adt--) printf ("%d ", *adt) ;

/* 5 */

50

Exe rcice s e n langage C printf ("\n") ; }

_______________________________________________________________

Sol ution /*1*/ re m plit le tableau ave c les valeurs 0 (0+ 0), 2 (1+ 1) e t 4 (2+ 2) ;on obtie ndrait plus sim plem e nt le m ê m e ré s ultat ave c l'e xpre s s ion 2*i. /*2 */ affich e "classiquem e nt" les valeurs du tableau t, dans l'ordre "nature l". /* 3 */ fait la m ê m e ch os e , e n utilisant le form alism e pointe ur au lie u du form alism e tableau. Ainsi, *(t+ i) e s t parfaite m e nt é q uivalent à t[i]. /*4 */ fait la m ê m e ch os e , e n utilisant la "lvalue " adt (à laq ue lle on a affe cté initialem e nt l'adre s s e t du tableau) e t e n "l'incré m e ntant" pour parcourir les diffé re nte s adresses des 4 é lém e nts du tableau. /*5 */ affich e les valeurs de t, à l'e nve rs, e n utilisant le m ê m e form alism e pointe ur q ue dans 4. O n aurait pu é crire , de façon é q uivalente : for (i=2 ; i>=0 ; i--) printf ("%d ", t[i]) ;

Voici les ré s ultats fournis par ce program m e : 0 0 0 4

2 2 2 2

4 4 4 0

Exe rcice V.2 ___________________________________________________________________________

V. Tableaux e t pointe urs

51

Enoncé Ecrire , de deux façons diffé re nte s , un program m e q ui lit 10 nom bre s e ntie rs dans un tableau avant d'en rech e rch e r le plus grand e t le plus petit : a) e n utilisant uniq ue m e nt le "form alism e tableau", b) e n utilisant le "form alism e pointe ur", à ch aq ue fois q ue ce la e s t possible _______________________________________________________________

Sol ution a) La program m ation e s t, ici, "classique". Nous avons sim plem e nt défini un sym bole NVALdestiné à conte nir le nom bre de valeurs du tableau. Note z bie n q ue la déclaration int t[NVAL] e s t acce pté e puis q ue NVAL e s t une "e xpre s s ion constante ". En re vanch e , e lle ne l'aurait pas é té s i nous avions défini ce sym bole NVAL par une "constante sym boliq ue " (const int NVAL = 10). #include #define NVAL 10 main() { int i, min, max ; int t[NVAL] ;

/* nombre de valeurs du tableau */

printf ("donnez %d valeurs\n", NVAL) ; for (i=0 ; i max) max = t[i] ; if (t[i] < min) min = t[i] ; }

/* ou max = t[i]>max ? t[i] : max */ /* ou min = t[i]
printf ("valeur max : %d\n", max) ; printf ("valeur min : %d\n", min) ; }

b) O n pe ut re m place r systé m atiq ue m e nt, t[i] par *(t+ i)./ D e plus, dans scanf, on pe ut re m place r & t[i] par t+ i. Voici finalem e nt le program m e obte nu : #include #define NVAL 10 main() { int i, min, max ;

/* nombre de valeurs du tableau */

52

Exe rcice s e n langage C int t[NVAL] ; printf ("donnez %d valeurs\n", NVAL) ; for (i=0 ; i
/* attention t+i et non *(t+i) */

max = min = *t ; for (i=1 ; i max) max = *(t+i) ; if (*(t+i) < min) min = *(t+i) ; } printf ("valeur max : %d\n", max) ; printf ("valeur min : %d\n", min) ; }

Exe rcice V.3 ___________________________________________________________________________

Enoncé Soie nt deux tableaux t1 e t t2 dé claré s ainsi : float t1[10], t2[10] ;

Ecrire les instructions perm e ttant de re copie r, dans t1, tous les é lém e nts positifs de t2, e n com plétant é ve ntue llem e nt t1 par de s zé ros. Ici, on ne ch e rch e ra pas à fournir un program m e com plet e t on utilisera systé m atiq ue m e nt le form alism e tableau. _______________________________________________________________

Sol ution O n pe ut com m e nce r par re m plir t1 de zé ros, avant d'y re copie r les é lém e nts positifs de t2 : int i, j ; for (i=0 ; i<10 ; i++) t1[i] = 0 ; /* i sert à pointer dans t1 et j dans t2 */ for (i=0, j=0 ; j<10 ; j++)

V. Tableaux e t pointe urs

53

if (t2[j] > 0) t1[i++] = t2[j] ;

M ais, on pe ut re copie r d'abord dans t1 les é lém e nts positifs de t2, avant de com pléte r é ve ntue llem e nt par de s zé ros. Ce tte deuxiè m e form ulation, m oins sim ple q ue la pré cédente , s e ré vé lerait toute fois plus e fficace s ur de grands tableaux : int i, j ; for (i=0, j=0 ; j<10 ; j++) if (t2[j] > 0) t1[i++] = t2[j] ; for (j=i ; j<10 ; j++) t1[j] = 0 ;

Exe rcice V.4 ___________________________________________________________________________

Enoncé Quels ré s ultats fournira ce program m e : #include main() { int t[4] = {10, 20, 30, 40} ; int * ad [4] ; int i ; for (i=0 ; i<4 ; i++) ad[i] = t+i ; for (i=0 ; i<4 ; i++) printf ("%d ", * ad[i]) ; printf ("\n") ; printf ("%d %d \n", * (ad[1] + 1), * ad[1] + 1) ; }

/* 1 */ /* 2 */ /* 3 */

_______________________________________________________________

Sol ution Le tableau ad e s t un tableau de 4 é lém e nts ;ch acun de ce s é lém e nts e s t un pointe ur sur un int. L'instruction /* 1 */ re m plit le tableau ad ave c les adresses des 4 é lém e nts du tableau t. L'instruction /*2 */ affich e finalem e nt les 4 é lém e nts du tableau t ;e n e ffe t, *ad[i] re pré s e nte la valeur situé e à l'adre s s e ad[i]. /*2 */ e s t é q uivalente ici à : for (i=0 ; i<4 ; i++) printf ("%d", t[i]) ;

54 Exe rcice s e n langage C Enfin, dans l'instruction /*3 */, *(ad[1] + 1) re pré s e nte la valeur situé e à l'e ntie r suivant ce lui d'adre s s e ad[1] ;ils'agit donc de t[2]. En re vanch e , *ad[1] + 1 re pré s e nte la valeur situé e à l'adre s s e ad[1] augm e nté e d e 1, autre m e nt dit t[1] + 1. Voici, e n dé finitive , les ré s ultats fournis par ce program m e : 10 20 30 40 30 21

Exe rcice V.5 ___________________________________________________________________________

Enoncé Soit le tableau t déclaré ainsi : float t[3] [4] ;

Ecrire les (s e ules ) instructions perm e ttant de calculer, dans une variable nom m é e som , la som m e d e s é lém e nts de t : a) e n utilisant le "form alism e usueldes tableaux à deux indice s ", b) e n utilisant le "form alism e pointe ur". _______________________________________________________________

Sol ution a) La pre m iè re s olution ne pos e aucun problèm e particulie r : int i, j ; som = 0 ; for (i=0 ; i<3 ; i++) for (j=0 ; j<4 ; j++) som += t[i] [j] ;

b) Le form alism e pointe ur e s t ici m oins facile à appliq ue r q ue dans le cas des tableaux à un indice . En e ffe t, ave c, par e xe m ple, float t[4], t e s t de type int * e t ilcorre s pond à un pointe ur sur le pre m ie r é lém e nt du tableau. Ilsuffit donc d'incré m e nte r conve nablem e nt t pour parcourir tous les é lém e nts du tableau.

V. Tableaux e t pointe urs 55 En re vanch e , ave c notre tableau float t [3] [4], t e s t du type pointe ur sur des tabl eaux de 4 fl ottants(type : float[4] *). La notation *(t+ i) e s t gé né ralem e nt inutilisable s ous ce tte form e puis q ue , d'une part, e lle corre s pond à des valeurs de tableaux de 4 flottants e t q ue , d'autre part, l'incré m e nt i porte , non plus sur de s flottants, m ais sur des blocs de 4 flottants ;par e xe m ple, t+ 2 re pré s e nte l'adresse du h uitiè m e flottant, com pté à partir de ce lui d'adre s s e t. Une s olution consiste à "conve rtir" la valeur de t e n un pointe ur de type float *. O n pourrait s e conte nte r de procéder ainsi : float * adt ; ..... adt = t ;

En e ffe t, dans ce cas, l'affe ctation e ntraî ne une conve rsion forcé e d e t e n float *, ce q ui ne ch ange pas l'adre s s e corre s pondante 1 (s e ule la nature du pointe ur a ch angé ). Gé né ralem e nt, on y gagne ra e n lisibilité e n e xplicitant la conve rsion m ise en oeuvre à l'aide de l'opé rate ur de "cast". Note z q ue , d'une part, ce la pe ut é vite r ce rtains m e s s ages d'ave rtissem e nt ("w arnings") de la part du com pilate ur. Voici finalem e nt ce q ue pourraie nt ê tre les instructions dem andé e s : int int som adt for

i ; * adt ; = 0 ; = (float *) t ; (i=0 ; i<12 ; i++) som += * (adt+i);

Exe rcice V.6 ___________________________________________________________________________

Enoncé Ecrire une fonction q ui fournit e n valeur de re tour la som m e d e s é lém e nts d'un tableau de flottants transm is, ainsi q ue s a dim e nsion, e n argum e nt. Ecrire un pe tit program m e d'essai.

1 Attention, cel a n'e s t vrai q ue parce que l'on passe de pointeurs sur des groupes d'élém ents à un pointeur sur ces élém ents. Autrem ent dit, aucune

"contrainte d'alignem ent" ne risque de nuire ici. Iln'en irait pas de m ê m e, par exem ple, pour des conversions de ch ar *e n int *.

56 Exe rcice s e n langage C _______________________________________________________________

Sol ution En ce q ui conce rne le tableau de flottants re çu e n argum e nt, ilne pe ut ê tre transm is que par adresse. Quant au nom bre d'élém e nt (de type int), nous le transm e ttrons classiquem e nt par valeur. L'e n-tê te de notre fonction pourra s e pré s e nte r sous l'une des form e s s uivante s : float somme (float t[], int n) float somme (float * t, int n) float somme (float t[5], int n)

/* déconseillé car laisse croire que t */ /* est de dimension fixe 5 */

En e ffe t, la dim e nsion ré e lle de t n'a aucune incide nce s ur les instructions de la fonction e lle-m ê m e (e lle n'inte rvie nt pas dans le calculde l'adresse d'un é lém e nt du tableau2 e t e lle ne s e rt pas à "alloue r" un e m place m e nt puis q ue le tableau e n q ue s tion aura é té alloué dans la fonction appe lant som m e ). Voici ce q ue pourrait ê tre la fonction de m andé e : float somme (float t[], int n)

{

int i ; float s = 0 ; for (i=0 ; i
/* on pourrait écrire somme (float * t, ... */ /* ou encore somme (float t[4], ... */ /* mais pas somme (float t[n], ... */

/* on pourrait écrire s += * (t+i) ; */

}

Pour ce q ui e s t du program m e d'utilisation de la fonction som m e , on pe ut, là e ncore , é crire le "prototype " sous diffé re nte s form e s : float somme (float [], int ) ; float somme (float * , int ) ; float somme (float [5], int ) ;

/* déconseillé car laisse croire que t */ /* est de dimension fixe 5 */

Voici un e xe m ple d'un te lprogram m e : #include main() 2Iln'en irait pas de m ê m e pour des tabl eaux à plusieurs indices.

V. Tableaux e t pointe urs

57

{ float somme (float *, int) ; float t[4] = {3, 2.5, 5.1, 3.5} ; printf ("somme de t : %f\n", somme (t, 4) ) ; }

Exe rcice V.7 ___________________________________________________________________________

Enoncé Ecrire une fonction q ui ne re nvoie aucune valeur e t q ui dé te rm ine la valeur m axim ale e t la valeur m inim ale d'un tableau d'entie rs (à un indice ) de taille q ue lconq ue . Ilfaudra donc pré voir 4 argum e nts : le tableau, sa dim e nsion, le m axim um e t le m inim um . Ecrire un pe tit program m e d'essai. _______________________________________________________________

Sol ution En langage C, un tableau ne pe ut ê tre transm is que par adresse (en toute rigue ur, C n'autoris e q ue la transm ission par valeur m ais, dans le cas d'un tableau, on transm e t une valeur de type pointe ur q ui n'e s t rie n d'autre q ue l'adresse du tableau!). En ce q ui conce rne s on nom bre d'élém e nts, on pe ut indiffé re m m e nt e n transm e ttre l'adre s s e (sous form e d'un pointe ur de type int*), ou la valeur ;ici, la s e conde s olution e s t la plus norm ale. En re vanch e , e n ce q ui conce rne le m axim um e t le m inim um , ils ne peuve nt pas ê tre transm is par valeur, puis q u'ils doive nt pré cis é m e nt ê tre déte rm iné s par la fonction. Ilfaut donc obligatoire m e nt pré voir de pas s e r de s pointe urs sur de s float. L'e n-tê te de notre fonction pourra donc s e pré s e nte r ainsi (nous ne donnons plus toute s les é criture s possibles ) : void maxmin (int t[], int n, int * admax, int * admin)

L'algorith m e de re ch e rch e de m axim um e t de m inim um pe ut ê tre calqué s ur ce lui de l'e xe rcice V.2, e n re m plaçant m ax par *adm ax e t m in par *adm in. Ce la nous conduit à la fonction suivante : void maxmin (int t[], int n, int * admax, int * admin)

58

Exe rcice s e n langage C { int i ; *admax = t[1] ; *admin = t[1] ; for (i=1 ; i *admax) *admax = t[i] ; if (t[i] < *admin) *admin = t[i] ; } }

Si l'on souh aite é vite r les "indire ctions" q ui apparais s e nt systé m atiq ue m e nt dans les instructions de com paraison, on pe ut "travailler" te m poraire m e nt sur des variables locales à la fonction (nom m é e s ici m ax e t m in). Ce la nous conduit à une fonction de la form e s uivante : void maxmin (int t[], int n, int * admax, int * admin) { int i, max, min ; max = t[1] ; min = t[1] ; for (i=1 ; i max) max = t[i] ; if (t[i] < min) min = t[i] ; } *admax = max ; *admin = min ; }

Voici un pe tit e xe m ple de program m e d'utilisation de notre fonction : #include main() { void maxmin (int [], int, int *, int *) ; int t[8] = { 2, 5, 7, 2, 9, 3, 9, 4} ; int max, min ; maxmin (t, 8, &max, &min) ; printf ("valeur maxi : %d\n", max) ; printf ("valeur mini : %d\n", min) ; }

V. Tableaux e t pointe urs

59

Exe rcice V.8 ___________________________________________________________________________

Enoncé Ecrire une fonction q ui fournit e n re tour la som m e des valeurs d'un tableau de flottants à dim e nsions sont fournie s e n argum e nt.

deux indices dont les

_______________________________________________________________

Sol ution Par analogie ave c ce q ue nous avions fait dans l'e xe rcice V.6, nous pourrions songe r à déclare r le tableau conce rné dans l'e n-tê te de la fonction sous la form e t[][]. M ais, ce la n'e s t plus possible car, ce tte fois, pour dé te rm ine r l'adresse d'un é lém e nt t[i][j] d'un te ltableau, le com pilate ur doit e n connaî tre la deuxiè m e dim e nsion. Une s olution consiste à considérer qu'on reçoit un pointe ur (de type float*) sur le début du tableau e t d'en parcourir tous les é lém e nts (au nom bre de n*p si n et p dé s igne nt les dim e nsions du tableau) com m e s i l'on avait affaire à un tableau à une dim e nsion. Ce la nous conduit à ce tte fonction : float somme (float * adt, int n, int p) { int i ; float s ; for (i=0 ; i
/* ou s += *(adt+i) */

Pour utiliser une te lle fonction, la s e ule difficulté consiste à lui transm e ttre e ffe ctive m e nt l'adresse de début du tableau, sous la form e d'un pointe ur de type int *. O r, ave c, par e xe m ple t[3][4], t, s'ilcorrre s pond bie n à la bonne adre s s e , e s t du type "pointe ur sur des tableaux de 4 flottants". A priori, toute fois, com pte te nu de la pré s e nce du prototype , la conve rsion voulue s e ra m ise en oeuvre autom atiq ue m e nt par le com pilate ur. Toute fois, com m e nous l'avons déjà dit dans l'e xe rcice V.5, on y gagne ra e n lisibilité (e t e n é ve ntue ls m e s s ages d'ave rtissem e nt!) e n faisant appe là l'opé rate ur de "cast". Voici finalem e nt un e xe m ple d'un te lprogram m e d'utilisation de notre fonction : #include main() {

60

Exe rcice s e n langage C float somme (float *, int, int) ; float t[3] [4] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} } ; printf ("somme : %f\n", somme ((float *)t, 3, 4) ) ; }

VI: LES CH A INES D E CARACTERES

Exe rcice VI.1 ___________________________________________________________________________

Enoncé Quels ré s ultats fournira ce program m e : #include main() { char * ad1 ; ad1 = "bonjour" ; printf ("%s\n", ad1) ; ad1 = "monsieur" ; printf ("%s\n", ad1) ; }

_______________________________________________________________

Sol ution L'instruction ad1 = "bonjour" place dans la variable ad1 l'adresse de la ch aî ne constante "bonjour". L'instruction printf ("%s\n", ad1) s e conte nte d'affich e r la valeur de la ch aî ne dont l'adre s s e figure dans ad1, c'e s t-à -dire , e n l'occurre nce "bonjour". D e m aniè re com parable, l'instruction ad1 = "m onsie ur" place l'adresse de la ch aî ne constante "m onsieur"

62 Exe rcice s e n langage C dans ad1 ;l'instruction printf ("%s\n", ad1) affich e la valeur de la ch aî ne ayant m ainte nant l'adre s s e conte nue dans ad1, c'e s t-à -dire m ainte nant "m onsieur". Finalem e nt, ce program m e affich e tout sim plem e nt : bonjour monsieur

O n aurait obte nu plus sim plem e nt le m ê m e ré s ultat e n é crivant : printf ("bonjour\nmonsieur\n") ;

Exe rcice VI.2 ___________________________________________________________________________

Enoncé Quels ré s ultats fournira ce program m e : #include main() { char * adr = "bonjour" ; int i ; for (i=0 ; i<3 ; i++) putchar (adr[i]) ; printf ("\n") ; i = 0 ; while (adr[i]) putchar (adr[i++]) ; }

/* 1 */ /* 2 */

/* 3 */

_______________________________________________________________

Sol ution La déclaration /*1 */ place dans la variable adr, l'adresse de la ch aî ne constante bonjour. L'instruction /*2 */ affich e les caractè re s adr[0], adr[1] e t adr[2], c'e s t-à -dire les 3 pre m ie rs caractè res de ce tte ch aî ne . L'instruction /*3 */ affich e tous les caractè re s à partir de ce lui d'adre s s e adr, tant q ue l'on a pas affaire à un caractè re nul;com m e notre ch aî ne

VI. Le s ch aî ne s d e caractè re s 63 "bonjour" e s t pré cis é m e nt te rm iné e par un te lcaractè re nul, ce tte instruction affich e finalem e nt, un par un, tous les caractè res de "bonjour". En dé finitive , le program m e fournit sim plem e nt les ré s ultats suivants : bon bonjour

Exe rcice VI.3 ___________________________________________________________________________

Enoncé Ecrire le program m e pré cédent (Exe rcice VI.2), sans util iser l e "form al ism e tabl eau" (ile xiste plusieurs solutions). _______________________________________________________________

Sol ution Voici de ux solutions possibles : a) O n pe ut re m place r systé m atiq ue m e nt la notation adr[i] par *(adr+ i), ce q ui conduit à ce program m e : #include main() { char * adr = "bonjour" ; int i ; for (i=0 ; i<3 ; i++) putchar (*(adr+i)) ; printf ("\n") ; i = 0 ; while (adr[i]) putchar (*(adr+i++)) ; }

b) O n pe ut é galem e nt parcourir notre ch aî ne , non plus à l'aide d'un "indice " i, m ais e n incré m e ntant un pointe ur de type ch ar *: ilpourrait s'agir tout sim plem e nt de adr, m ais généralem e nt, on pré fé re ra ne pas détruire ce tte inform ation e t e n e m ploye r une copie :

64

Exe rcice s e n langage C #include main() { char * adr = "bonjour" ; char * adb ; for (adb=adr ; adb
Note z bie n q ue s i nous incré m e ntions directe m e nt adr dans la pre m iè re instruction d'affich age , nous ne disposerions plus de la "bonne adre s s e " pour la deuxiè m e instruction d'affich age .

Exe rcice VI.4 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui de m ande à l'utilisate ur de lui fournir un nom bre e ntie r e ntre 1 e t 7 e t q ui affich e le nom du jour de la s e m aine ayant le num é ro indiq ué (lundi pour 1, m ardi pour 2, ... dim anch e pour 7). _______________________________________________________________

Sol ution Une dém arch e consiste à cré e r un "tableau de 7 pointe urs sur de s ch aî ne s ", corre s pondant ch acune au nom d'un jour de la s e m aine . Com m e ce s ch aî ne s s ont ici constante s , ile s t possible de cré e r un te ltableau par une déclaration com portant une intialisation de la form e : char * jour [7] = { "lundi", "mardi", ...

N'oublie z pas alors q ue jour[0] contie ndra l'adresse de la pre m iè re ch aî ne , c'e s t-à -dire l'adresse de la ch aî ne constante "lundi" ;jour[1] contie ndra l'adresse de "m ardi", ... Pour affich e r la valeur de la ch aî ne de rang i, ilsuffit de re m arq ue r q ue s on adre s s e e s t sim plem e nt jour[i-1]. D 'où le program m e dem andé :

VI. Le s ch aî ne s d e caractè re s

65

#include main() { char * jour [7] = { "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche" } ; int i ; do { printf ("donnez un nombre entier entre 1 et 7 : ") ; scanf ("%d", &i) ; } while ( i<=0 || i>7) ; printf ("le jour numéro %d de la semaine est %s", i, jour[i-1]) ; }

Exe rcice VI.5 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui lit deux nom bre s e ntie rs fournis obligatoire m e nt sur une m ê m e ligne . Le program m e ne devra pas "s e plante r" e n cas de ré pons e incorre cte (caractè re s invalides) com m e le fe rait scanf ("%d %d", ...) m ais sim plem e nt affich e r un m e s s age e t redem ande r une autre ré pons e . Ildevra e n aller de m ê m e lors q ue la ré pons e fournie ne com porte pas as s e z d'inform ations. En re vanch e , lors q ue la ré pons e com porte ra trop d'inform ations, les derniè re s devront ê tre ignoré e s . Le traite m e nt (dem ande de 2 nom bre s e t affich age ) devra s e poursuivre jus q u'à ce q ue le pre m ie r nom bre fourni soit 0. Voici un e xe m ple d'exécution d'un te lprogram m e : --- donnez deux réponse erronée merci pour 2 15 --- donnez deux réponse erronée merci pour 4 12 --- donnez deux merci pour 4 8 --- donnez deux

entiers : é - redonnez-la : 2 15 entiers : 5 - redonnez-la : 4 12 entiers : 4 8 6 9 entiers : 5 é3

66

Exe rcice s e n langage C réponse erronée - redonnez-la : 5 23 merci pour 5 23 --- donnez deux entiers : 0 0 merci pour 0 0

R e m arque : on pe ut utiliser les fonctions ge ts e t sscanf. _______________________________________________________________

Sol ution Com m e le s uggè re la re m arq ue de l'é noncé , on pe ut ré s oudre les problèm e s pos é s e n e ffe ctuant e n de ux te m ps la lecture d'un couple d'entie rs : - lecture d'une ch aî ne de caractè re s (c'e s t-à -dire une s uite de caractè re s absol um ent quel conques, validée par "re turn") ave c la fonction ge ts, - "décodage " de ce tte ch aî ne ave c sscanf, suivant un "form at", d'une m aniè re com parable à ce q ue fe rait scanf, à partir de s on "tam pon d'e ntré e ". R appe lons q ue sscanf, tout com m e scanf, fournit e n re tour le nom bre d'inform ations corre cte m e nt lue s , de sorte q u'il suffit de ré pé te r les deux opé rations précédente s jus q u'à ce q ue la valeur fournie par sscanf soit é gale à 2. L'é noncé ne fait aucune h ypoth è s e s ur le nom bre m axim alde caractè re s q ue l'utilisate ur pourra ê tre am e né à fournir. Ici, nous avons suppos é q u'au plus 128 caractè re s s e raie nt fournis ;ils'agit là d'une h ypoth è s e q ui, dans la pratiq ue , s'avè re ré aliste , dans la m e s ure où on ris q ue rare m e nt de frappe r de s ligne s plus longue s ;de surcroî t, ils'agit m ê m e d'une lim itation "nature lle" de ce rtains e nvironne m e nts (DOS, e n particulie r). Voici le program m e dem andé : #include #define LG 128 main() { int n1, n2 ; int compte ; char ligne [LG+1] ;

/* longueur maximale d'une ligne */

/* entiers à lire en donnée */ /* pour la valeur de retour de sscanf */ /* pour lire une ligne (+1 pour \0) */

/* boucle de lecture des différents couples de valeurs */ do {

/* boucle de lecture d'un couple de valeur jusqu'à OK */ printf ("--- donnez deux entiers : ") ; do { gets (ligne) ; compte = sscanf (ligne, "%d %d", &n1, &n2) ;

VI. Le s ch aî ne s d e caractè re s

67

if (compte<2) printf ("réponse erronée - redonnez-la : ") ; } while (compte < 2) ; printf ("merci pour %d %d\n", n1, n2) ; } while (n1) ; }

R e m arques 1) Si l'utilisate ur fournit plus de caractè re s q u'iln'e n faut pour form e r 2 nom bre s e ntie rs, ce s caractè re s (lus dans ligne ) ne s e ront pas utilisés par sscanf ;m algré tout, ils ne seront pas e xploité s ulté rie ure m e nt puis q ue , lors q ue l'on redem ande ra 2 nouve aux e ntie rs, on re lira une nouve lle ch aî ne par ge ts. 2) Si l'on souh aite absolum e nt pouvoir lim ite r la longue ur de la ch aî ne lue au clavie r, e n utilisant des instructions 1 "portables ", ilfaut s e tourne r ve rs la fonction fge ts destiné e à lire une ch aî ne dans un fich ie r, e t l'appliq ue r à stdin. O n re m place ra l'instruction ge ts (ligne ) par fge ts (ligne , LG, stdin) q ui lim ite ra à LG le nom bre de caractè re s pris e n com pte . Note z toute fois q ue , dans ce cas, les caractè re s e xcédentaire s (e t donc non "vus" par fge ts) re s te ront disponibles pour une proch aine lecture (ce q ui n'e s t pas pire q ue dans la situation actue lle où ce s caractè re s vie ndraie nt é cras e r de s e m place m e nts m é m oire s itué s au-de là du tableau ligne !). D ans ce rtaine s im plém e ntations (Turbo/Borland C/C+ + e t Quick C/C M icrosoft), il e xiste une fonction (non portable, puis q ue non pré vue par la norm e ANSI) nom m é e cge ts q ui, utilisée à la place de ge ts (ou fge ts) pe rm e t de ré gler le problèm e é voq ué . En e ffe t, cge ts pe rm e t de lire une ch aî ne , e n lim itant le nom bre de caractè re s e ffe ctive m e nt fournis au clavie r : iln'e s t pas possible à l'utilisate ur d'e n frappe r plus q ue pré vu, de s orte q ue le ris q ue de caractè re s e xcédentaire s n'e xiste plus!

Exe rcice VI.6 ___________________________________________________________________________

1 M ais, si vous réal isez ces exercices en accom pagnem ent d'un cours de langage C, ile s t probable q ue vous n'aurez pas e ncore étudié la fonction

fge ts (en général, elle e s t introduite dans le ch apitre relatif au traitem ent des fich iers). Certains e xercices de la s e conde partie de cet ouvrage feront appelà fgets, et/ou à s s canf.

68

Exe rcice s e n langage C

Enoncé Ecrire un program m e déte rm inant le nom bre de lettre s e (m inuscule) conte nues dans un te xte fourni e n donné e s ous form e d'une seule ligne ne dépassant pas 128 caractè re s . O n ch e rch e ra, ici, à n'utiliser aucune des fonctions de traite m e nt de ch aî ne . _______________________________________________________________

Sol ution Com pte te nu de s contrainte s im pos é e s par l'é noncé , nous ne pouvons pas faire appe là la fonction strlen. Pour "e xplore r" notre ch aî ne , nous utiliserons le fait q u'e lle e s t te rm iné e par un caractè re nul(\0]. D'où le program m e propos é : #define LG_LIG 128 #include main() { char ligne [LG_LIG+1] ; int i ; int ne ;

/* pour lire une ligne au clavier +1 pour \0 */ /* pour explorer les différents caractères de ligne */ /* pour compter le nombre de 'e' */

printf ("donnez un texte de moins d'une ligne : \n") ; gets (ligne) ; ne = 0 ; i = 0 ; while (ligne[i])

if (ligne[i++] == 'e') ne++ ;

printf ("votre texte comporte %d lettres e", ne) ; }

Exe rcice VI.7 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui lit, e n donné e , un ve rbe du prem ie r groupe e t q ui e n affich e la conjugaison au pré s e nt de l'indicatif, sous la form e :

VI. Le s ch aî ne s d e caractè re s

69

je chante tu chantes il chante nous chantons vous chantez ils chantent

O n s'assure ra q ue le m ot fourni s e te rm ine bien par "er". O n supposera q u'ils'agit d'un ve rbe ré gulie r ;autre m e nt dit, on adm e ttra q ue l'utilisate ur ne fournira pas un ve rbe te lq ue m ange r (le program m e affich e rait alors : nous m angons!). _______________________________________________________________

Sol ution O n lira "classiquem e nt" un m ot, sous form e d'une ch aî ne à l'aide de la fonction ge ts. Pour vé rifie r sa te rm inaison par "e r", on com pare ra ave c la ch aî ne constante "e r", la ch aî ne ayant com m e adre s s e l'adresse de fin du m ot, dim inué e d e 2. L'adresse de fin se déduira de l'adresse de début e t de la longue ur de la ch aî ne (obte nue par la fonction strlen). Quant à la com paraison voulue , e lle s e fe ra à l'aide de la fonction strcm p ;rappe lons q ue ce tte derniè re re çoit e n argum e nt 2 pointe urs sur de s ch aî ne s e t q u'e lle fournit e n re tour une valeur nulle lors q ue les deux ch aî ne s corre s pondante s s ont é gales e t une valeur non nulle dans tous les autre s cas. Les diffé re nte s pe rsonnes du ve rbe s 'obtie nne nt e n re m plaçant, dans la ch aî ne e n q ue s tion, la te rm inaison "e r" par une te rm inaison approprié e . O n pe ut, pour ce la, utiliser la fonction strcpy q ui re copie une ch aî ne donnée (ici la te rm inaison) à une adresse donné e (ici, ce lle déjà utilisée dans strcm p pour vé rifie r q ue le ve rbe s e te rm ine bien par "er"). Les diffé re nte s te rm inaisons possibles s e ront rangées dans un tableau de ch aî ne s constante s (plus précisém e nt, dans un tableau de pointe urs sur de s ch aî ne s constante s ). Nous fe rons de m ê m e pour les diffé re nts suje ts (je , tu...) ;e n re vanch e , ici, nous ne ch e rch e rons pas à les "concaté ne r" au ve rbe conjugué ;nous nous conte ntons de les é crire , au m om e nt opportun. Voici finalem e nt le program m e dem andé : #include #include #define LG_VERBE 30 /* longueur maximale du verbe fourni en donnée */ main() { char verbe [LG_VERBE+1] ; /* verbe à conjuguer +1 pour \0 */ char * sujet [6] = { "je", "tu", "il", "nous", "vous", "ils"} ; /* sujets */ char * term [6] = { "e", "es", "e", "ons", "ez", "ent" } ;/* terminaisons */ int i ; char * adterm ; /* pointeur sur la terminaison du verbe */

70

Exe rcice s e n langage C do { printf ("donnez un verbe régulier du premier groupe : ") ; gets (verbe) ; adterm = verbe + strlen(verbe) - 2 ; } while (strcmp (adterm, "er") ) ; printf ("conjugaison à l\'indicatif présent :\n") ; for (i=0 ; i<6 ; i++) { strcpy (adterm, term[i]) ; printf ("%s %s\n", sujet[i], verbe) ; } }

R e m arque : rappe lons q ue strcpy re copie (sans aucun contrôle) la ch aî ne dont l'adre s s e e s t fournie e n pre m ie r argum e nt (c'e s t-à -dire , e n fait, tous les caractè re s à partir de ce tte adre s s e , jus q u'à ce q ue l'on re ncontre un \0) à l'adre s s e fournie e n s e cond argum e nt ;de plus, e lle com plète bien le tout ave c un caractè re nulde fin de ch aî ne .

Exe rcice VI.8 ___________________________________________________________________________

Enoncé Ecrire un program m e q ui supprim e toute s les lettre s e (m inuscule) d'un te xte de m oins d'une ligne (ne dépassant pas 128 caractè re s ) fourni e n donné e . O n s'arrange ra pour q ue le te xte ainsi m odifié s oit cré é e n m é m oire , à l a pl ace de l 'ancien. N.B. on pourra utiliser la fonction strch r. _______________________________________________________________

Sol ution La fonction strch r pe rm e t de trouve r un caractè re donné dans une ch aî ne . Elle e s t donc tout à fait approprié e pour localiser les 'e ' ;ilfaut toute fois note r q ue , pour localiser tous les 'e ', ile s t né ce s s aire de ré pé te r l'appe lde ce tte

VI. Le s ch aî ne s d e caractè re s 71 fonction, e n m odifiant à ch aq ue fois l'adresse de début de la ch aî ne conce rné e (ilfaut é vite r de boucler sur la re ch e rch e du m ê m e caractè re 'e '). La fonction strch r fournit l'adre s s e à laq ue lle on a trouvé le pre m ie r caractè re indiq ué (ou la valeur 0 si ce caractè re n'e xiste pas). La suppre s s ion du 'e ' trouvé pe ut s e faire e n re copiant le "re s te " de la ch aî ne à l'adre s s e où l'on a trouvé le 'e '. Voici une s olution possible :

#include #include #define LG_LIG 128 #define CAR 'e'

/* longueur maximum d'une ligne de données */ /* caractère à supprimer */

main() { char ligne [LG_LIG+1] ; char * adr ;

/* pour lire une ligne +1 pour \0 */ /* pointeur à l'intérieur de la ligne */

printf ("donnez un texte de moins d'une ligne : \n") ; gets (ligne) ; adr = ligne ; while (adr = strchr (adr,'e') ) strcpy (adr, adr+1) ; printf ("voici votre texte, privé des caractères %c :\n") ; puts (ligne) ; }

VII : LES STRUCTURES

Exe rcice VII.1 ___________________________________________________________________________

Enoncé Soit le m odè le (type ) de structure s uivant : struct s_point { char c ; int x, y ; } ;

Ecrire une fonction q ui re çoit e n argum e nt une s tructure de type s_point e t q ui e n affich e le conte nu sous la form e : point B de coordonnées 10 12

a) En transm e ttant e n argum e nt la val eur de la structure conce rné e , b) En transm e ttant e n argum e nt l'adresse de la structure conce rné e . D ans les deux cas, on é crira un pe tit program m e d'essai de la fonction ainsi réalisée. _______________________________________________________________

Sol ution a) Voici la fonction de m andé e : #include

74

Exe rcice s e n langage C void affiche (struct s_point p) { printf ("point %c de coordonnées %d %d\n", p.c, p.x, p.y) ; }

Note z q ue s a com pilation né ce s s ite obligatoire m e nt la déclaration du type s_point, c'e s t-à -dire les instructions : struct s_point { char c ; int x, y ; } ;

Voici un pe tit program m e q ui affe cte les valeurs 'A', 10 e t 12 aux diffé re nts ch am ps d'une structure nom m é e s , avant d'en affich e r les valeurs à l'aide de la fonction pré cédente : main() { void affiche (struct s_point) ; struct s_point s ; s.c = 'A' ; s.x = 10 ; s.y = 12 ; affiche (s) ; }

// déclaration (prototype) de affiche

Nature llem e nt, la re m arq ue pré cédente s 'appliq ue é galem e nt ici. En pratiq ue , la déclaration de la structure s_point figure ra dans un fich ie r d'e xte nsion h q ue l'on s e conte nte ra d'incorpore r par #include au m om e nt de la com pilation. D e m ê m e , ile s t né ce s s aire d'inclure stdio.h . b) Voici la nouve lle fonction de m andé e : #include void affiche (struct s_point * adp) { printf ("point %c de coordonnées %d %d\n", adp->c, adp->x, adp->y) ; }

Note z q ue l'on doit, ce tte fois, faire appe là l'opé rate ur -> , à la place de l'opé rate ur point (.), puis q ue l'on "travaille" sur un pointe ur sur une s tructure , e t non plus sur la valeur de la structure e lle-m ê m e . Toute fois l'usage de -> n'e s t pas totalem e nt indispensable, dans la m e s ure où, par e xe m ple, adp-> x e s t é q uivalent à (*adp).x. Voici l'adaptation du program m e d'essai pré cédent : main() {

VII. Le s s tructure s

75

void affiche (struct s_point *) ; struct s_point s ; s.c = 'A' ; s.x = 10 ; s.y = 12 ; affiche (&s) ; }

R e m arque : Au lie u d'affe cte r de s valeurs aux ch am ps c, x e t y de notre s tructure s (dans les deux program m es d'essai), nous pourrions (ici) utiliser les possibilité s d'initial isation offe rte s par le langage C, e n é crivant : struct s_point s = {'A', 10, 12} ;

Exe rcice VII.2 ___________________________________________________________________________

Enoncé Ecrire une fonction q ui "m e t à zé ro" les diffé re nts ch am ps d'une structure du type s_point (défini dans l'e xe rcice pré cédent) q ui lui e s t transm ise en argum e nt. La fonction ne com porte ra pas de valeur de re tour. _______________________________________________________________

Sol ution Ici, bie n q ue l'é noncé ne le pré cis e pas, ile s t né ce s s aire de transm e ttre à la fonction conce rné e , non pas la valeur, m ais l'adresse de la structure à "re m e ttre à zé ro". Voici la fonction de m andé e (ici, nous avons re produit la déclaration de s_point) : #include struct s_point { char c ; int x, y ; } ; void raz (struct s_point * adr)

76

Exe rcice s e n langage C {

adr->c = 0 ; adr->x = 0 ; adr->y = 0 ;

}

Voici, à titre indicatif, un pe tit program m e d'essai (sa com pilation né ce s s ite la déclaration de s_point, ainsi que le fich ie r stdio.h ) : main() { struct s_point p ; void raz (struct s_point *) ; // déclaration de raz raz (&p) ; /* on écrit c en %d pour voir son code */ printf ("après : %d %d %d", p.c, p.x, p.y) ; }

Exe rcice VII.3 ___________________________________________________________________________

Enoncé Ecrire une fonction q ui re çoit e n argum e nt l'adresse d'une s tructure du type s_point (défini dans l'e xe rcice VII.1) e t q ui re nvoie e n ré s ultat une s tructure de m ê m e type corre s pondant à un point de m ê m e nom (c) e t de coordonné e s oppos é e s . Ecrire un pe tit program m e d'essai. _______________________________________________________________

Sol ution Bie n q ue l'é noncé ne pré cis e rie n, le ré s ultat de notre fonction ne pe ut ê tre transm is que par valeur. En e ffe t, ce ré s ultat doit ê tre cré é au s e in de la fonction e lle-m ê m e ;ce la signifie q u'ils e ra dé truit dè s la sortie de la fonction ;e n transm e ttre l'adre s s e re vie ndrait à re nvoye r l'adre s s e d e q ue lque ch ose destiné à disparaî tre ... Voici ce q ue pourrait ê tre notre fonction (ici, e ncore , nous avons re produit la déclaration de s_point) : #include struct s_point { char c ;

VII. Le s s tructure s

77

int x, y ; } ; struct s_point sym (struct s_point * adr) { struct s_point res ; res.c = adr->c ; res.x = - adr->x ; res.y = - adr->y ; return res ; }

Note z la "dissym é trie " d'instructions te lles q ue re s .c = adr-> c ;on y fait appe là l'opé rate ur . à gauch e e t à l'opé rate ur -> à droite (on pourrait ce pe ndant é crire re s .c = (*adr).c. Voici un e xe m ple d'essai de notre fonction (ici, nous avons utilisé les possibilités d'initialisation d'une s tructure pour donne r de s valeurs à p1) : main() { struct s_point sym (struct s_point *) ; struct s_point p1 = {'P', 5, 8} ; struct s_point p2 ; p2 = sym (&p1) ; printf ("p1 = %c %d %d\n", p1.c, p1.x, p1.y) ; printf ("p2 = %c %d %d\n", p2.c, p2.x, p2.y) ; }

Exe rcice VII.4 ___________________________________________________________________________

Enoncé Soit la structure s uivante , re pré s e ntant un point d'un plan : struct s_point { char c ; int x, y ; } ;

1) Ecrire la déclaration d'un tableau (nom m é courbe ) de NP points (NP supposé défini par une instruction #de fine ) 2) Ecrire une fonction (nom m é e affich e ) q ui affich e les valeurs des diffé re nts "points" du tableau courbe , transm is en argum e nt, sous la form e :

78

Exe rcice s e n langage C point D de coordonnées 10 2

3) Ecrire un program m e q ui : - lit e n données des valeurs pour le tableau courbe ;on utilisera de préfé re nce les fonctions ge ts e t sscanf, de pré fé re nce à scanf (voir é ve ntue llem e nt l'e xe rcice VI.5) ;on supposera q u'une ligne de donnée ne peut pas dépas s e r 128 caractè re s , - fait appe là la fonction pré cédente pour les affich e r. _______________________________________________________________

Sol ution 1) Ilsuffit de déclare r un tableau de s tructure s : struct s_point courbe [NP] ;

2) Com m e courbe e s t un tableau, on ne pe ut q u'e n transm e ttre l'adre s s e e n argum e nt de affich e . Ile s t pré fé rable de pré voir é galem e nt e n argum e nt le nom bre de points. Voici ce q ue pourrait ê tre notre fonction : void affiche (struct s_point courbe [], int np) /* courbe : adresse de la première structure du tableau */ /* (on pourrait écrire struct s_point * courbe) */ /* np : nombre de points de la courbe */ { int i ; for (i=0 ; i
Com m e pour n'im porte q ue ltableau à une dim e nsion transm is en argum e nt, ile s t possible de ne pas e n m e ntionne r la dim e nsion dans l'e n-tê te de la fonction. Bie n e nte ndu, com m e , e n fait, l'ide ntificate ur courbe n'e s t q u'un pointe ur de type s_point*(pointe ur sur la pre m iè re s tructure du tableau), nous aurions pu égalem e nt é crire s_point*courbe . Note z q ue , com m e à l'accoutum é e , le "form alism e tableau" e t le "form alism e pointe ur" pe uve nt ê tre indiffé re m m e nt utilisés (voire com biné s ). Par e xe m ple, notre fonction aurait pu é galem e nt s'é crire : void affiche (struct s_point * courbe, int np) { struct s_point * adp ; int i ;

VII. Le s s tructure s

79

for (i=0, adp=courbe ; ic, courbe->x, courbe->y) ; }

3) Com m e nous avons appris à le faire dans l'e xe rcice VI.5, nous lirons les inform ations re lative s aux diffé re nts points à l'aide des deux fonctions : - ge ts, pour lire , sous form e d'une ch aî ne , une ligne d'inform ation, - sscanf, pour dé code r suivant un form at le conte nu de la ch aî ne ainsi lue . Voici ce q ue pourrait le program m e dem andé (ici, nous avons re produit, à la fois la déclaration de s_point e t la fonction affich e pré cédente ) : #include struct s_point { char c ; int x, y ; } ; #define NP 10 /* nombre de points d'une courbe */ #define LG_LIG 128 /* longueur maximale d'une ligne de donnée */ main() { struct s_point courbe [NP] ; int i ; char ligne [LG_LIG+1] ; void affiche (struct s_point [], int) ; /* lecture des différents points de la courbe */ for (i=0 ; i
80

Exe rcice s e n langage C

Exe rcice VII.5 ___________________________________________________________________________

Enoncé Ecrire le program m e de la q ue s tion 3 de l'e xe rcice pré cédent, sans util iser de structures. O n pré voira toujours une fonction pour lire les inform ations re lative s à un point. _______________________________________________________________

Sol ution Ici, ilnous faut obligatoire m e nt pré voir 3 tableaux diffé re nts de m ê m e taille : un pour les nom s de points, un pour leurs abscis s e s e t un pour leurs ordonné e s . Le program m e ne pré s e nte pas de difficulté s particuliè re s (son principalinté rê t e s t d'ê tre com paré au pré cédent!). #include #define NP 10 /* nombre de points d'une courbe */ #define LG_LIG 128 /* longueur maximale d'une ligne de donnée */ main() { char c [NP] ; /* noms des différents points */ int x [NP] ; /* abscisses des différents points */ int y [NP] ; /* ordonnées des différents points */ int i ; char ligne [LG_LIG+1] ; void affiche (char [], int[], int[], int) ; /* lecture des différents points de la courbe */ for (i=0 ; i
VII. Le s s tructure s

81

void affiche (char c[], int x[], int y[], int np) { int i ; for (i=0 ; i
Exe rcice VII.6 ___________________________________________________________________________

Enoncé Soie nt les deux m odè les de structure date e t pe rsonne déclaré s ainsi : #define LG_NOM 30 struct date { int jour ; int mois ; int annee ; } ; struct personne { char nom [LG_NOM+1] ; /* chaîne de caractères représentant le nom */ struct date date_embauche ; struct date date_poste ; } ;

Ecrire une fonction q ui re çoit e n argum e nt une s tructure de type pe rsonne e t q ui e n re m plit les diffé re nts ch am ps ave c un dialogue s e pré s e ntant sous l'une des 2 form e s s uivante s : nom : DUPONT date embauche (jj mm aa) : 16 1 75 date poste = date embauche ? (O/N) : O

nom : DUPONT date embauche (jj mm aa) : 10 3 81 date poste = date embauche ? (O/N) : N date poste (jj mm aa) : 23 8 91

82 Exe rcice s e n langage C _______________________________________________________________

Sol ution Notre fonction doit m odifie r le conte nu d'une s tructure de type pe rsonne ;ile s t donc né ce s s aire q u'e lle e n re çoive l'adre s s e e n argum e nt. Ici, l'é noncé n'im posant aucune prote ction particuliè re conce rnant les lecture s au clavie r, nous lirons "classiquem e nt" le nom par ge ts e t les trois autre s inform ations num é riq ue s par scanf. Voici ce q ue pourrait ê tre la fonction de m andé e : void remplit (struct personne * adp) { char rep ; /* pour lire une réponse de type O/N */ printf ("nom : ") ; gets (adp->nom) ;

/* attention, pas de contrôle de longueur */

printf ("date embauche (jj mm aa) : ") ; scanf ("%d %d %d", &adp->date_embauche.jour, &adp->date_embauche.mois, &adp->date_embauche.annee) ; printf ("date poste = date embauche ? (O/N) : ") ; getchar () ; rep = getchar () ; /* premier getchar pour sauter \n */ if (rep == 'O') adp->date_poste = adp->date_embauche ; else { printf ("date poste (jj mm aa) : ") ; scanf ("%d %d %d", &adp->date_poste.jour, &adp->date_poste.mois, &adp->date_poste.annee) ; } }

Note z q ue , com m e à l'accoutum é e , dè s lors q u'une lecture de valeurs num é riq ue s (ici par scanf) e s t suivie d'une lecture d'un caractè re (ici par ge tch ar, m ais le m ê m e problèm e s e pos e rait ave c scanf e t le code %c), ile s t né ce s s aire de "saute r" artificie llem e nt le caractè re ayant s e rvi à la validation de la derniè re inform ation num é riq ue ;e n e ffe t, dans le cas contraire , c'e s t pré cis é m e nt ce caractè re (\n) q ui e s t pris e n com pte . En toute rigue ur, la dém arch e ainsi utilisée n'est pas infaillible : si l'utilisate ur fournit des inform ations supplém e ntaire s aprè s la derniè re valeur num é riq ue (ne s e rait-ce q u'un sim ple e s pace ), le caractè re lu ulté rie ure m e nt ne s e ra pas ce lui atte ndu. Toute fois, ils'agit alors des "problèm e s h abitue ls" lié s à la fourniture d'inform ations e xcédentaire s . Ils peuve nt ê tre ré s olus par diffé re nte s te ch niq ues dont nous avons parlé, notam m e nt, dans l'e xe rcice VI.5.

VII. Le s s tructure s 83 Voici, à titre indicatif, un pe tit program m e d'essai de notre fonction (sa com pilation né ce s s ite les déclarations des structure s date e t pe rsonne ) : main() { struct personne bloc ; remplit (&bloc) ; printf ("nom : %s \n date embauche : %d %d %d \n date poste : %d %d %d", bloc.nom, bloc.date_embauche.jour, bloc.date_embauche.mois, bloc.date_embauche.annee, bloc.date_poste.jour, bloc.date_poste.mois, bloc.date_poste.annee ) ; }

D EUXIEM E PARTIE : EXERCICES TH EM A TIQUES

INTRO D UCTIO N A LA D EUXIEM E PARTIE

Ce ch apitre vous fournit q ue lque s e xplications conce rnant la m aniè re dont sont conçus les problèm e s proposés dans ce tte deuxiè m e partie de l'ouvrage e t les q ue lque s rè gles q ue nous nous som m e s fixé e s pour la rédaction de s program m e s corre s pondants.

1 - Cane vas com m un à ch aq ue e xe rcice Pour ch aq ue e xe rcice , nous avons adopté le m ê m e cane vas.

a)L'e xpos é du probl è me Ile s t constitué d'un énoncé accom pagné d'un exem ple. Ce t e ns e m ble constitue ce q u'ile s t indispensable de lire avant de te nte r de ré s oudre le problèm e . Ce rte s , l'e xe m ple pe rm e t d'illustre r e t de concré tiser l'é noncé m ais, de plus, ille pré cis e , e n particulie r e n e xplicitant la m aniè re dont le program m e dialogue ave c l'utilisate ur. O n note ra q ue ce t e xe m ple corre s pond e xacte m e nt à une im age d'écran obte nue ave c le program m e propos é e n solution.

b)L'anal yse Elle s pé cifie (ou pré cis e ) les algorith m e s à m e ttre e n oe uvre pour aboutir à une solution. Elle garde un caractè re gé né ral; notam m e nt, e lle é vite de s'inté re s s e r à ce rtains détails de program m ation dont le ch oix e s t re je té au m om e nt de l'é criture du program m e . A priori, e lle fait déjà partie de la solution ;toute fois, si vous s é ch e z sur l'é noncé lui-m ê m e , rie n ne vous e m pê ch e , aprè s la lecture de ce tte analyse, de te nte r d'é crire le program m e corre s pondant. En e ffe t, un te le xe rcice , bie n

86 Exe rcice s e n langage C q ue lim ité à la sim ple traduction d'un algorith m e dans un langage , n'e n possè de pas m oins un inté rê t propre e n ce q ui conce rne l'appre ntissage du langage lui-m ê m e .

c)Le program m e Bie n q u'ilsuive e xacte m e nt l'analyse proposée, iln'e n re s te pas m oins q u'ilfaille le considérer com m e une rédaction possible parm i beaucoup d'autre s . N'oublie z pas q u'à ce nive au ile s t bien difficile de porte r un juge m e nt de valeur sur les q ualité s ou les défauts de te lle ou te lle rédaction, tant q ue l'on n'a pas précisé les critè re s re te nus (vitesse d'e xé cution, taille m é m oire , clarté de la rédaction, re s pe ct de ce rtaine s rè gles de style, ...) ;ce la e s t d'autant plus vrai q ue ce rtains de ce s critè re s pe uve nt s'avé re r incom patibles e ntre e ux. Ce s re m arq ue s s 'appliq ue nt d'ailleurs déjà aux e xe rcice s propos é s pré cédem m e nt dans la pre m iè re partie de ce t ouvrage m ais ave c m oins d'accuité .

d)Le s com m e ntaire s Ils fournis s e nt ce rtaine s e xplications q ue nous avons jugé e s utiles à la com pré h e nsion du program m e lui-m ê m e . Ilpe ut, par e xe m ple, s'agir : - de rappe ls conce rnant une instruction ou une fonction pe u usuelle, - de justifications de ce rtains ch oix ré alisés uniquem e nt au m om e nt de la rédaction du program m e , - de m ise en évidence de certaine s particularité s ou originalités du langage , - e tc.

e )La dis cus s ion Elle constitue une s orte d'ouve rture fondé e s ur une ré flexion de caractè re gé né ralq ui pe ut porte r sur : - les insuffisance s é ve ntue lles du program m e propos é , notam m e nt e n ce q ui conce rne s on com porte m e nt face à des e rre urs de la part de l'utilisate ur, - les am é liorations q u'ile s t possible de lui apporte r, - une gé né ralisation du problèm e pos é , - e tc.

Introduction à la de uxiè m e partie

2 - Prote ction de s program m e s par rapport aux donné e s

87

Com m e beaucoup d'autre s langage s , les instructions usuelles de lecture au clavie r du langage C ne s ont pas totalem e nt proté gées d'é ve ntue lles ré pons e s incorre ctes de la part de l'utilisate ur. Ce lles -ci pe uve nt e ntraî ne r un com porte m e nt anorm aldu program m e . D 'une m aniè re gé né rale, ce problèm e de contrôle des données peut ê tre ré s olu par l'e m ploi de te ch niq ue s approprié e s te lles q ue ce lles q ue nous avons re ncontrées dans l'e xe rcice VI.5 de la pre m iè re partie . Toute fois, ce lles -ci pré s e nte nt l'inconvé nie nt d'alourdir le te xte du program m e . C'e s t pourq uoi nous avons é vité d'introduire systé m atiq ue m e nt de te lles prote ctions dans tous nos exem ples , ce q ui aurait m anife s te m e nt m as q ué l'obje ctif e s s e ntie lde l'e xe rcice (bie n e nte ndu, ce s prote ctions pourraie nt deve nir indispe nsables dans un program m e ré e l). Note z toute fois q ue ce rtains e xe rcice s , de par leur nature m ê m e , re q uiè re nt une te lle prote ction ;ce lle-ci s e ra alors claire m e nt dem andée dans l'é noncé lui-m ê m e .

3 - A propos d e s s tructure s de boucl e En principe , lors q ue l'analyse d'un problèm e fait inte rve nir une ré pé tition, ilfaudrait, pour ê tre com plet, e n pré cis e r le type : - ré pé tition définie (ou ave c com pte ur) : e lle e s t ré alisée en C ave c l'instruction for, - ré pé tition tant q u e , dans laq ue lle le te s t de poursuite a lie u e n début de boucle : e lle e s t ré alisée en C ave c l'instruction w h ile, - ré pé tition jusqu'à dans laq ue lle le te s t d'arrê t a lie u e n fin de boucle : e lle e s t ré alisée en C ave c l'instruction do ... w h ile. En fait, ile xiste plusieurs raisons de ne pas toujours spé cifie r le ch oix du type d'une répétition au nive au de l'analyse et de le re porte r au nive au de l'é criture du program m e : - d'une part, le ch oix d'un type de boucle n'e s t pas toujours dicté im pé rative m e nt par le problèm e : par e xe m ple, un algorith m e utilisant une ré pé tition de type jusqu'à pe ut toujours ê tre transform é e n un algorith m e utilisant une ré pé tition de type tant q u e , - d'autre part, com m e nous l'avons déjà e ntre vu dans le ch apitre III de la pre m iè re partie , le langage C autorise des form es de ré pé tition plus varié e s q ue les trois q ue nous ve nons d'évoq ue r (e t q ui sont ce lles propos é e s classiquem e nt par la "program m ation structuré e ") : ainsi, par e xe m ple : *grâ ce à la notion d'opé rate ur s é q ue ntie l, on pe ut ré aliser, à l'aide de l'instruction w h ile, des boucles dans les q ue lles le te s t de poursuite a lie u, non plus e n début, m ais e n cours de boucle, *l'instruction bre ak autorise des boucles à sortie s m ultiples .

88 Exe rcice s e n langage C Ce rte s , on pe ut obje cte r q ue ce s ont là des possibilité s q ui sont contraire s à l'e s prit de la program m ation structuré e . Ce pe ndant, utilisées à bon e s cie nt, e lles pe uve nt am é liore r la concision et le te m ps d'exécution de s program m e s . Com pte te nu de l'orie ntation du langage C, ilne nous a pas paru opportun de nous prive r totalem e nt de ce s facilité s . En dé finitive , ilnous arrive ra souve nt, au cours de l'analyse, de nous conte nte r de pré cis e r la (ou les ) condition(s) d'arrê t d'une ité ration e t de re porte r au nive au de la program m ation m ê m e le ch oix de s instructions à utiliser. On note ra q u'e n procédant ainsi un effort de ré flexion logiq ue pe ut re s te r né ce s s aire au m om e nt de la rédaction du program m e , laq ue lle, dans ce cas, s e trouve ê tre plus q u'une s im ple traduction litté rale!

4 - A propos d e s fonctions a) Com m e nous l'avons déjà re m arq ué dans l'avant-propos, la norm e ANSI acce pte deux form es de définition de fonctions. Voici, par e xe m ple, deux façons d'écrire l'e n-tê te d'une fonction fct re ce vant deux argum e nts de type int e t ch are t re nvoyant une valeur de type double : double fct (int x, char * p)

double fct (x, p) int x ; char * p ;

Ilne s 'agit là q ue de sim ples diffé re nces de rédaction, sans aucune incide nce s ur le plan fonctionne l. Ici, nous avons systé m atiq ue m e nt e m ployé la pre m iè re form e (on la nom m e parfois form e "m ode rne "), dans la m e s ure où e lle a te ndance à s e gé né raliser et où, de plus, ils'agit de la s e ule form e acce pté e par le C+ + .

b) Le s fonctions ont toujours é té déclarées dans les fonctions les utilisant bien q u'a priori : - ce la ne s oit pas obligatoire pour les fonctions fournissant un ré s ultat de type int, - ce la ne s oit pas obligatoire lors q u'une fonction a é té définie , dans le m ê m e s ource , avant d'ê tre utilisée.

c) D ans les déclarations des fonctions, nous avons utilisé la form e prototype autoris é e par le s tandard ANSI. Ce lle-ci s e ré vè le s urtout fort pré cie us e lors q ue l'on e xploite les possibilités de com pilation s é paré e e t q ue l'on a donc affaire à plusieurs fich ie rs source diffé re nts. Ce rte s , ce n'e s t pas le cas ici, m ais, com pte te nu de ce q u'e lle e s t pratiq ue m e nt acce pté e d e tous les com pilate urs actue ls e t q ue , de plus, e lle e s t e s t obligatoire e n C+ + , ilnous a paru judicie ux d'e n faire une h abitude .

I : VARIA TIO NS A LGO RITH M IQUES SUR LES INSTRUCTIO NS D E BASE

Ce ch apitre vous propose des problèm e s ne faisant appe lq u'aux notions de base du langage C, à savoir : - e ntré e s -sortie s conve rsationne lles (ge tch ar, scanf, ge ts, putch ar, printf), - instructions de contrôle, - tableaux, - ch aî ne s , - fonctions.

I-1 Triangl e de Pas cal ______________________________________________________________________________

Enoncé Affich e r un "triangle de Pascal" dont le nom bre de ligne s e s t fourni e n donné e . Nous vous rappe lons q ue les "cas e s " d'un te ltriangle contie nne nt les valeurs des coe fficie nts du binom e C (ou nom bre de com binaisons de n élém e nts pris p à p). n,p

Ce tte valeur e s t placée dans la cas e corre s pondant à l'inte rs e ction de la ligne de rang n e t la colonne de rang p (la num é rotation com m e nçant à 0). O n é vite ra de calculer ch aq ue te rm e s é paré m e nt ;au contraire , on ch e rch e ra à e xploite r la re lation de ré curre nce :

90 C

Exe rcice s e n langage C = C + C

i,j

i-1, j

i-1,j-1

O n lim ite ra à 15 le nom bre de lignes dem andé e s par l'utilisate ur e t on re s pe cte ra la pré s e ntation proposée dans l'e xe m ple ci-de s s ous.

Exe m pl e combien de lignes voulez vous ? 12 p 0 1 2 3 4 5 6 7 8 9 10 11 n ----------------------------------------------------------------0 -1 1 -1 1 2 -1 2 1 3 -1 3 3 1 4 -1 4 6 4 1 5 -1 5 10 10 5 1 6 -1 6 15 20 15 6 1 7 -1 7 21 35 35 21 7 1 8 -1 8 28 56 70 56 28 8 1 9 -1 9 36 84 126 126 84 36 9 1 10 -1 10 45 120 210 252 210 120 45 10 1 11 -1 11 55 165 330 462 462 330 165 55 11 1 ______________________________________________________________________________

ANALYSE A priori, nous pourrions utiliser un tableau t à deux dim e nsions com portant 15x15 é lém e nts e t décide r (arbitraire m e nt) q ue le pre m ie r indice corre s pond au rang d'une ligne du triangle, le s e cond à ce lui d'une colonne . Nous re m plirions alors partie llem e nt ce tableau ave c les valeurs C voulue s (i varie rait de 0 à n-1 si n re pré s e nte le nom bre de ligne s i,j

dem andé e s e t, pour ch aq ue valeur de i, j varie rait de 0 à i). Pour e xploite r la ré curre nce propos é e , ilnous suffirait alors de procéder com m e s uit : - place r la valeur 1 e n t(0,0) (ce q ui constitue la pre m iè re ligne ), - pour ch aq ue ligne de rang i, à partir de i=1, procéder ainsi : *place r la valeur 1 e n t(i,0) e t t(i,i) (e xtré m ités de la ligne de rang i), *pour j variant de 1 à i-1, faire : t(i,j) = t(i-1,j) + t(i-1,j-1)

I. Variations algorith m iques sur les instructions de base 91 En fait, ile s t possible de n'utiliser qu'un tableau à une s e ule dim e nsion, dans leq ue lon vie nt calculer succe s s ive m e nt ch acune des lignes du triangle (ilfaut alors, bie n sûr, affich e r ch aq ue ligne dè s q u'e lle a é té déte rm iné e ). Supposons, en effe t, q u'à un instant donné , nous disposions dans ce tableau t des i+1 valeurs de la ligne de rang i e t voyons com m e nt déte rm ine r ce lles de la ligne de rang i+1. Nous constatons q ue la ré curre nce propos é e pe rm e t de définir la nouve lle valeur d'un é lém e nt de t e n fonction de s on ancie nne valeur e t de l'ancie nne valeur de l'é lém e nt pré cédent. Ce rte s , si nous répétions une affe ctation de la form e : t(j) = t(j) + t(j-1) e n faisant varie r j de 1 à i-1, nous n'aboutirions pas au résultat e s com pté puis q u'alors la valeur de t(j) dépendrait de la nouve lle valeur pré alablem e nt attribué e à t(j-1). M ais, ile s t facile de m ontre r q u'e n e xplorant la ligne de droite à gauch e , c'e s t-à -dire e n ré pé tant l'affe ctation ci-de s s us e n faisant décroî tre j de i-1 à 0, le problèm e ne s e pos e plus. Voici finalem e nt l'algorith m e q ue nous utiliserons : Faire varie r i de 0 à n-1. Pour ch aq ue valeur de i : - ré pé te r, e n faisant décroî tre j de i-1 à 1 : t(j) = t(j) + t(j-1) - place r la valeur 1 dans t(i). R e m arques : 1) Te lq ue l'algorith m e vie nt d'ê tre é noncé , nous constatons q ue pour i=0, j doit décroî tre de -1 à 1! Nous adm e ttrons q ue ce la signifie e n fait q u'aucun traite m e nt n'e s t à ré aliser dans ce cas (ce qui est norm alpuis q ue alors notre ligne e s t réduite à la s e ule valeur 1, laq ue lle s e ra placé e par l'affe ctation t(i)=1). Ile n va de m ê m e pour i=1, j devant alors décroî tre de 0 à 1. O n note ra q u'e n langage C la boucle for pe rm e t de te nir com pte de ce s cas particulie rs (le te s t de poursuite de boucle é tant ré alisé en début). Ce n'e s t toute fois pas là une rè gle gé né ralisable à tous les langage s . 2) Ave c les pré cautions q ue nous ve nons d'évoq ue r, l'algorith m e "s'initialise" de lui-m ê m e .

Program m e #include #define NMAX 15

/* nombre maximal de lignes */

main() { int t [NMAX],

/* tableau représentant une ligne du triangle */

92

Exe rcice s e n langage C nl, i, j ;

/* nombre de lignes souhaitées */ /* indice de la ligne courante */ /* indice courant de colonne */

/* lecture nombre de lignes souhaitées et affichage titres */ printf ("combien de lignes voulez vous ? ") ; scanf ("%d", &nl) ; if (nl > NMAX) nl = NMAX ; printf ("\n\n p ") ; for (i=0 ; i0 ; j--) t[j] = t[j-1] + t[j] ; printf ("%2d --", i) ; for (j=0 ; j<=i ; j++) printf ("%5d", t[j]) ; printf ("\n") ; } }

Com m e ntaire s *En langage C, les indices d'un tableau com m e nce nt à 0. Ici, ce tte particularité s 'avè re inté re s s ante puis q ue nos num é ros de ligne s ou de colonnes doive nt aussi com m e nce r à 0. *Plutôt q ue d'utiliser directe m e nt la constante 15 dans notre program m e , nous avons préfé ré faire appe là l'instruction #de fine du pré proce s s e ur pour dé finir un sym bole NMAX possédant ce tte valeur. Ile s t ainsi beaucoup plus facile, le cas é ch é ant, de m odifie r ce tte valeur (puis q u'ilsuffit alors d'inte rve nir e n un s e ule ndroit du program m e ). Note z q ue nous n'aurions pas pu utiliser la déclaration de constante sym boliq ue (const int NM AX = 15), car, dans ce cas, NM AX n'aurait pas é té une "e xpre s s ion constante ", e t nous n'aurions pas pu l'utiliser com m e dim e nsion d'un tableau. *Ne pas oublie r q ue t[NM A X] ré s e rve NMAX élém e nts (c'e s t-à -dire 15), dont les indice s varie nt de 0 à 14.

I. Variations algorith m iques sur les instructions de base

93

*Si l'utilisate ur de m ande un nom bre de ligne s s upé rie ur à NMAX, le program m e s e conte nte de lim ite r ce tte dem ande à la valeur NM A X.

D ISCUSSIO N *Nous aurions pu te nir com pte de la sym é trie de ch aq ue ligne par rapport à son ce ntre ;q ue lque s instructions supplém e ntaire s nous auraie nt alors perm is une légè re réduction du te m ps de calcul. *L'é noncé lim itait à 15 le nom bre de lignes de notre triangle. En e ffe t, au-de là, iln'e s t gé né ralem e nt plus possible d'affich e r toute s les valeurs sur une s e ule ligne d'écran. *Notre program m e n'e s t pas proté gé dans le cas où l'utilisate ur fournit une ré pons e non num é riq ue à la q ue s tion pos é e . D ans ce cas, toute fois, la situation n'e s t pas trè s grave ;e n e ffe t, la valeur de nle s t, ce rte s , aléatoire m ais, de toute façon, e lle s e ra lim ité e à 15 par le program m e . Si vous souh aitie z q uand m ê m e traite r ce type d'anom alie , ilvous suffirait d'exam ine r le code de re tour de la fonction scanf (ilfournit le nom bre de valeurs conve nablem e nt lue s ) e t de vé rifie r q u'ile s t bien égalà 1.

I-2 Cribl e d'Eratos th è ne ________________________________________________________________________________________

Ile xiste une m é th ode de déte rm ination de nom bre s pre m ie rs connue s ous le nom de "crible d'Erastoth è ne ". Elle pe rm e t d'obte nir tous les nom bre s pre m ie rs infé rie urs à une valeur donné e n. La m é th ode (m anue lle) consiste à dre s s e r une liste des nom bre s considérés (de 1 à n) e t à y raye r tous les nom bre s m ultiples d'autre s e ntie rs (de te ls nom bre s s ont né ce s s aire m e nt non pre m ie rs). Plus précisém e nt, on procè de ainsi : 1 - on raye le 1 (q ui, par dé finition, n'e s t pas un nom bre pre m ie r). 2 - on re ch e rch e , à partir du de rnie r nom bre pre m ie r considéré (la pre m iè re fois, on convie nt q u'ils'agit du 1), le pre m ie r nom bre non rayé (on pe ut m ontre r q u'ile s t pre m ie r). Ildevie nt, à son tour, le dernie r nom bre pre m ie r considéré e t on raye tous s e s m ultiples . 3 - on ré pè te le point 2 jus q u'à ce q ue le nom bre pre m ie r considéré soit supérieur à la racine carré e d e n. O n pe ut alors m ontre r q ue tous les nom bre s non pre m ie rs ont é té rayés de la liste .

94

Exe rcice s e n langage C

Enoncé Ecrire un program m e bas é s ur ce tte m é th ode re ch e rch ant tous les nom bre s pre m ie rs com pris e ntre 1 e t n (la valeur de n é tant fixée dans le program m e )

Exe m pl e entre 1 et 1000, les nombres premiers sont : 2 3 5 7 11 13 31 37 41 43 47 53 73 79 83 89 97 101 127 131 137 139 149 151 179 181 191 193 197 199 233 239 241 251 257 263 283 293 307 311 313 317 353 359 367 373 379 383 419 421 431 433 439 443 467 479 487 491 499 503 547 557 563 569 571 577 607 613 617 619 631 641 661 673 677 683 691 701 739 743 751 757 761 769 811 821 823 827 829 839 877 881 883 887 907 911 947 953 967 971 977 983

17 59 103 157 211 269 331 389 449 509 587 643 709 773 853 919 991

19 61 107 163 223 271 337 397 457 521 593 647 719 787 857 929 997

23 67 109 167 227 277 347 401 461 523 599 653 727 797 859 937

29 71 113 173 229 281 349 409 463 541 601 659 733 809 863 941

________________________________________________________________________________________

ANALYSE La m é th ode m anue lle s uggè re d'utiliser un tableau. Toute fois, devons-nous, par analogie , y range r les nom bre s e ntie rs de 1 à n?En fait, ce la ne s e rait guè re utile puis q ue alors ch aq ue nom bre s e rait é galà son rang dans le tableau (du m oins, à une unité prè s, suivant les conve ntions q ue l'on adopte rait pour l'indice du prem ie r é lém e nt). En ré alité , le bon déroulem e nt de l'algorith m e nous im pos e s e ulem e nt d'ê tre e n m e s ure de faire corre s pondre à ch aq ue e ntie r e ntre 1 e t n, une inform ation pré cisant, à ch aq ue instant, s'ile s t rayé ou non (ce tte inform ation pouvant é volue r au fildu déroulem e nt du program m e ). Ils'agit là tout nature llem e nt d'une inform ation de type "logiq ue " (vrai ou faux). Com m e ce type n'e xiste pas e n tant q ue te le n langage C, nous le s im ulerons à l'aide de deux constante s e ntiè re s : VR A I de valeur 1, FAUX de valeur 0. Note z q ue le ch oix de la valeur 0 pour FAUX est im pos é par la m aniè re dont le langage

I. Variations algorith m iques sur les instructions de base 95 C considè re une e xpre s s ion num é riq ue apparaissant dans une condition ;la valeur 1, par contre , pourrait ê tre , sans inconvé nie nt, re m placé e par n'im porte q ue lle valeur non nulle. Notons raye un te ltableau e t supposons q ue raye [i] corre s pond à l'e ntie r i (ce q ui, com pte te nu de s conve ntions du langage C, signifie q ue raye [0] e s t inutilisé). Notre algorith m e nous im pose de garde r la trace du dernier nom bre pre m ie r considéré. Nous le nom m e rons pre m . La dém arch e m anue lle s e transpose alors com m e s uit : *Initialisation : - m e ttre à FAUX tous les é lém e nts du tableau raye , - m e ttre à FAUX le pre m ie r é lém e nt de raye , e t faire : pre m = 1 *Ité ration : - re ch e rch e r, à partir de pre m , le pre m ie r nom bre non e ncore rayé , c'e s t-à -dire incré m e nte r la valeur de pre m jus q u'à ce q ue t[pre m ] soit FAUX (en toute rigue ur, ilfaut se dem ande r s'ile xiste e ncore un te lnom bre dans notre tableau, e t donc lim ite r l'incré m e ntation de pre m à N). - raye r tous les m ultiples de pre m , dans le cas où un te lnom bre a é té trouvé . *L'ité ration propos é e pe ut ê tre ré pé té e , indiffé re m m e nt (les deux form ulations é tant é q uivalentes dè s q ue N est supérieur ou égalà 1) : - jusqu'à ce q ue la valeur de pre m soit supérieure à la racine carrée de N, - ou tant q u e la valeur de pre m e s t infé rie ure ou é gale à la racine carrée de N.

Program m e

#include #define N 1000 #define VRAI 1 #define FAUX 0 main() { int raye [N+1], prem, na, i ;

/* plus grand entier à examiner */ /* pour "simuler" des ..... */ /* ..... valeurs logiques */

/* tableau servant de crible */ /* dernier nombre premier considéré */ /* compteur de nombres affichés */

/* initialisations */ for (i=1 ; i<=N ; i++)

/* mise à zéro du crible */

96

Exe rcice s e n langage C raye[i] = FAUX ; raye[1] = VRAI ;

/* on raye le nombre 1 */

/* passage au crible */ prem = 1 ; while (prem*prem <= N) { while (raye[++prem] && prem
Com m e ntaire s *La re ch e rch e du prem ie r nom bre non e ncore rayé est ré alisée par la s e ule instruction : while (raye[++prem] && prem
Note z bie n la pré -incré m e ntation de pre m ;une post-incré m e ntation : while (t[prem++] && prem
aurait conduit à une boucle infinie s ur le pre m ie r nom bre pre m ie r trouvé , c'e s t-à -dire 2 (du m oins si N est supérieur ou é galà 2). Ilsuffirait toute fois d'incré m e nte r pre m une fois avant d'entre r dans la boucle pour q ue ce la fonctionne . *Nous avons cons e rvé le garde -fou : prem < N

I. Variations algorith m iques sur les instructions de base 97 O n pourrait toute fois dém ontre r q ue , dè s q ue N est supérieur ou égalà 2, on e s t toujours assuré de trouve r au m oins un nom bre non rayé avant la fin du tableau (com pte te nu de ce q ue l'on com m e nce l'e xploration ave c un nom bre infé rie ur ou é galà la racine carrée de N). *Nous avons prévu d'affich e r nos nom bre s pre m ie rs, à raison de 10 par ligne , ch aq ue nom bre occupant 7 caractè re s . Pour ce faire , nous utilisons une variable nom m é e na nous perm e ttant de com ptabiliser le nom bre de nom bre s affich é s . A ch aq ue fois q ue na e s t m ultiple de 10, nous provoq uons un saut de ligne .

D ISCUSSIO N *Te lq u'ile s t propos é ici, le program m e traite le cas n=1000. Pour le faire fonctionne r ave c d'autre s valeurs, ile s t né ce s s aire d'inte rve nir au nive au du program m e lui-m ê m e e t de le re com piler. Si vous souh aite z q ue la valeur de n puis s e ê tre fournie e n donné e , ilfaut lui fixe r une valeur m axim ale, afin de pré voir la ré s e rvation du tableau corre s pondant. Note z toute fois q ue les possibilités de ge s tion dynam iq ue du langage C offre nt une s olution plus agré able à ce problèm e de dim e nsions variables . Vous e n trouve re z ce rtains e xe m ples dans le ch apitre consacré à la ge s tion dynam iq ue . *Le tableau raye , ainsi que les variables pre m e t i, ont é té déclarés de type int, ce q ui, dans ce rtaine s im plém e ntations, pe ut lim ite r à 32767 les valeurs q u'ile s t ainsi possible d'exam ine r. O n pe ut toujours faire m ie ux, e n utilisant le type unsigne d int, ou m ie ux le type long ou unsigne d long. Toute fois, dans ce cas, on s'assure ra q ue l'on n'e s t pas soum is à des contrainte s s ur la taille des diffé re nts m odules obje ts, sur la taille de la pile ou, e ncore , tout sim plem e nt, sur la taille des diffé re nts obje ts q u'ile s t possible de m anipuler. Iln'e s t pas rare , e n e ffe t, q ue l'on re ncontre des lim itations à 64 KO (c'e s t le cas, actue llem e nt, des com pilate urs Borland/Turbo C/C+ + utilisés dans l'e nvironne m e nt D O S).

I-3 Le ttre s com m une s à de ux m ots (1) ________________________________________________________________________________________

Enoncé R é aliser un program m e q ui affich e les lettre s com m une s à deux m ots fournis au clavie r. O n pré voira d'affich e r plusieurs fois une lettre q ui apparaî t à plusieurs reprises dans ch acun des deux m ots.

98 Exe rcice s e n langage C O n supposera q ue ce s m ots ne peuve nt pas com porte r plus de 26 caractè re s e t on les lira à l'aide de la fonctions ge ts.

Exe m pl es donnez un donnez un la lettre la lettre la lettre la lettre

premier mot : monsieur deuxième mot : bonjour o est commune aux deux mots n est commune aux deux mots u est commune aux deux mots r est commune aux deux mots _________________

donnez un donnez un la lettre la lettre la lettre

premier mot : barbara deuxième mot : ravage a est commune aux deux mots r est commune aux deux mots a est commune aux deux mots

________________________________________________________________________________________

ANALYSE L'é noncé nous im pose d'utiliser ge ts, donc de re pré s e nte r nos m ots sous form e de ch aî nes de caractè re s (suites de caractè re s te rm iné e s par le caractè re nul, noté e n C : \0). Nous utiliserons à ce t e ffe t des tableaux de caractè res de dim e nsion 27 (pour 26 lettre s m axim um e t un caractè re de fin). La re ch e rch e des lettre s com m une s aux de ux m ots peut s e faire e n com parant ch acun de s caractè res de la pre m iè re ch aî ne à ch acun de s caractè res de la s e conde . Ce la nous conduit nature llem e nt à l'utilisation de deux boucles ave c com pte ur (instructions for) im briq ué e s . Toute fois, nous devons te nir com pte de ce q u'une m ê m e lettre pe ut figure r plusieurs fois dans un m ê m e m ot. Dans ces conditions, ilfaut é vite r : *q u'une m ê m e lettre du prem ie r m ot ne puis s e ê tre trouvé e e n de ux e ndroits diffé re nts du second. Par e xe m ple, ave c : m onsieur et bonjour

I. Variations algorith m iques sur les instructions de base 99 aprè s avoir trouvé q ue le o de m onsie ur figurait e n position 2 de bonjour, ilfaut é vite r de s ignaler une nouve lle coïncide nce e ntre ce m ê m e o de m onsie ur e t le s e cond o de bonjour. Ile s t donc né ce s s aire d'inte rrom pre la com paraison entre une lettre du prem ie r m ot ave c toute s ce lles du second m ot, dè s q u'une coïncide nce a é té déte cté e . *q u'une m ê m e lettre du second m ot ne puis s e coïncide r ave c deux lettres diffé re ntes du second. Par e xe m ple, ave c (atte ntion à l'ordre des m ots) : bonjour et m onsieur ilfaut é vite r de trouve r une coïncide nce e ntre le pre m ie r o de bonjour e t l'uniq ue o de m onsie ur e t une autre coïncide nce e ntre le s e cond o de bonjour e t le m ê m e o de m onsie ur. Pour ce faire , une dém arch e (parm i d'autre s ) consiste à é lim ine r dans le s e cond m ot la lettre ayant fait l'obje t d'une coïncide nce . Plus précisém e nt, ilsuffit de re m place r une te lle lettre par un caractè re dont on e s t sûr q u'iln'apparaî tra pas dans un m ot. Ici, nous avons ch oisi l'e s pace puis q ue nous som m e s ce ns é s travailler ave c des m ots.

Program m e

#include #include #define LMAX 26 main() { char mot1 [LMAX+1], mot2 [LMAX+1] ; int i, j ;

/* premier mot */ /* deuxième mot */

/* lecture des deux mots */ printf ("donnez un premier mot : ") ; gets (mot1) ; printf ("donnez un deuxième mot : ") ; gets (mot2) ; /* comparaison */ for (i=0 ; i
100

Exe rcice s e n langage C { printf ("la lettre %c est commune aux deux mots\n", mot1[i]) ; mot2[j] = ' ' ; break ; }

}

Com m e ntaire s *Nous avons utilisé le sym bole LM A X pour re pré s e nte r la longue ur m axim ale d'un m ot. Note z bie n q ue les tableaux m ot1 e t m ot2 ont dû ê tre pré vus de dim e nsion LM A X+1, afin de te nir com pte de la pré s e nce du caractè re de fin de ch aî ne . *Nous aurions pu utiliser, à la place de la s e conde boucle ave c com pte ur (e n j), une boucle tant q u e (w h ile). Ce rte s , la program m ation e û t é té plus structuré e m ais, né anm oins, m oins concis e .

D ISCUSSIO N Ce program m e n'e s t pas proté gé contre des ré ponses de plus de 26 caractè re s . Dans ce cas, en effe t, les caractè re s superflus iront é cras e r les données se trouvant au-de là de l'un de s tableaux m ot1 ou m ot2. Le s cons é q ue nce s pe uve nt ê tre as s e z varié e s (vous pouve z e xpé rim e nte r le pré s e nt program m e dans dive rs e s s ituations e t te nte r d'e xpliq ue r les com porte m e nts observé s ). Ile xiste diffé re nte s façons d'évite r ce ris q ue . Citons, par e xe m ple : - lire (toujours par ge ts), une ch aî ne com portant un nom bre de caractè re s s uffisam m e nt é levé pour q ue l'utilisate ur ne ris q ue pas (trop!) d'en fournir plus. O n pourrait ch oisir, par e xe m ple 80 ou 128 caractè re s (dans ce rtaine s im plém e ntations, iln'e s t jam ais possible de tape r de s lignes de plus de 128 caractè re s ). - lim ite r autom atiq ue m e nt la longue ur de la ch aî ne lue , e n utilisant la fonction fge ts ;par e xe m ple, ave c fge ts (m ot1, LM AX, stdin), on lim ite à LM AX le nom bre de caractè re s lus sur stdin. - utiliser, dans certaine s im plém e ntations (Turbo/Borland C/C+ + , C/Quick C M icrosoft), une fonction (non portable!) nom m é e cge ts.

I. Variations algorith m iques sur les instructions de base

101

I-4 Le ttre s com m une s à de ux m ots (2) ________________________________________________________________________________________

Enoncé R é aliser un program m e q ui affich e les lettre s com m une s à deux m ots fournis e n donné e . Ce tte fois, on n'im pos e ra pas de lim ite à la taille des m ots fournis par l'utilisate ur, m ais on ne pre ndra e n com pte q ue les 26 pre m ie rs caractè re s . Que lq ue soit le nom bre de caractè re s e ffe ctive m e nt frappé s , l'utilisate ur de vra toujours valider sa réponse par la frappe de la touch e re turn. Là e ncore , on pré voira d'affich e r plusieurs fois une lettre q ui apparaî t à plusieurs reprises dans ch acun de s m ots. O n s'astre indra à n'utiliser pour la lecture au clavie r q ue l a seul e fonction getch ar. De plus, on ré alisera une fonction destiné e à lire un m ot dans un tableau q u'on lui transm e ttra e n argum e nt ;e lle fournira, e n re tour, la longue ur e ffe ctive du m ot ainsi lu.

Exe m pl es Voir ce ux de l'e xe rcice pré cédent ________________________________________________________________________________________

ANALYSE L'é noncé nous im pos e l'e m ploi de ge tch ar, ce q ui signifie q ue ch acun des deux m ots devra ê tre lu caractè re par caractè re . Dans ces conditions, nous pouvons ch oisir de représente r nos m ots : - soit sous form e d'une ch aî ne de caractè re s . Ilnous faudra alors introduire nous-m ê m e s le caractè re de fin de ch aî ne (\0), ce q ue faisait autom atiq ue m e nt ge ts. - soit sous form e d'une sim ple s uite de caractè re s (c'e s t-à -dire s ans ce caractè re de fin). Dans ce cas, ilnous faudra alors prévoir d'e n dé te rm ine r la "longue ur". Com m e l'é noncé nous im pos e q ue la fonction de lecture d'un m ot e n re s titue la longue ur, nous ch oisirons la s e conde solution. La lecture d'un m ot consiste donc à lire des caractè re s au clavie r jus q u'à ce q ue l'on re ncontre une validation (\n) ou q ue l'on ait obte nu 26 caractè re s ;de plus, dans le cas où l'on a obte nu 26 caractè re s , ilfaut poursuivre la lecture de caractè re s au clavie r, sans les pre ndre e n com pte , jus q u'à ce q ue l'on re ncontre une validation.

102

Exe rcice s e n langage C

Program m e #include #define LMAX 26 main() { int lire(char []) ; char mot1 [LMAX], mot2 [LMAX] ; int l1, l2, i, j ;

/* longueur maximale d'un mot */

/* /* /* /* /*

déclaration (prototype) fonction lecture d'un mot */ premier mot (sans '\0') */ deuxième mot (sans '\0') */ longueur premier mot */ longueur deuxième mot */

/* lecture des deux mots */ printf ("donnez un premier mot : ") ; l1 = lire (mot1) ; printf ("donnez un deuxième mot : ") ; l2 = lire (mot2) ; /* comparaison */ for (i=0 ; i
I. Variations algorith m iques sur les instructions de base while (getchar() != '\n') {} return(i) ;

103

/* recherche '\n' */

}

Com m e ntaire s *Là e ncore , nous avons utilisé le sym bole LM A X pour re pré s e nte r la taille m axim ale d'un m ot. Par contre , ce tte fois, la dim e nsion des tableaux m ot1 e t m ot2 e s t é gale à LM A X (e t non plus LM A X+ 1), puis q ue nous n'avons pas à y introduire le caractè re s upplém e ntaire de fin de ch aî ne . *En ce q ui conce rne la fonction (nom m é e lire ) de lecture d'un m ot au clavie r, vous constate z q ue nous l'avons déclaré e dans le program m e principal(m ain), bie n q ue ce la soit facultatif, dans la m e s ure où e lle fournit un ré s ultat de type int (e n e ffe t, toute fonction q ui n'e s t pas e xplicite m e nt déclaré e e s t supposée produire un résultat de type int). D 'autre part, com m e nous l'avons e xpliq ué dans l'introduction de ce tte s e conde partie , nous avons utilisé, dans ce tte déclaration, la form e "prototype " autoris é e par la norm e ANSI (ce prototype assure les contrôles de types d'argum e nts e t m e t e n place d'éve ntue lles conve rsions). Par ailleurs, l'e n-tê te de notre fonction lire a é té é crit suivant la form e "m ode rne ". La norm e ANSI aurait autoris é le re m place m e nt de note e n-tê te par : int lire (mot) char mot [LMAX] ;

*Le tableau de caractè re s re pré s e ntant l'uniq ue argum e nt de lire doit obligatoire m e nt ê tre transm is par adre s s e puis q ue ce tte fonction doit ê tre e n m e s ure d'en m odifie r le conte nu. N'oublie z pas ce pe ndant q u'e n langage C un nom de tableau e s t inte rpré té (par le com pilate ur) com m e un pointe ur (constant) sur son pre m ie r é lém e nt. C'e s t ce q ui justifie la pré s e nce , dans les appe ls à la fonction lire , de m ot1 ou m ot2, e t non de & m ot1 ou & m ot2. *La déclaration de l'argum e nt de lire , dans son e n-tê te : char mot [LMAX]

aurait pu é galem e nt s'é crire : char mot []

ou m ê m e : char * mot

104 Exe rcice s e n langage C D ans le pre m ie r cas, on continue de spé cifie r (au lecte ur du program m e plus q u'au com pilate ur) q ue m ot e s t un tableau de caractè re s m ais q ue s a dim e nsion n'a pas besoin d'ê tre connue au s e in de lire . Dans le s e cond cas, on e xprim e plus claire m e nt q ue , finalem e nt, l'argum e nt re çu par lire n'e s t rie n d'autre q u'un pointe ur sur des caractè re s . Ce s form ulations sont totalem e nt é q uivalente s pour le com pilate ur e t, dans tous les cas (m ê m e le dernie r), ilre s te possible de faire appe lau "form alism e " tableau au s e in de lire , e n utilisant une notation te lle q ue : mot [i++]

D 'ailleurs, pour le com pilate ur, ce tte derniè re e s t é q uivalente à : * (mot + i++)

Le s m ê m e re flexions s'appliq ue nt à l'é criture du prototype de lire .

D ISCUSSIO N *Le sym bole M ais, si ce tte (#de fine ) dans à faire appe là

LM A X e s t défini pour l'e ns e m ble du source conte nant, ici, le program m e principale t la fonction lire . fonction de vait ê tre com pilée s é paré m e nt du re s te , ils e rait alors néce s s aire de faire figure r la définition les deux source s , ce q ui com porte un ris q ue d'erreur. Dans une situation "ré e lle", on pourrait avoir inté rê t l'une des dém arch e s s uivante s :

- transm e ttre la valeur de LM A X e n argum e nt de la fonction lire . - re groupe r les définitions de sym boles com m uns à plusieurs sources dans un fich ie r s é paré q ue l'on appe lle par #include dans ch acun de s s ource s conce rné s . *Contraire m e nt au program m e de l'e xe rcice pré cédent, ce lui-ci s e trouve proté gé de ré pons e s trop longues de la part de l'utilisate ur.

I-5 Com ptage de l e ttre s ________________________________________________________________________________________

I. Variations algorith m iques sur les instructions de base

105

Enoncé R é aliser un program m e q ui com pte le nom bre de ch acune des lettres de l'alph abet d'un te xte e ntré au clavie r. Pour sim plifie r, on ne tie ndra com pte q ue des m inuscules , m ais on com pte ra le nom bre des caractè re s non re connus com m e te ls (q ue ls q u'ils soie nt : m ajuscules , ponctuation, ch iffre s ,...). Le program m e devra acce pte r un nom bre q ue lconq ue de ligne s . L'utilisate ur tape ra une "ligne vide" pour signaler q u'ila te rm iné la frappe de son te xte (ce q ui re vie nt à dire q u'ilfrappe ra donc de ux fois de suite la touch e re turn, aprè s la frappe de sa derniè re ligne ). O n supposera q ue les ligne s frappé e s au clavie r ne pe uve nt jam ais dépas s e r 127 caractè re s . Par ailleurs, on fe ra l'h ypoth è s e (pe u re s trictive e n pratiq ue ) q ue les "code s " des lettre s m inuscules a à z sont cons é cutifs (ce q ui e s t le cas, notam m e nt, ave c le code A SCII).

Exe m pl e donnez votre texte, en le terminant par une ligne vide je me figure ce zouave qui joue du xylophone en buvant du whisky

votre texte comporte 63 caractères dont : 2 fois la lettre a 1 fois la lettre b 1 fois la lettre c 2 fois la lettre d 8 fois la lettre e 1 fois la lettre f ...... ...... 7 fois la lettre u 2 fois la lettre v 1 fois la lettre w 1 fois la lettre x 2 fois la lettre y 1 fois la lettre z et 11 autres caractères ________________________________________________________________________________________

106

Exe rcice s e n langage C

ANALYSE Ilnous faut donc utiliser un tableau de 26 e ntie rs perm e ttant de com ptabiliser le nom bre de fois où l'on a re ncontré ch acune des 26 lettre s (m inuscules ) de l'alph abet. Nous le nom m e rons com pte . Nous utiliserons égalem e nt un com pte ur nom m é ntot pour le nom bre totalde caractè re s e t un autre nom m é nautre s pour les caractè res diffé re nts d'une lettre m inuscule. En ce q ui conce rne le com ptage propre m e nt dit, ilnous faut e xam ine r ch acune des lettres du te xte . Pour ce faire , ile xiste (au m oins) deux dém arch e s possibles : - e ffe ctue r une ré pé tition du traite m e nt d'un caractè re , - e ffe ctue r une ré pé tition du traite m e nt d'une ligne , lui-m ê m e constitué de la ré pé tition du traite m e nt de ch acun de s caractè re s q u'e lle contie nt. a) La pre m iè re dém arch e aboutit à une s im ple boucle ave c com pte ur. Elle ne dem ande d'accéder q u'à un s e ulcaractè re à la fois (par e xe m ple, par ge tch ar). Elle né ce s s ite , par contre , l'é lim ination de s caractè res de fin de ligne \n (q ui sont transm is com m e les autre s par ge tch ar), puis q u'ils ne font pas vraim e nt partie du te xte . D e s urcroî t, la déte ction de la fin du te xte oblige à cons e rve r e n pe rm ane nce le "caractè re pré cédent". Lors q ue ce caractè re , ainsi que le caractè re courant, sont é gaux à \n, c'e s t q ue l'on a atte int la fin du te xte . Ilsuffit d'initialiser artificie llem e nt ce caractè re pré cédent à une valeur q ue lconq ue (autre q ue \n) pour é vite r de devoir e ffe ctue r un traite m e nt particulie r pour le pre m ie r caractè re . b) La s e conde dém arch e aboutit à deux boucles im briq ué e s . Elle pe rm e t de lire directe m e nt ch aq ue ligne par ge ts. Elle rè gle de m aniè re nature lle les problèm es de fin de ligne e t de fin de te xte . Nous vous proposons ici de ux program m e s , corre s pondant à ch acune de ces deux dé m arch e s .

Program m e bas é s ur l a ré pé tition du traite m e nt d'un caractè re #include main() { char c, cprec ; int compte[26] ; int numl, ntot, nautres, i ;

/* /* /* /* /* /*

pour lire un caractère frappé au clavier */ caractère précédent */ pour compter les différentes lettres */ rang lettre courante dans l'alphabet */ nombre de caractères du texte */ nb caractères autres qu'une lettre minuscule */

/* initialisations */

I. Variations algorith m iques sur les instructions de base

107

cprec = ' ' ; ntot = 0 ; nautres = 0 ; for (i=0 ; i<26 ; i++) compte[i]=0 ; /* lecture texte et comptages */ printf ("donnez votre texte, en le terminant par une ligne vide\n") ; while ( (c=getchar()) != '\n' || cprec != '\n' ) { if (c != '\n') { numl = c - 'a' ; /* on donne le rang 0 à la lettre 'a' */ if (numl >=0 && numl < 26) compte[numl]++ ; else nautres++ ; ntot++ ; } cprec = c ; } /* affichage résultats */ printf ("\n\nvotre texte comporte %d caractères dont :\n", ntot) ; for (i=0; i<26 ; i++) printf ("%d fois la lettre %c\n", compte[i], 'a'+i) ; printf ("\net %d autres caractères\n", nautres) ; }

Com m e ntaire s *L'e xpre s s ion : c - 'a' pe rm e t d'obte nir le "rang" dans l'alph abet du caractè re conte nu dans c. N'oublie z pas q ue le langage C considè re le type ch ar com m e num é riq ue . Plus précisém e nt, dans le cas présent, les valeurs de c e t de 'a' sont conve rtie s e n int (ce q ui fournit la valeur num é riq ue de leur code ) avant q ue ne s oit é valué e l'e xpre s s ion c-'a'. Com m e nous avons suppos é q ue les codes des m inuscules s ont cons é cutifs, nous obte nons bien le ré s ultat e s com pté . *Le s instructions : if (c != '\n') { numl = c - 'a' ; if (numl >=0 && numl < 26) compte[numl]++ ; else nautres++ ; ntot++ ;

108

Exe rcice s e n langage C } cprec = c;

pourraie nt s e conde ns e r e n : if ( (cprec=c) != '\n') { numl = c - 'a' ; if (numl >=0 && numl < 26) compte[numl]++ ; else nautres++ ; ntot++ ; }

Program m e bas é s ur l a ré pé tition du traite m e nt d'une l igne #include #include main() { char ligne[128] ; int compte[26] ; int numl, ntot, nautres, i ;

/* /* /* /* /*

pour lire une ligne frappée au clavier */ pour compter les différentes lettres */ rang lettre courante dans l'alphabet */ nombre de caractères du texte */ nombre de caractères autres qu'une lettre minuscule */

/* initialisations */ ntot = 0 ; nautres = 0 ; for (i=0 ; i<26 ; i++) compte[i]=0 ; /* lecture texte et comptages */ printf ("donnez votre texte, en le terminant par une ligne vide\n") ; do { gets(ligne) ; for (i=0 ; i=0 && numl < 26) compte[numl]++ ; else nautres++ ; } } while (strlen(ligne)) ; /* affichage résultats */

I. Variations algorith m iques sur les instructions de base

109

printf ("\n\nvotre texte comporte %d caractères dont :\n", ntot) ; for (i=0; i<26 ; i++) printf ("%d fois la lettre %c\n", compte[i], 'a'+i) ; printf ("\net %d autres caractères\n", nautres) ; }

D ISCUSSIO N *Aucun des deux program m e s propos é s ne pose de problèm e de prote ction vis-à -vis des réponses fournie s par l'utilisate ur.

I-6 Com ptage de m ots ________________________________________________________________________________________

Enoncé Ecrire un program m e pe rm e ttant de com pte r le nom bre de m ots conte nus dans un te xte fourni au clavie r. Le te xte pourra com porte r plusieurs ligne s e t l'utilisate ur tape ra une ligne "vide" pour signaler q u'ile n a te rm iné la frappe (ce q ui re vie nt à dire q u'ilfrappe ra de ux fois de suite la touch e re turn aprè s avoir fourni la derniè re ligne ). O n adm e ttra q ue deux m ots sont toujours s é paré s par un ou plusieurs des caractè re s s uivants : - fin de ligne - e s pace - ponctuation :

: . , ;?!

- pare nth è s e s :

( )

- guillem e ts :

"

- apostroph e :

'

O n adm e ttra é galem e nt, pour sim plifie r, q u'aucun m ot ne pe ut ê tre com m e ncé s ur une ligne e t s e poursuivre s ur la suivante . O n pré voira une fonction pe rm e ttant de décide r si un caractè re donné transm is en argum e nt e s t un de s s é parate urs m e ntionné s ci-de s s us. Elle fournira la valeur 1 lors q ue le caractè re e s t un s é parate ur e t la valeur 0 dans le cas contraire .

110

Exe rcice s e n langage C

Exe m pl e donnez votre texte, en le terminant par une ligne vide Le langage C a été conçu en 1972 par Denis Ritchie avec un objectif très précis : écrire un "système d'exploitation" (UNIX). A cet effet, il s'est inspiré du langage B (créé par K. Thompson) qu'il a haussé au niveau de langage évolué, notamment en l'enrichissant de structures et de types, et ceci tout en lui conservant ses aptitudes de programmation proche de la machine.

votre texte comporte 68 mots _______________________________________________________________________________________

ANALYSE Com m e dans l'e xe rcice pré cédent, ile xiste (au m oins) deux dém arch e s possibles : - e ffe ctue r une ré pé tition du traite m e nt d'un caractè re , - e ffe ctue r une ré pé tition du traite m e nt d'une ligne , lui-m ê m e constitué de la ré pé tition du traite m e nt de ch acun de s caractè re s q u'e lle contie nt. La pre m iè re dém arch e aboutit à une s im ple boucle ave c com pte ur. Elle dem ande s im plem e nt d'accéder à un s e ul caractè re (par e xe m ple par ge tch ar). La s e conde dém arch e aboutit à deux boucles im briq ué e s . Elle dem ande d'effe ctue r une lecture ligne par ligne (par e xe m ple par ge ts). Là e ncore , nous e xam ine rons les deux dé m arch e s e t nous proposerons un program m e corre s pondant à ch acune d'entre e lles . D ans les deux dé m arch e s , tous les caractè re s s é parate urs joue nt le m ê m e rôle, à condition d'y inclure \n (si l'on travaille ave c ge tch ar) ou \0 (si l'on travaille ave c ge ts). O n pe ut alors dire que l'on a progressé d'un m ot dans le te xte , ch aq ue fois q ue l'on a ré alisé la s é q ue nce s uivante : - re ch e rch e du prem ie r caractè re diffé re nt d'un séparate ur, - re ch e rch e du prem ie r caractè re é galà un s é parate ur.

I. Variations algorith m iques sur les instructions de base 111 O n pourrait ré pé te r succe s s ive m e nt ces deux opé rations, tant q u e q ue l'on n'e s t pas arrivé à la fin du te xte . En fait, ile s t plus sim ple d'utiliser un "indicate ur logiq ue " (nous l'appe llerons m ot_e n_cours) e t d'effe ctue r pour ch aque caractè re le traite m e nt suivant : - si le caractè re e s t un s é parate ur e t si m ot_e n_cours e s t vrai, augm e nte r de un le com pte ur de m ots e t re m e ttre m ot_e n_cours à faux. - si le caractè re n'e s t pas un séparate ur e t si m ot_e n_cours e s t faux, m e ttre m ot_e n_cours à vrai. Quant à la condition d'arrê t, e lle s 'e xprim e diffé re m m e nt suivant la dém arch e adopté e : - deux caractè re s cons é cutifs é gaux à \n pour la pre m iè re , ce q ui im pose de cons e rve r e n pe rm ane nce la valeur du "caractè re pré cédent" ;ce dernie r s e ra initialisé à une valeur q ue lconq ue diffé re nte de \n pour é vite r un traite m e nt particulie r du pre m ie r caractè re du te xte . - ligne vide pour la s e conde .

Program m e bas é s ur l a ré pé tition du traite m e nt d'un caractè re

#include #define VRAI 1 #define FAUX 0

/* pour "simuler" des ..... */ /* ..... valeurs logiques */

main() { int sep(char) ; char c, cprec ; int nmots, fin_texte, mot_en_cours ;

/* /* /* /* /* /*

prototype fonction test "caractère séparateur?" */ pour lire un caractère frappé au clavier */ caractère précédent */ compteur du nombre de mots */ indicateurs logiques : - fin texte atteinte */ - mot trouvé */

cprec = ' ' ; fin_texte = FAUX ; mot_en_cours = FAUX ; nmots = 0 ; printf ("donnez votre texte, en le terminant par une ligne vide\n") ; while (!fin_texte) { if ( sep(c=getchar()) ) { if (mot_en_cours) { nmots++ ; mot_en_cours = FAUX ; }

112

Exe rcice s e n langage C } else mot_en_cours = VRAI ; if ( c=='\n' && cprec=='\n') fin_texte = VRAI ; cprec = c ; } printf ("\n\nvotre texte comporte %d mots :\n", nmots) ;

} /*******************************************/ /* fonction d'examen d'un caractère */ /*******************************************/ int sep (char c) { char sep[12] = {'\n', /* fin de ligne */ ' ', /* espace */ ',', ';', ':', '.', '?', '!', /* ponctuation */ '(', ')', /* parenthèses */ '"', '\'' } ; /* guillemets, apostrophe*/ int nsep=12, /* nombre de séparateurs */ i ; i = 0 ; while ( c!=sep[i] && i++
Com m e ntaire s *Nous avons introduit une variable "logiq ue " nom m é e fin_te xte q ui nous facilite la déte ction de la fin du te xte . Nous aurions pu nous en passer en introduisant une instruction bre ak au s e in d'une boucle do ... w h ile {1}(boucle infinie ). *D ans le traite m e nt de ch aq ue caractè re , nous n'avons pas respecté "à la lettre " l'algorith m e propos é lors de l'analyse. En e ffe t, nous e xé cutons l'instruction : mot_en_cours = VRAI

m ê m e s i l'indicate ur m ot_e n_cours a déjà la valeur VR A I ;ce la nous é vite un te s t supplém e ntaire , sans m odifie r le com porte m e nt du program m e (puis q ue la m odification ainsi apporté e consiste à m e ttre à VR A I l'indicate ur alors q u'ily e s t déjà ).

I. Variations algorith m iques sur les instructions de base

113

*D ans la fonction s e p, la s e ule instruction : while ( c!=sep[i] && i++
pe rm e t de savoir si le caractè re c e s t un s é parate ur. En e ffe t, ilne faut pas oublie r q ue l'opé rate ur & & n'é value s on s e cond opé rande q ue lors q ue ce la e s t né ce s s aire . Autre m e nt dit, si la pre m iè re condition e s t faus s e (c e s t donc é galà un s é parate ur), l'e xpre s s ion i++
Program m e bas é s ur l a ré pé tition du traite m e nt d'une l igne #include #include #define VRAI 1 #define FAUX 0 main() { int sep(char) ; char ligne[128] ; int nmots, mot_en_cours, i ;

/* pour "simuler" des ..... */ /* ..... valeurs logiques */

/* /* /* /*

prototype fonction test "caractère séparateur?" */ pour lire une ligne frappée au clavier */ compteur du nombre de mots */ indicateur logique : mot trouvé */

nmots = 0 ; mot_en_cours = FAUX ; printf ("donnez votre texte, en le terminant par une ligne vide\n") ; do { gets(ligne) ; for (i=0 ; i<=strlen(ligne) ; i++) /* on traite aussi le '\0' */ if ( sep(ligne[i]) ) { if (mot_en_cours) { nmots++ ; mot_en_cours = FAUX ; } } else mot_en_cours = VRAI ; } while (strlen(ligne)) ;

114

Exe rcice s e n langage C printf ("\n\nvotre texte comporte %d mots :\n", nmots) ;

} /********************************************/ /* fonction d'examen d'un caractère */ /********************************************/ int sep (char c) { char sep[12] = {'\0', /* fin de ligne (chaîne) */ ' ', /* espace */ ',', ';', ':', '.', '?', '!', /* ponctuation */ '(', ')', /* parenthèses */ '"', '\'' } ; /* guillemets, apostrophe*/ int nsep=12, /* nombre de séparateurs */ i ; i = 0 ; while ( c!=sep[i] && i++
Com m e ntaire s Nous avons dû : - d'une part, au s e in de la fonction s e p, re m place r le s é parate ur \n par \0, - d'autre part, dans la boucle de traite m e nt des caractè res d'une ligne , traite r com m e les autre s ce caractè re de fin de ligne (c'e s t-à -dire faire varie r i de 0 à strlen(ligne ) e t non strlen(ligne )-1), afin d'é vite r de com pte r pour un s e ulm ot le dernie r m ot d'une ligne (non suivi d'un séparate ur) e t le pre m ie r de la suivante .

D is cus s ion *En ce q ui conce rne la fonction d'e xam e n d'un caractè re (nom m é e s e p), vous constate z (dans les deux ve rsions propos é e s ) q ue nous l'avons déclarée dans le program m e principal(m ain), bie n q ue ce la soit facultatif, dans la m e s ure où e lle fournit un ré s ultat de type int. *Aucun des deux program m e s propos é s ne pose de problèm e de prote ction vis-à -vis des réponses fournie s par l'utilisate ur.

II : UTILISATIO N D E STRUCTURES

Le ch apitre I vous a proposé des exe rcice s faisant appe laux instructions de base du langage C. Le s e xe rcices de ce ch apitre font inte rve nir, e n plus, la notion de structure sous des form es dive rs e s (e n particulie r les tableaux de s tructure s e t leur initialisation).

II-1 Signe du zodiaq ue ________________________________________________________________________________________

Enoncé Affich e r le s igne du zodiaq ue corre s pondant à une date de naissance fournie e n donné e , sous la form e : jour m ois Les deux inform ations s e ront s é paré e s par au m oins un espace. La pre m iè re s e ra fournie s ous form e num é riq ue , tandis q ue la s e conde le s e ra sous form e d'une ch aî ne de caractè re s . Nous vous rappe lons q ue les pé riode s corre s pondant à ch aq ue s igne s ont les s uivante s : Capricorne Verseau Poisson

23 décembre - 19 janvier 20 janvier - 19 février 20 février - 20 mars

116

Exe rcice s e n langage C Bélier Taureau Gémeau Cancer Lion Vierge Balance Scorpion Sagittaire

21 20 21 21 22 23 23 23 22

mars - 19 avril avril - 20 mai mai - 20 juin juin - 21 juillet juillet - 22 août août - 22 septembre septembre - 22 octobre octobre - 21 novembre novembre - 22 décembre

Exe m pl es donnez votre jour et votre mois (sans accent) de naissance ? 11 july *** erreur de nom de mois *** _______________________ donnez votre jour et votre mois de naissance ? 16 janvier vous êtes né sous le signe suivant : Capricorne ________________________________________________________________________________________

ANALYSE Le program m e doit ê tre e n m e s ure d'établir une corre s pondance e ntre le nom d'un signe e t les deux date s lim ite s corre s pondante s . O n pe ut déjà note r q ue la date de fin d'un signe e s t la ve ille de ce lle de début du suivant. Nous nous conte nte rons donc de ne cons e rve r q u'une s e ule de ces deux inform ations, par e xe m ple la date de fin. La corre s pondance s ouh aité e pe ut ê tre ré alisée : - par plusieurs tableaux (jour, m ois, signe) re lié s par une valeur com m une d'indice . - par un s e ultableau dans leq ue lch aq ue é lém e nt e s t une structure com portant un num é ro de jour, un nom de m ois e t un nom de signe. Nous ch oisirons la s e conde s olution car e lle pe rm e t de m ie ux m e ttre e n é vidence la corre s pondance e ntre les inform ations, au m om e nt de l'initialisation au s e in du program m e . La re ch e rch e du signe correspondant à une date donnée se fait alors de la m aniè re s uivante : - O n ch e rch e tout d'abord l'é lém e nt (nous le nom m e rons x) apparte nant à notre tableau de s tructure s , dont le nom de m ois corre s pond à ce lui propos é e n donné e . S'iln'e xiste pas, on le s ignale par un m e s s age approprié .

II. Utilisation de s tructure s - O n re garde e nsuite s i le num é ro du jour propos é e s t infé rie ur ou é galà ce lui de l'é lém e nt x.

117

D ans l'affirm ative , on pe ut e n conclure q ue la date propos é e e s t anté rie ure à la date de fin du signe figurant dans l'é lém e nt x, ce q ui fournit la ré pons e voulue . D ans le cas contraire , on e n conclut q ue la date propos é e e s t posté rie ure à la date de début du signe figurant dans l'é lém e nt x ;ilsuffit donc d'e xam ine r l'é lém e nt suivant pour obte nir la ré pons e voulue . Toute fois, si x est le dernie r é lém e nt de notre tableau, ilfaudra considérer que son suivant e s t e n fait le pre m ie r é lém e nt du tableau. O n re m arq ue ra q ue l'algorith m e propos é fonctionne e ffe ctive m e nt parce q ue ch acun de s 12 m ois de l'anné e ne com porte q u'un s e ulch ange m e nt de signe. Si ce la n'avait pas é té le cas, ilaurait fallu "e ncadre r" la date propos é e par de ux date s d'élém e nts cons é cutifs de notre tableau.

Program m e

#include #include #include main() { struct s_date { int jour ; char mois [10] ; char signe [11] ; } ; struct s_date date [12] = { 23, "decembre", "Sagittaire", 20, "janvier", "Capricorne", 20, "fevrier", "Verseau", 21, "mars", "Poisson", 20, "avril", "Bélier", 21, "mai", "Taureau", 21, "juin", "Gémeau", 22, "juillet", "Cancer", 23, "aout", "Lion", 23, "septembre", "Vierge", 23, "octobre", "Balance", 22, "novembre", "Scorpion" } ; int jour_n ; /* jour de naissance */ char mois_n [10] ; /* mois de naissance */ int nbv, i ;

118

Exe rcice s e n langage C /* lecture date de naissance */ printf ("donnez votre jour et votre mois de naissance ?\n") ; scanf ("%d %s", &jour_n, mois_n) ; /* recherche et affichage du signe correspondant */ i = 0 ; while ( stricmp(date[i].mois, mois_n) && i++<11 ) { } if (i<12) { printf ("vous êtes né sous le signe suivant : ") ; if (jour_n >= date[i].jour) i = (i+1)%12 ; printf ("%s", date[i].signe) ; } else printf ("*** erreur de nom de mois ***") ;

}

Com m e ntaire s *Nous avons défini ici un m odè le de structure nom m é s_date , dans leq ue lnous trouvons un num é ro de jour, un nom de m ois e t le s igne corre s pondant. Nous avons prévu 10 caractè re s pour le nom de m ois, ce q ui autorise des ch aî nes de longue ur infé rie ure ou é gale à 9 (com pte te nu du \0 de fin) ;de m ê m e , nous avons prévu 11 caractè re s pour le s igne . Le tableau nom m é date e s t un tableau de 12 é lém e nts ayant ch acun le type s_date . Nous l'avons initialisé dans sa déclaration, ce q ui pe rm e t de m e ttre facilem e nt e n parallèle ch aq ue s igne e t sa date de fin. *En ce q ui conce rne la lecture de la date au clavie r, nous n'avons pas prévu, ici, de prote ction vis-à -vis d'éve ntue lles e rre urs de frappe de l'utilisate ur (ce la n'é tait pas dem andé par l'é noncé ). *R appe lons q ue la fonction stricm p com pare , sans te nir com pte de la distinction m ajuscules /m inuscules , les deux ch aî ne s dont on lui fournit l'adre s s e e n argum e nt. Elle re s titue une valeur non nulle (q u'on pe ut inte rpré te r com m e vrai) lors q ue les deux ch aî ne s s ont diffé re nte s e t une valeur nulle (faux) lors q u'e lles s ont é gales . *La re ch e rch e du nom de m ois e s t ré alisée par la s e ule instruction : while ( stricmp(date[i].mois, mois_n) && i++<11 ) {}

Ce lle-ci possè de un double avantage ;tout d'abord, ce lui de la concision ;e nsuite , ce lui de nous perm e ttre de savoir dire cte m e nt si la re ch e rch e a é té fructue us e ou non.

II. Utilisation de s tructure s 119 En e ffe t, ilne faut pas oublie r q ue l'opé rate ur & & n'é value s on s e cond opé rande q ue lors q ue ce la e s t né ce s s aire . Autre m e nt dit, si la pre m iè re condition e s t faus s e (ily a donc é galité des deux ch aî ne s ), l'e xpre s s ion i++<11 n'e s t pas é valué e e t i n'e s t donc pas incré m e nté e . La valeur de i désigne alors l'é lém e nt voulu. Si, par contre , ce tte pre m iè re condition e s t vé rifié e (iln'y a donc pas é galité des deux ch aî ne s ) alors q u'on e s t arrivé e n fin de table (i=11), la s e conde condition e s t é valué e e t e lle e s t trouvé e faus s e , m ais e n m ê m e te m ps i se trouve incré m e nté e (à 12). En dé finitive , on voit q ue , à la fin de ce tte instruction, lors q ue i vaut 12, ce la signifie q ue l'é lém e nt ch e rch é ne figure pas dans la table. Dans le cas contraire (i< 12), i dé s igne l'é lém e nt ch e rch é . Bie n e nte ndu, ce tte "re ch e rch e e n table" pouvait s e program m e r de beaucoup d'autre s m aniè re s . Par e xe m ple, nous aurions pu écrire : while ( stricmp(date[i].mois, mois_n) && i<11 ) i++ ;

Toute fois, ce tte instruction n'e s t pas é q uivalente à la pré cédente . En e ffe t, lors q ue i vaut 11, ce la pe ut signifie r : - soit q ue l'é lém e nt ch e rch é e s t e n position 11 (pre m ie r te s t satisfait), - soit q ue l'é lém e nt ch e rch é ne figure pas dans la table (s e cond te s t satisfait). Pour tranch e r, ile s t donc né ce s s aire , dans ce cas, d'e ffe ctue r une com paraison supplém e ntaire . Note z q ue , par contre , une instruction te lle q ue : while ( stricmp(date[i].mois, mois_n) && i++ <= 11) {}

s e rait q ue lque pe u e rroné e . En e ffe t, dans le cas où l'é lém e nt ch e rch é ne figure rait pas dans le tableau, on s e rait am e né à é value r l'e xpre s s ion : date[i].mois

ave c une valeur i é gale à 12, c'e s t-à -dire désignant un é lém e nt situé e n de h ors du tableau. Ce rte s , e n gé né ral, ce la ne s e rait guè re visible dans le com porte m e nt du program m e , dans la m e s ure où ile s t bien peu probable q ue ce tte valeur soit é gale au nom de m ois voulu... *Note z l'e m ploi de l'opé rate ur arith m é tiq ue % q ui pe rm e t de ré gler le problèm e du signe suivant le dernie r signe du tableau.

D ISCUSSIO N *Te lq u'ila é té pré vu, notre program m e acce pte des nom s de m ois é crits e n m inuscules ou e n m ajuscules m ais sans acce nt. Dans un program m e ré e l, ils e rait souh aitable de faire pre uve de plus de tolérance .

120

Exe rcice s e n langage C

*Notre re ch e rch e du nom de m ois a é té ré alisée ici par un algorith m e dit de rech erch e séquentiel l e en tabl e (algorith m e q ui, com m e nous l'avons vu, pe ut s e program m e r e n C à l'aide d'une seule instruction). D'autre s algorith m e s plus rapide s e xiste nt, e n particulie r ce lui dit de rech erch e dich otom ique. L'e xe rcice IV-5 vous en proposera un exem ple.

II-2 Codage m ors e ________________________________________________________________________________________

Enoncé Ecrire un program m e affich ant le codage e n m orse d'un te xte fourni au clavie r e t ne dépassant pas une "ligne " de 127 caractè re s . Le s caractè re s s usce ptibles d'ê tre codé s e n m ors e s ont : - les 26 lettres de l'alph abet (supposées tapé e s e n m ajuscul es), - les 10 ch iffres de 0 à 9 , - le point, Si le te xte contie nt d'autre s caractè re s q ue ce ux-ci, le program m e affich e ra sim plem e nt des points d'inte rrogation à la place du code m ors e .

Tabl e au de s code s m ors e s A F K P U Z 0 5

...-. -..--. ..--.. ----.....

B G L Q V . 1 6

-... --. .-.. --.....-.-..----....

C H M R W

-.-. .... -.-. .--

D I N S X

-.. .. -. ... -..-

E J O T Y

. .-----.--

2 7

..----...

3 8

...----..

4 9

....----.

Exe m pl e donnez votre message (1 ligne maxi) : LE LANGAGE C, CONCU EN 1972, EST L'OEUVRE DE DENIS RITCHIE. voici la traduction de votre message

II. Utilisation de s tructure s

121

.-.. . ?????? .-.. .-. --. .--. . ?????? -.-. ?????? ?????? -.-. ---. -.-. ..- ?????? . -. ?????? .---- ----. --... ..--- ?????? ?????? . ... - ?????? .-.. ?????? --. ......-. . ?????? -.. . ?????? -.. . -. .. ... ?????? .-. .. -.-. .... .. . .-.-.________________________________________________________________________________________

ANALYSE Le program m e doit donc ê tre e n m e s ure d'établir une corre s pondance e ntre un caractè re e t son code m ors e . Là e ncore , nous pourrions utiliser deux tableaux re lié s par une valeur com m une d'un indice . M ais l'e m ploi d'un tableau de structure s pe rm e t de m ie ux m e ttre e n é vidence la corre s pondance e ntre les inform ations, lors de l'initialisation. Ch aq ue é lém e nt (structure ) du tableau contie ndra : - un caractè re , - le code m ors e corre s pondant, e xprim é s ous form e d'une ch aî ne . Le codage d'un caractè re s e fe ra alors sim plem e nt par sa localisation dans le tableau.

Program m e #include #include #define NL 37 main() { struct code { char lettre ; char * morse ; } ; struct code table[NL] = { 'A', ".-", 'D', "-..", 'G', "--.", 'J', ".---", 'M', "--", 'P', ".--.", 'S', "...", 'V', "...-",

/* nombre de caractères codés */

'B', 'E', 'H', 'K', 'N', 'Q', 'T', 'W',

"-...", ".", "....", "-.-", "-.", "--.-", "-", ".--",

/* code morse */ 'C', "-.-.", 'F', "..-.", 'I', "..", 'L', ".-..", 'O', "---", 'R',".-.", 'U', "..-", 'X', "-..-",

122

Exe rcice s e n langage C 'Y', '.', '0', '3', '6', '9', } ; char ligne[128] ; int i, j ;

"-.--", ".-.-.-", "-----", "...--", "-....", "----."

'Z', "--..", '1', ".----", '4', "....-", '7', "--...",

'2', "..---", '5', ".....", '8', "---..",

/* pour lire une ligne au clavier */

/* lecture message à traduire */ printf ("donnez votre message (1 ligne maxi) : \n") ; gets (ligne) ; printf ("\n\n voici la traduction de votre message\n") ; /* traduction lettre par lettre */ for (i=0 ; i
Com m e ntaire s *Nous avons défini un m odè le de structure , nom m é code , dans leq ue lnous trouvons : - un caractè re , - un pointeur sur une ch aî ne de caractè res destiné e à conte nir le code m ors e corre s pondant. Note z q ue , contraire m e nt à ce q ue nous avions fait dans le program m e de l'e xe rcice pré cédent, nous avons prévu ici un pointe ur sur une ch aî ne e t non un tableau de caractè re s . D ans ce s conditions, le tableau table occupe ra s e ulem e nt 37 (valeur de NL) e m place m e nts dont la taille s e ra gé né ralem e nt de 3 ou 5 octe ts (1 pour le caractè re e t 2 ou 4 pour le pointe ur). L'e m place m e nt m ê m e des ch aî ne s corre s pondante s s e trouve ce pe ndant ré s e rvé à la com pilation, de par le fait q ue nous avons initialisé ce tableau lors de sa déclaration. Ilne faut pas oublie r, e n e ffe t, q u'une notation te lle q ue : ".-.-."

II. Utilisation de s tructure s 123 e s t inte rpré té e par le com pilate ur com m e re pré s e ntant l'adresse de la ch aî ne fournie , m ais q u'e n m ê m e te m ps illui ré s e rve un e m place m e nt. Ce tte façon de procéder pe ut s e ré vè ler plus é conom iq ue e n place m é m oire q ue la pré cédente , dans la m e s ure où ch aq ue ch aî ne n'occupe q ue l'e s pace q ui lui e s t né ce s s aire (ilfaut toute fois ajoute r, pour ch aq ue ch aî ne , l'e s pace né ce s s aire à un pointe ur).

R e m arque : En toute rigue ur, le tableau table e s t de clas s e autom atiq u e (puis q u'ilapparaî t au s e in d'une fonction - ici le program m e principal). Son e m place m e nt e s t donc alloué au m om e nt de l'e xé cution du program m e (c'e s t-à -dire , ici, dè s le début). Le s constante s ch aî ne s , par contre , voie nt leurs e m place m e nts définis dè s la com pilation. Si notre tableau table avait é té déclaré de m aniè re globale, ilaurait é té de clas s e statiq u e . Son e m place m e nt aurait alors é té ré s e rvé dè s la com pilation. Une te lle distinction e s t toute fois re lative m e nt form e lle e t e lle n'a guè re d'incide nce e n pratiq ue . Ile s t, e n e ffe t, gé né ralem e nt, as s e z te ntant de considérer les variables déclarées dans le program m e principal com m e "q uasi statiq ue s ", dans la m e s ure où, bie n q ue non ré s e rvé e s à la com pilation, e lles n'e n n'occupe nt pas m oins de l'e s pace pe ndant toute la duré e d e l'e xé cution du program m e . *La re ch e rch e du caractè re dans notre tableau table e s t ré alisée par la s e ule instruction : while (ligne[i] != table[j].lettre && j++
D ISCUSSIO N D ans un program m e "ré e l", ilfaudrait pré voir d'acce pte r un m e s s age de plus d'une ligne , ce q ui pos e rait le problèm e de sa m é m orisation. O n pourrait ê tre am e né , soit à lui im pos e r une taille m axim ale, soit à s e tourne r ve rs des m é th odes de "ge s tion dynam iq ue ".

II-3 D é codage m ors e ________________________________________________________________________________________

124

Exe rcice s e n langage C

Enoncé Ecrire un program m e pe rm e ttant de décode r un m e s s age e n m ors e fourni au clavie r sous form e d'une suite de caractè re s . Ce lle-ci pourra com porte r : - des points e t des tire ts re pré s e ntant les code s propre m e nt dits, - un ou plusieurs espaces pour séparer les diffé re nts code s (on n'im pos e ra donc pas à l'utilisate ur d'e m ploye r un "gabarit" fixe pour ch aq ue code ). O n supposera q ue le m e s s age fourni ne dépas s e pas une ligne de 127 caractè re s . Le s code s ine xistants s e ront traduits par le caractè re "?". O n utilisera le tableau de s code s m ors e s fourni dans l'e xe rcice pré cédent (II-2).

Exe m pl e donnez votre message (1 ligne maxi) : -... --- -. .----..-

.-.

.-.-.-

.-.-.

voici la traduction de votre message B O N J O U R . ? ________________________________________________________________________________________

ANALYSE Ce program m e doit donc é tablir une corre s pondance e ntre un code m ors e e t un caractè re . Nous pouvons, pour ce faire , utiliser la m ê m e s tructure q ue dans l'e xe rcice pré cédent. Le décodage d'un caractè re s e fe ra alors e n e xplorant, non plus la partie caractè re , m ais la partie ch aî ne du tableau de s tructure . L'algorith m e de re ch e rch e s e ra donc sim ilaire , la com paraison de caractè re s é tant re m placé e par une com paraison de ch aî ne s . En ce q ui conce rne le m e s s age e n m ors e , nous pouvons le lire par ge ts dans un tableau de 128 caractè re s , nom m é ligne . Le principalproblèm e q ui s e pos e alors à nous e s t ce lui de l'accè s à ch acun de s code s m ors e s conte nus dans ligne ;e n e ffe t, ce ux-ci sont é crits ave c un gabarit variable e t s é paré s par un nom bre variable d'espace s . Nous proposons de ré pé te r le traite m e nt suivant, fondé s ur l'e m ploi d'un pointe ur de caractè re s (indice ) dans le tableau ligne : - Avance r le pointe ur, tant q u'ildésigne un espace.

II. Utilisation de s tructure s 125 - Extraire , à partir de la position indiq ué e par le pointe ur, à l'aide de sscanf, une ch aî ne de longue ur m axim ale 7 (puis q ue aucun code m ors e ne dépas s e ce tte longue ur). Pour ce la, nous fe rons appe lau code form at %7s, leq ue l inte rrom pt l'e xploration, soit q uand un s é parate ur e s t re ncontré , soit lors q ue la longue ur indiq ué e (7) e s t atte inte . - Incré m e nte r le pointe ur de la longue ur de la ch aî ne ainsi lue (car, bie n sûr, iln'aura pas é té m odifié par sscanf).

Program m e #include #include #define NL 37 #define LG 127 main() { struct code { char lettre ; char * morse ; } ; struct code table[NL] = { 'A', ".-", 'D', "-..", 'G', "--.", 'J', ".---", 'M', "--", 'P', ".--.", 'S', "...", 'V', "...-", 'Y', "-.--", '.', ".-.-.-", '0', "-----", '3', "...--", '6', "-....", '9', "----." } ; char ligne[LG+1] ; char code[7] ; int i, j ;

/* nombre de caractères codés */ /* longueur ligne clavier */

'B', 'E', 'H', 'K', 'N', 'Q', 'T', 'W', 'Z',

"-...", ".", "....", "-.-", "-.", "--.-", "-", ".--", "--..",

'1', ".----", '4', "....-", '7', "--...",

/* code morse */ 'C', "-.-.", 'F', "..-.", 'I', "..", 'L', ".-..", 'O', "---", 'R',".-.", 'U', "..-", 'X', "-..-",

'2', "..---", '5', ".....", '8', "---..",

/* pour lire une ligne au clavier */ /* code courant à traduire */

/* lecture message à traduire */ printf ("donnez votre message (1 ligne maxi) : \n") ; gets (ligne) ; printf ("\n\n voici la traduction de votre message\n") ;

126

Exe rcice s e n langage C /* traduction code par code */ i=0 ; while (i
*/ */ */ */ */ */ */

}

Com m e ntaire s *D ans la boucle de saut des espace s é ve ntue ls, on ne ris q ue pas d'aller au-de là de la fin de la ch aî ne conte nue dans ligne , car le caractè re de fin (\0), diffé re nt d'un e s pace , s e rvira de "s e ntine lle". *Par contre , avant d'extraire un nouve au code par sscanf, ile s t né ce s s aire de s'assure r q ue l'on n'e s t pas parve nu e n fin de ligne . En e ffe t, dans ce cas, sscanf fournirait une s uite de caractè re s constituée du caractè re \0 (q ui n'e s t pas considéré par ce tte fonction com m e un s é parate ur) e t des caractè re s s uivants (pré levé s e n de h ors du tableau ligne ). Note z q ue , e n l'abs e nce d'un te lte s t, le m alne s e rait pas trè s grave puis q u'ilre vie ndrait sim plem e nt à place r au plus 7 caractè res dans code , com m e nçant par \0. *La re ch e rch e du code m orse dans le tableau table e s t ré alisée par la s e ule instruction : while ( stricmp (code, table[j].morse) && j++
Le s re m arq ue s faites dans le q uatriè m e com m e ntaire de l'e xe rcice II-1, à propos de la re ch e rch e s é q ue ntie lle e n table, s'appliq ue nt é galem e nt ici.

D ISCUSSIO N

II. Utilisation de s tructure s 127 Notre program m e ne déte cte pas le cas où l'utilisate ur fournit un code m orse de plus de 6 caractè re s . Dans ce cas, en e ffe t, ils e conte nte de le "découpe r" e n tranch es de 6 caractè re s (la derniè re tranch e pouvant avoir une longue ur infé rie ure ). Si l'on souh aitait déte cte r ce ge nre d'anom alie , il faudrait, aprè s ch aq ue e xam e n d'un code , s'assure r q u'il e s t e ffe ctive m e nt suivi d'un e s pace ou d'une fin de ch aî ne .

II-4 Facturation par code ________________________________________________________________________________________

Enoncé R é aliser un program m e é tablissant une facture pouvant porte r sur plusieurs articles . Pour ch aq ue article à facture r, l'utilisate ur ne fournira q ue la quantité e t un num é ro de code à partir duq ue lle program m e devra re trouve r à la fois le libellé e t le prix unitaire . Le program m e devra re fus e r les code s ine xistants. A la fin, ilaffich e ra un ré capitulatif te nant lie u de facture . Le s inform ations re lative s aux diffé re nts articles s e ront définies dans le s ource m ê m e du program m e (e t non dans un fich ie r de données). Elle s e ront toute fois placé e s à un nive au gl obal , de m aniè re à pouvoir, le cas é ch é ant, faire l'obje t d'un source s é paré , appe lable par #include . O n pré voira de ux fonctions : - une pour re ch e rch e r les inform ations re lative s à un article, à partir de s on num é ro de code , - une pour affich e r la facture ré capitulative .

Exe m pl e combien d'articles à facturer ? 3 code article ? 25 quantité de Centrifugeuse au prix unitaire de code article ? 7 ** article inexistant - redonnez le code : 16

370.00 ? 33

128

Exe rcice s e n langage C

quantité de Grille-pain au prix unitaire de 199.50 ? 12 code article ? 26 quantité de Four à raclette 6P au prix unitaire de 295.25 ? 6 FACTURE ARTICLE Centrifugeuse Grille-pain Four raclette 6P

TOTAL

NBRE

P-UNIT

MONTANT

33 12 6

370.00 199.50 295.25

12210.00 2394.00 1771.50

16375.50

________________________________________________________________________________________

ANALYSE L'é noncé nous précise que les codes d'articles s ont num é riq ue s , m ais ilne dit pas q u'ils sont cons é cutifs. Dans ces conditions, ile s t né ce s s aire de m é m oris e r les diffé re nte s valeurs possibles de ce s code s . Com m e nous devons pouvoir associe r à ch aq ue code un libellé (ch aî ne ) e t un prix (ré e l), nous pouvons songe r à utiliser un tableau de s tructure s , dans leq ue lch aq ue é lém e nt contie nt les inform ations re lative s à un article (code , libellé, prix unitaire ). Ce tableau s e ra, com m e dem andé par l'é noncé , déclaré à un nive au globale t initialisé dans sa déclaration. Le travailde la fonction de re ch e rch e (nous la nom m e rons re ch e rch e ) consiste ra à vé rifie r la pré s e nce du code d'article dans le tableau de s tructure ainsi défini. En cas de succè s, e lle e n re s titue ra le rang (ce q ui s e ra suffisant au program m e principalpour affich e r les inform ations corre s pondante s ). Dans le cas contraire , e lle re s titue ra la valeur -1. Note z q ue le code d'article s e ra le s e ulargum e nt de ce tte fonction. Nous voyons donc dé jà com m e nt, pour ch aq ue code (corre ct) fourni par l'utilisate ur, affich e r les inform ations corre s pondante s avant d'en dem ande r la q uantité . M ais, com pte te nu de ce q ue l'édition de la facture doit ê tre faite aprè s les s aisies re lative s à tous les articles , nous devons obligatoire m e nt, pour ch aq ue article à facture r, cons e rve r : - la q uantité , - une inform ation pe rm e ttant d'en retrouve r le libellé e t le prix unitaire . Nous pourrions, ce rte s , arch ive r ce s inform ations dans un tableau. M ais, e n fait, ce la n'e s t pas néce s s aire puis q u'ile s t possible de les re trouve r à partir du rang de l'article dans la structure (le code article convie ndrait é galem e nt, m ais ilnous faudrait alors e xplore r à nouve au notre tableau de s tructure s lors de l'édition de la facture ). Ces deux inform ations s e ront cons e rvées dans deux tableaux (nom m é s q te e t rangart) com portant autant d'élém e nts q ue d'articles à facture r (on e n pré voira un nom bre m axim al).

II. Utilisation de s tructure s 129 La fonction d'édition de la facture (nom m é e facture ) s e conte nte ra alors d'explore r s é q ue ntie llem e nt ces deux tableaux pour re trouve r toute s les inform ations néce s s aire s . Elle re ce vra, e n argum e nt, les adresses des deux tableaux (q te e t rangart), ainsi que le nom bre d'articles à facture r.

Program m e #include /* ------ structure contenant les informations relatives aux */ /* différents articles -------------- */ #define NBART 6 /* nombre total d'articles */ typedef struct { int code ; /* code article */ char * lib ; /* libellé */ float pu ; /* prix unitaire */ } t_article ; t_article article [NBART] = { 11, "Gaufrier", 268.0, 14, "Cafetière 12 T", 235.0, 16, "Grille-pain", 199.50, 19, "Balance de ménage", 278.0, 25, "Centrifugeuse", 370.0, 26, "Four raclette 6P", 295.25 } ; /* ----------------------------------------------------------------------*/ #define NAFMAX 10

/* nombre maxi d'articles à facturer */

main() { int recherche(int) ; void facture(int[], int[], int) ; int naf, rang, codart, i ; int rangart [NAFMAX], qte [NAFMAX] ;

/* /* /* /* /*

proto fonction de recherche d'un article */ proto fonction d'affichage de la facture */ nombre d'articles à facturer */ rang courant d'un article */ code courant d'un article */

/* rang des articles à facturer */ /* quantité de chaque article à facturer */

/* entrée du nombre d'articles à facturer */ printf ("combien d'articles à facturer ? ") ; scanf ("%d", &naf) ;

130

Exe rcice s e n langage C /* boucle de traitement de chaque article à facturer */ for (i=0 ; i
} /***********************************************************/ /* fonction de recherche d'un code article */ /***********************************************************/ int recherche (int codart) { int rang ; /* rang courant d'un article */ rang = 0 ; while (article[rang].code != codart && rang++ < NBART-1) {} ; if (rang
II. Utilisation de s tructure s

131

printf ("\n\n %32s\n\n", "FACTURE") ; printf ("%-20s%5s%10s%12s\n\n", "ARTICLE", "NBRE", "P-UNIT", "MONTANT") ; somme = 0 ; for (i=0 ; i
Com m e ntaire s *Nous avons ch oisi ici d'utilise r type de f pour dé finir sous le nom t_article la structure corre s pondant à un article. Vous constate z q ue le libellé y apparaî t sous la form e d'un pointe ur sur une ch aî ne e t non d'une ch aî ne ou d'un tableau de caractè re s . Dans ces conditions, le tableau article, déclaré de ce type , n'occupe ra q ue 6 e m place m e nts de petite taille (gé né ralem e nt 6 ou 8 octe ts) *Là e ncore , une s e ule instruction pe rm e t d'effe ctue r la re ch e rch e d'un code article dans le tableau article. Voye z, à ce propos, les re m arq ue s faites dans le q uatriè m e com m e ntaire de l'e xe rcice II-1. *Le code form at %-20s, utilisé à deux reprises dans la fonction facture , pe rm e t de "cadre r" une ch aî ne à gauch e .

D ISCUSSIO N *Notre program m e n'e s t pas proté gé contre des ré pons e s incorre ctes de la part de l'utilisate ur. En particulie r, une ré pons e non num é riq ue pe ut e ntraî ne r un com porte m e nt as s e z désagré able. Dans un program m e ré e l, ils e rait né ce s s aire de ré gler conve nablem e nt ce type de problèm e , par e xe m ple e n utilisant fge ts (..., stdin) e t sscanf. *D e m ê m e , dans un program m e ré e l, ilpourrait ê tre judicie ux de dem ande r à l'utilisate ur de confirm e r q ue le produit ch e rch é e s t bien celui dont on vie nt de lui affich e r les inform ations.

132

Exe rcice s e n langage C

*La pré cision offe rte par le type float (6 ch iffre s s ignificatifs) pe ut s e ré vé ler insuffisante .

III : H ASARD ET RECREA TIO NS

Ce ch apitre vous propose un certain nom bre d'exercices correspondant à la ré alisation de program m e s ré cré atifs, bas é s sur l'utilisation du h asard. Les deux pre m ie rs e xe rcice s s ont e s s e ntie llem e nt destiné s à vous m ontre r com m e nt gé né re r de s nom bre s aléatoire s e n langage C.

III-1 Tirage al é atoire ________________________________________________________________________________________

Enoncé Ecrire une fonction fournissant un nom bre e ntie r tiré au h asard e ntre 0 (inclus) e t une valeur n (inclus e ) fournie e n argum e nt. R é aliser un program m e principalutilisant ce tte fonction pour e xam ine r la "distribution" de s valeurs ainsi obte nues dans l'inte rvalle [0, 10]. Le nom bre de tirage s à ré aliser sera lu e n donné e e t le program m e affich e ra le nom bre de fois où ch acune de ce s valeurs aura é té obte nue .

Exe m pl e combien de tirages : 1100 nombre de tirages obtenus 0 : 106 1 : 95

134

Exe rcice s e n langage C 2 3 4 5 6 7 8 9 10

: : : : : : : : :

115 95 91 103 103 101 92 94 105

Indication : ile s t né ce s s aire de faire appe là la fonction rand de la "biblioth è q ue s tandard". ________________________________________________________________________________________

ANALYSE Ilfaut faire appe là la fonction rand. Ce lle-ci fournit un nom bre e ntie r, tiré de façon "ps e udo-aléatoire " dans l'inte rvalle [0, R A ND_M A X] , ch aq ue nom bre de ce t inte rvalle ayant q uasim e nt la m ê m e probabilité d'ê tre tiré . Note z q ue la valeur de RAND_M AX e s t définie dans stdlib.h ;d'aprè s la norm e , e lle n'e s t jam ais infé rie ure à la capacité m inim ale d'un int, c'e s t-à -dire 32767. Pour aboutir au ré s ultat voulu, une dém arch e consiste à transform e r un te lnom bre e n un nom bre ré e lapparte nant à l'inte rvalle [0,1[. Ilsuffit e nsuite de m ultiplie r ce ré e lpar n+1 e t d'en prendre la partie e ntiè re pour obte nir le ré s ultat e s com pté . O n pe ut alors m ontre r q ue les valeurs 0, 1, ... n-1, n sont q uasi équiprobables . Pour obte nir un te lnom bre aléatoire , nous pouvons diviser le nom bre fourni par rand par la valeur RAND_M AX+ 1 (il faut é vite r de diviser par RAND_M AX, car la valeur 1 ris q ue rait alors d'ê tre obte nue - e n m oye nne une fois sur RAND_M AX!). Là e ncore , on pe ut, de m aniè re form e lle, m ontre r q ue s i la loi de probabilité e s t uniform e s ur [0,1[, ile n va de m ê m e de ce lle du nom bre ainsi fabriq ué dans l'inte rvalle d'entie rs [0,n].

Program m e

#include #include

/* pour la fonction rand */

#define N 10

/* les tirages se feront entre 0 et N */

main() {

III. H asard e t ré cré ations int aleat (int) ; int ntir, t[N+1], i ;

135

/* prototype fonction de tirage aléatoire */ /* nombre de tirages requis */ /* tableau comptage tirages de chaque valeur */

printf ("combien de tirages : ") ; scanf ("%d", &ntir) ; for (i=0 ; i<=N ; i++) t[i] = 0 ; for (i=1 ; i<=ntir ; i++) t[aleat(N)]++ ; printf ("nombre de tirages obtenus\n") ; for (i=0 ; i<=N ; i++) { printf ("%4d : ", i) ; printf ("%6d\n", t[i]) ; } } /********************************************************/ /* fonction de tirage aléatoire d'un nombre dans [0, n] */ /********************************************************/ int aleat (int n) { int i ; i = rand() / (RAND_MAX + 1.) * (n+1) ; return (i) ; }

Com m e ntaire s *D ans la fonction aleat, la division par RAND_M AX+ 1 doit bien sûr s'effe ctue r sur des valeurs ré e lles . M ais, de plus, il faut pre ndre garde à ne pas é crire le diviseur sous la form e RAND_M AX + 1. En e ffe t, ce lui-ci s e rait é valué dans le type int e t, dans le cas (fré q ue nt) où la valeur de RAND_M AX e s t e xacte m e nt la valeur m axim ale du type int, l'addition de 1 à RAND_M AX conduirait à la valeur ... -1 (le dépas s e m e nt de capacité n'é tant jam ais déte cté e n cas d'opérations sur de s e ntie rs).

D ISCUSSIO N

136 Exe rcice s e n langage C En gé né ral, la fonction rand fournit toujours la m ê m e s uite de valeurs, d'une e xé cution à une autre . L'e xe rcice s uivant vous m ontre com m e nt é vite r ce ph é nom è ne .

III-2 Tirage al é atoire variabl e ________________________________________________________________________________________

Enonce Ecrire une fonction fournissant un nom bre e ntie r tiré au h asard e ntre 0 e t une valeur n fournie e n argum e nt. La suite des valeurs re s titué e s par ce tte fonction (lors q u'on l'appe lle à dive rs e s re pris e s ) devra ê tre diffé re nte d'une exécution à une autre e t ne pas dépendre d'une quelconq ue inform ation fournie par l'utilisate ur. Com m e dans l'e xe rcice pré cédent, on ré alisera un program m e principal utilisant ce tte fonction pour e xam ine r la "distribution" de s valeurs ainsi obte nues dans l'inte rvalle [0,10]. Pour ce faire , on lira e n donné e s le nom bre de tirage s à ré aliser et le program m e affich e ra le nom bre de fois où ch acune des valeurs aura é té obte nue . Suggestion : ilfaut "initialiser" conve nablem e nt le "gé né rate ur de nom bre s aléatoire ", e n utilisant la fonction srand. La "graî ne " né ce s s aire pe ut ê tre fabriq ué e à l'aide de la fonction tim e , de façon à avoir un caractè re s uffisam m e nt im pré visible.

Exe m pl es (ils'agit là des ré s ultats corre s pondant à deux exécutions diffé re ntes du m ê m e program m e ) combien de tirages : 1100 nombre de tirages obtenus 0 : 124 1 : 104 2 : 97 3 : 97 4 : 89 5 : 93 6 : 105

III. H asard e t ré cré ations 7 8 9 10

: : : :

137

109 110 89 83 ___________________

combien de tirages : 1100 nombre de tirages obtenus 0 : 104 1 : 98 2 : 98 3 : 106 4 : 98 5 : 97 6 : 99 7 : 109 8 : 99 9 : 96 10 : 96 ________________________________________________________________________________________

ANALYSE En langage C, la fonction srand pe rm e t d'initialiser le gé né rate ur de nom bre s aléatoire s . Ilfaut ce pe ndant lui fournir une "graî ne ", c'e s t-à -dire un nom bre e ntie r (de type unsigne d int) q ui dé te rm ine ra le pre m ie r nom bre tiré par rand. Ce tte m é th ode pe rm e t ainsi, si on le s ouh aite , d'obte nir à volonté une m ê m e s uite de nom bre s aléatoire s ;ilfaut d'ailleurs note r q ue , par dé faut, tout s e pas s e com m e s i srand é tait appe lé, e n début de l'e xé cution d'un program m e , ave c l'argum e nt 1. Ici, par contre , nous souh aitons obte nir une s uite diffé re nte d'une exécution à une autre . Une s olution à ce problèm e consiste à ch oisir une "graî ne " aléatoire . Bie n sûr, iln'e s t pas q ue s tion de faire appe là rand dans ce cas. Par contre , la fonction tim e fournit une date , e xprim é e e n s e conde s . Ce lle-ci possè de un caractè re s uffisam m e nt im pré visible pour ê tre utilisée com m e graî ne . Ce tte initialisation du gé né rate ur de nom bre s aléatoires doit toute fois n'ê tre ré alisée qu'une seule fois pour une e xé cution donné e . Dans le cas contraire , on ris q ue rait, e n e ffe t, d'obte nir plusieurs fois de suite les m ê m e s nom bre s . Si l'on souh aite q ue ce problèm e s oit pris e n ch arge par la fonction de tirage d'un nom bre e lle-m ê m e , ile s t né ce s s aire q ue ce tte derniè re s oit capable de le faire lors de son prem ie r appe l(e t uniq ue m e nt à ce m om e nt-là). Ce m é canism e pas s e par l'e m ploi d'une variable de clas s e statiq u e .

138

Exe rcice s e n langage C

Program m e #include #include #include

/* pour la fonction rand */ /* pour la fonction time */

#define N 10

/* les tirages se feront entre 0 et N */

main() { int aleat (int) ; int ntir, t[N+1], i ;

/* prototype fonction de tirage aléatoire */ /* nombre de tirages requis */ /* tableau comptage tirages de chaque valeur */

printf ("combien de tirages : ") ; scanf ("%d", &ntir) ; for (i=0 ; i<=N ; i++) t[i] = 0 ; for (i=1 ; i<=ntir ; i++) t[aleat(N)]++ ; printf ("nombre de tirages obtenus\n") ; for (i=0 ; i<=N ; i++) { printf ("%4d : ", i) ; printf ("%6d\n", t[i]) ; } } /********************************************************/ /* fonction de tirage aléatoire d'un nombre dans [0, n] */ /********************************************************/ int aleat (int n) { int i ; static int prem = 1 ; /* drapeau premier appel */ time_t date ; /* pour l'argument de time */ /* time_t est un type entier défini dans time.h */ /* initialisation générateur au premier appel */ if (prem) { srand (time(&date)) ; prem = 0 ; }

III. H asard e t ré cré ations

139

/* génération nombre */ i = rand() / (RAND_MAX + 1.) * (n+1) ; return (i) ; }

Com m e ntaire s *Le m é canism e du traite m e nt particulie r à e ffe ctue r au pre m ie r appe le s t ré alisé grâ ce à la variable pre m , déclaré e d e clas s e s tatiq ue . Ce tte variable e s t initialisée à un, lors de la com pilation. D è s le pre m ie r appe l, e lle e s t m ise à zé ro e t e lle garde ra e nsuite ce tte valeur jus q u'à la fin de l'e xé cution du program m e . Ainsi, la fonction srand n'e s t e ffe ctive m e nt appe lée q u'une s e ule fois, lors du prem ie r appe lde notre fonction aleat. *La fonction tim e fournit e n re tour le te m ps (e xprim é e n s e conde s ) é coulé depuis une certaine "origine " dépendant de l'im plém e ntation. Le type de ce tte valeur dé pe nd, lui aussi, de l'im plém e ntation ;toute fois, la norm e pré voit q u'ile xiste , dans tim e .h , un sym bole tim e _t (défini par type de f) pré cisant le type e ffe ctive m e nt e m ployé . Ici, lors q ue nous transm e ttons ce tte valeur à srand, ile s t possible q u'apparais s e une conve rsion du type tim e _t dans le type unsigne d int ; ici, ce la n'a guè re d'im portance , dans la m e s ure où, m ê m e s i ce tte conve rsion est "dégradante ", la valeur obte nue re s te ra im pré visible pour l'utilisate ur. D 'autre part, la fonction tim e ne s e conte nte pas de fournir une "h e ure " e n re tour ;e lle range é galem e nt ce tte m ê m e inform ation à l'adre s s e q u'on lui fournit (obligatoire m e nt) e n argum e nt ;c'e s t ce q ui justifie l'e xiste nce de la variable date (q ui n'e s t pas utilisée par ailleurs) e t q ui doit, ici, absolum e nt ê tre déclarée dans le "bon type ", sous peine de risquer d'aboutir à un é cras e m e nt inte m pe s tif de données (dans le cas où on aurait déclaré date d'un type "plus petit" q ue le type e ffe ctif).

III-3 A l é a d'é toil es ________________________________________________________________________________________

140

Exe rcice s e n langage C

Enoncé Affich e r au h asard un ce rtain nom bre d'étoiles (caractè re "*") à l'inté rie ur d'un re ctangle. Le nom bre d'étoiles souh aité e s , ainsi que le nom bre de ligne s e t de colonnes du rectangle s e ront fournis e n donné e s . Le program m e vé rifie ra q ue la zone e s t as s e z grande pour re ce voir le nom bre d'étoiles re q uis. O n é vite ra q ue plusieurs é toiles ne s oie nt superposées.

Exe m pl e combien de lignes : 10 combien de colonnes : 45 combien de points : 200 ** * **** ** *** * ** *** * *** ** * * * ** * ** * * ****** * ** ** * * ** * * * ***** *** ** * *** * * * *** * * * * * ** * * ** * * ** ** ** **** ** ** ** ** * * * * * * ** *** * * * ** * * * * ** *** ** ** * ** * * * * ** * * * * * ***** ** ** * * * * ***** ** *** * ** * ***** **** * * *** * ** **** * ***** ________________________________________________________________________________________

ANALYSE Nous utiliserons un tableau de caractè re s à deux dim e nsions, dans leq ue lch aq ue é lém e nt re pré s e nte ra une case de notre re ctangle. Nous convie ndrons q ue le pre m ie r indice re pré s e nte le rang de la ligne e t q ue le s e cond indice re pré s e nte le rang de la colonne . Com m e l'utilisate ur doit pouvoir ch oisir les dim e nsions du rectangle conce rné , nous prévoirons de donne r à notre tableau une taille s uffisante pour couvrir tous les cas possibles (nous avons ch oisi, ici, 25 lignes de 80 caractè re s ) ;ce la signifie q ue , la plupart du te m ps, le program m e n'utilisera qu'une partie de ce tableau. Au départ, nous initialiserons tous les é lém e nts de la "partie utile" de ce tableau ave c le caractè re e s pace . Nous ch oisirons ensuite au h asard les é lém e nts dans les q ue ls nous devrons place r un caractè re "*". Pour ce faire , ilnous suffira de tire r au h asard un num é ro de ligne e t un num é ro de colonne jusqu'à ce q ue l'e m place m e nt corre s pondant soit disponible (caractè re e s pace ). L'algorith m e de tirage au h asard d'un nom bre e ntie r apparte nant à un inte rvalle donné a é té e xposé dans l'analyse de l'e xe rcice III-1.

III. H asard e t ré cré ations 141 Ilne nous re s te ra plus q u'à affich e r, par e xe m ple ave c la fonction putch ar, les diffé re nts é lém e nts de notre tableau, e n pré voyant un "ch ange m e nt de ligne " aux m om e nts opportuns.

Program m e #include #include #include #include #define NY 25 #define NX 80 main() { int aleat (int) ; int ny, nx, ix, iy, nb_points, i, j ; char ecran [NX] [NY] ; const char blanc = ' ', point = '*' ;

/* pour memset */ /* nombre total de lignes de l'écran */ /* nombre total de colonnes de l'écran */

/* /* /* /* /* /*

prototype fonction tirage aléatoire */ nombre de lignes du rect. considéré */ nombre de col. du rect. considéré */ colonne courante */ ligne courante */ nombre de points à tirer */

/* image de l'écran */ /* caractère de remplissage */ /* représentation d'un point */

/* entrée des dimensions du rectangle considéré ... ... et du nombre de points souhaités */ do { printf ("combien de lignes : ") ; scanf ("%d", &ny) ; } while (ny<=0 || ny>=NY) ; do { printf ("combien de colonnes : ") ; scanf ("%d", &nx) ; } while (nx<=0 || nx>=NX) ; do { printf ("combien de points : ") ; scanf ("%d", &nb_points) ; } while (nb_points > nx*ny || nb_points < 1 ) ;

142

Exe rcice s e n langage C /* remplissage aléatoire du tableau image d'écran */ memset (ecran, blanc, NX*NY) ; for (i=1 ; i<=nb_points ; i++) { do { ix = aleat (nx-1) ; iy = aleat (ny-1) ; } while ( ecran [ix] [iy] != blanc) ; ecran [ix] [iy] = point ; } /* affichage du tableau image d'écran */ for (j=0 ; j
} /*******************************************************/ /* fonction de tirage aléatoire d'un nombre dans [0,n] */ /*******************************************************/ int aleat (int n) { int i ; static int prem = 1 ; /* drapeau premier appel */ time_t date ; /* pour l'argument de time */ /* initialisation générateur au premier appel */ if (prem) { srand (time(&date) ) ; prem = 0 ; } /* génération nombre aléatoire */ i = rand() / (RAND_MAX + 1.) * (n+1) ; return (i) ; }

Com m e ntaire s

III. H asard e t ré cré ations *L'initialisation de la partie utile du tableau ave c le caractè re e s pace aurait pu s e program m e r ainsi :

143

for (i=0 ; i
Ici, nous avons préfé ré faire appe là la fonction m e m s e t, d'e xé cution plus rapide . Toute fois, ce lle-ci re m plit d'un caractè re donné une suite d'octe ts cons é cutifs ;ce ci e xclut donc de lim ite r l'initialisation à la partie utile du tableau. Ilne faut pas oublie r, e n e ffe t, q ue ce lle-ci n'e s t pas form é e d e nx*ny octe ts cons é cutifs (q uoiq ue , e n toute rigue ur, e n te nant com pte de la m aniè re dont sont rangé s e n m é m oire les diffé re nts é lém e nts d'un tableau, ilsoit possible de lim ite r l'initialisation à nx*NY élém e nts cons é cutifs). *Nous avons re pris la fonction aleat de l'e xe rcice pré cédent. Ce lle-ci tire une valeur e ntiè re au h asard e ntre 0 e t une lim ite q u'on lui fournit e n argum e nt ;de plus, lors de son prem ie r appe l, e lle e ffe ctue une initialisation du gé né rate ur de nom bre s aléatoire s .

III-4 Es tim ation de pi ________________________________________________________________________________________

Enoncé Calculer une valeur approch é e d e pi, par la m é th ode s uivante : - on tire un ce rtain nom bre de points au h asard dans un carré donné. - on dé te rm ine le rapport e ntre le nom bre de ce s points apparte nant au ce rcle inscrit dans le carré e t le nom bre total de points tiré s . Ce rapport fournit une e s tim ation de la valeur de pi/4. Le nom bre totalde points à tire r s e ra fourni e n donné e .

Exe m pl e combien de points ? 10000 estimation de pi avec 10000 points : 3.164800e+000

144

Exe rcice s e n langage C

________________________________________________________________________________________

ANALYSE Nous ch oisirons un carré de côté unité . Nous convie ndrons de prendre son coin bas gauch e com m e origine d'un repè re carté s ie n. Nous tire rons alors au h asard le nom bre de points voulus, à l'inté rie ur de ce carré . Plus précisém e nt, pour ch aq ue point, nous déte rm ine rons au h asard ses deux coordonné e s , e n tirant deux nom bre s ré e ls apparte nant à l'inte rvalle [0,1]. A ce t e ffe t, nous fe rons appe là la m é th ode e xposée dans l'analyse de l'e xe rcice III-1. Pour ch aq ue point, nous calculerons sa distance au ce ntre du carré (de coordonné e s : 0.5, 0.5) e t nous considérerons qu'il appartie nt au ce rcle inscrit si ce tte distance e s t infé rie ure à 0.5 (note z q ue , par souci de s im plicité , nous travaillerons e n fait ave c le carré de ce tte distance ).

Program m e #include #include main() { float caleat(void) ; float x, y, d2, pi ; int np, nc, i ;

/* /* /* /* /* /*

prototype fonction de tirage valeur aléatoire */ coordonnées d'un point courant */ distance (au carré) d'un point courant au centre */ valeur approchée de pi */ nombre de points à tirer */ nombre de points à l'intérieur du cercle */

printf ("combien de points ? ") ; scanf ("%d", &np) ; for (nc=0, i=1 ; i<=np ; i++) { x = caleat() ; y = caleat() ; d2 = (x-0.5) * (x-0.5) + (y-0.5) * (y-0.5) ; if (d2 <= 0.25) nc++ ; } pi = (4.0 * nc) / np ;

III. H asard e t ré cré ations

145

printf ("estimation de pi avec %d points : %e", np, pi) ; } float caleat (void) /* fonction fournissant une valeur aléatoire */ /* appartenant à l'intervalle [0-1] */ { return ( (float) rand() / (RAND_MAX + 1.0) ) ; }

D ISCUSSIO N Notre fonction de tirage aléatoire d'un entie r fournit toujours la m ê m e s uite de valeurs. Ce q ui signifie q ue , pour un nom bre donné de points, nous obtie ndrons toujours la m ê m e e s tim ation de pi. Vous pouve z é vite r ce ph é nom è ne e n utilisant la fonction ré alisée dans l'e xe rcice III-2.

III-5 Je u du de vin ________________________________________________________________________________________

Enoncé Ecrire un program m e q ui ch oisit un nom bre e ntie r au h asard e ntre 0 e t 1000 e t q ui de m ande à l'utilisate ur de le "devine r". A ch aq ue proposition faite par le joue ur, le program m e ré pondra e n situant le nom bre propos é par rapport à ce lui à devine r (plus grand, plus petit ou gagné ). Lors q ue le joue ur aura de viné le nom bre ch oisi, ou lors q u'un nom bre m axim alde coups (10) aura é té dépas s é , le program m e affich e ra la ré capitulation des diffé re nte s propositions.

Exe m pl e Devinez le nombre que j'ai choisi (entre 1 et 1000) votre proposition : 500 ----------- trop grand

146

Exe rcice s e n langage C

votre proposition : 250 ----------- trop grand votre proposition : 125 ----------- trop grand votre proposition : 64 ----------- trop grand votre proposition : 32 ----------- trop grand votre proposition : 16 ----------- trop grand votre proposition : 8 ----------- trop petit votre proposition : 12 ----------- trop grand votre proposition : 10 ++++ vous avez gagné en 9 coups ---- Récapitulation des coups joués ---500 250 125 64 32 16 8 12 10

trop grand trop grand trop grand trop grand trop grand trop grand trop petit trop grand exact

________________________________________________________________________________________

ANALYSE Le program m e com m e nce ra par tire r un nom bre e ntie r au h asard, suivant la dém arch e e xposée dans l'analyse de l'e xe rcice III-1. Ildevra e nsuite ré pé te r l'action : faire joue r le joue ur jusqu'à ce q ue le joue ur ait gagné ou q u'ilait dépas s é le nom bre m axim alde coups perm is. L'action e n q ue s tion consiste s im plem e nt à :

III. H asard e t ré cré ations

147

- D e m ande r au joue ur de propos e r un nom bre . - Cons e rve r ce nom bre dans un tableau (pour pouvoir é tablir la ré capitulation finale). Note z q ue , com pte te nu de ce q u'un nom bre de coups m axim ale s t im pos é , ce dernie r fournira le nom bre m axim ald'élém e nts de notre tableau. - Com pare r le nom bre fourni ave c la valeur ch oisie par le program m e e t affich e r le m e s s age corre s pondant.

Program m e

#include #include #define NCOUPS 15 #define NMAX 1000 main() { int aleat(int) ; int nc, ndevin, n, prop[NMAX], i ;

/* nombre maximal de coups autorisés */ /* valeur maximale du nombre à deviner */

/* /* /* /* /*

prototype fonction de tirage d'un nombre au hasard */ compteur du nombre de coups joués */ nombre à deviner */ nombre courant proposé par le joueur */ tableau récapitulatif des nombres proposés */

/* initialisations et tirage du nombre secret */ nc = 0 ; printf ("Devinez le nombre que j'ai choisi (entre 1 et %d)\n", NMAX) ; ndevin = aleat(NMAX) ;

/* déroulement du jeu */ do { printf ("votre proposition : ") ; scanf ("%d",&n) ; prop [nc++] = n ; if (n < ndevin) printf ("----------- trop petit\n") ; else if (n > ndevin) printf ("----------- trop grand\n") ; } while (n != ndevin && nc < NCOUPS) ; /* affichage résultats */

148

Exe rcice s e n langage C if (n == ndevin) printf ("\n\n++++ vous avez gagné en %d coups\n", nc) ; else { printf ("\n\n---- vous n'avez pas trouvé\n") ; printf ("le nombre choisi était %d\n", ndevin) ; } /* affichage récapitulation */ printf ("\n ---- Récapitulation des coups joués ----\n\n") ; for (i=0 ; i ndevin) printf ("trop grand \n") ; else if (prop[i] < ndevin) printf ("trop petit\n") ; else printf ("exact\n") ; }

} /*******************************************************/ /* fonction de tirage aléatoire d'un nombre dans [0,n] */ /*******************************************************/ int aleat(int n) { int i = rand() / (RAND_MAX + 1.) * (n+1) ; return i ; }

D ISCUSSIO N Notre fonction de tirage aléatoire d'un nom bre e ntie r fournit toujours la m ê m e valeur, ce q ui gâ ch e q ue lque pe u l'inté rê t du je u. D ans la pratiq ue , ils e rait né ce s s aire de re m place r la fonction aleat de ce program m e par ce lle proposée dans l'e xe rcice III-2, laq ue lle pe rm e t d'obte nir un nom bre diffé re nt d'une e xé cution à une autre .

III-6 M as te rm ind ________________________________________________________________________________________

III. H asard e t ré cré ations

149

Enoncé R é aliser un program m e q ui ch oisit au h asard une com binaison de 5 ch iffre s (com pris e ntre 1 e t 8) e t q ui de m ande à l'utilisate ur de la devine r. A ch aq ue proposition, le program m e pré cis e ra : - le nom bre de ch iffre s exacts propos é s à la bonne pl ace, - le nom bre de ch iffre s exacts m ais proposés à la m auvaise pl ace. Les diffé re nte s propositions du joue ur s e ront fournie s s ous la form e de 5 ch iffre s cons é cutifs (sans aucun s é parate ur), validés par re turn. Le program m e devra traite r conve nablem e nt le cas des ré pons e s incorre cte s : lettre à la place d'un ch iffre , ré pons e trop courte ou trop longue , ch iffre incorre ct (nulou supérieur à 8). O n pré voira un nom bre lim ite d'essais, au-de là duq ue l le program m e s 'inte rrom pra e n indiq uant q ue lle é tait la com binaison à devine r.

Exe m pl e proposition ? : 12345 2 P 0 C proposition ? : 23456 0 P 1 C proposition ? :

34567

proposition ? :

45678

proposition ? : ** incorrect ** proposition ? : ** incorrect ** proposition ? :

56789

proposition ? :

11333

proposition ? :

11313

0 P 1 C 0 P 0 C

1133é 11332 3 P 1 C 4 P 0 C

5 P 0 C vous avez trouvé en 7 coups ________________________________________________________________________________________

150

Exe rcice s e n langage C

ANALYSE Ilparaî t as s e z nature ld'utiliser un tableau à 5 é lém e nts pour y range r la com binaison tiré e au h asard. Note z q ue nous pourrions é galem e nt tire r au h asard un nom bre de 5 ch iffre s , m ais ilfaudrait, de toute façon, e n e xtraire ch acun de s ch iffre s ;de plus, la m é th ode s e rait difficilem e nt gé né ralisable à un nom bre q ue lconq ue de positions. La principale difficulté ré s ide dans l'analyse de la proposition du joue ur. D ans la com paraison des deux tableaux (com binaison tiré e par le program m e e t com binaison proposé e par le joue ur), ilfaudra te nir com pte des re m arq ue s suivante s : - Un ch iffre com pté "à sa place " ne doit pas pouvoir ê tre é galem e nt com pté com m e "e xact, m ais m alplacé ". - Lors q u'un tirage com porte plusieurs ch iffre s identiq ue s , ilne faut pas q u'un m ê m e ch iffre de la proposition du joue ur puis s e ê tre com pté plusieurs fois com m e e xact. - Lors q u'une proposition com porte plusieurs ch iffre s identiq ue s , il ne faut pas les considérer tous com m e corre s pondant à un m ê m e ch iffre du tirage . Nous vous proposons la m é th ode s uivante : 1 - Nous re ch e rch ons tout d'abord les ch iffre s e xacts placé s e n bonne position. A ch aq ue fois q u'une coïncide nce e s t re levé e , nous supprim ons le ch iffre , à la fois dans la proposition du joue ur e t dans le tirage (e n le re m plaçant, par e xe m ple, par la valeur 0). 2 - Nous re pre nons e nsuite , un à un, ch acun de s ch iffres du tirage q ui n'ont pas é té s upprim é s (c'e s t-à -dire q ui sont diffé re nts de 0). Nous les com parons à ch acun de s ch iffres de la proposition. Là e ncore , si une coïncide nce e s t re levé e , nous supprim ons les ch iffre s corre s pondants, à la fois dans la proposition e t dans le tirage . Note z bie n q u'il faut absolum e nt é vite r de considérer les ch iffres déjà supprim és du tirage : ils ris q ue raie nt d'ê tre trouvé s é gaux à d'autre s ch iffre s s upprim és de la proposition. Ce tte m é th ode q ui dé truit le tirage nous oblige né ce s s aire m e nt à e n faire une copie avant d'entam e r l'analyse de la proposition. Nous avons ch oisi de réaliser trois fonctions : - tirage : tirage au h asard de la com binaison (tableau de 5 e ntie rs) à devine r. - e ntre e : e ntré e d e la proposition du joue ur. Ilparaî t logiq ue q ue ce tte fonction fournis s e ce tte proposition dans un tableau d'e ntie rs. Toute fois, afin de traite r conve nablem e nt les cas de ré pons e s incorre cte s , la proposition du joue ur s e ra tout d'abord lue dans une ch aî ne à l'aide de la fonction cge ts (son m é canism e e s t décrit dans l'e xe rcice II-4). - analy s e : analyse de la proposition du joue ur, suivant l'algorith m e décrit pré cédem m e nt.

Program m e

III. H asard e t ré cré ations #include #include #include #define NPOS 5 #define NCHIF 8 #define NCMAX 12

/* nombre de positions */ /* nombre de chiffres (ici, de 1 a 8) */ /* nombre maximal de coups */

main() { void tirage (int []) ; int entree (int []) ; void analyse(int [], int[], int[], int []) ; int tir[NPOS], prop[NPOS], ncoup, bpos, bchif ;

/* /* /* /* /*

/*****************************/ /* prototypes fonctions */ /*****************************/

combinaison tirée par le programme */ proposition du joueur */ compteur de coups joués */ nombre de chiffres bien placés */ nombre de chiffres exacts mais mal placés */

/* initialisations */ tirage (tir) ; ncoup = 0 ; /* déroulement du jeu */ do { while (printf ("proposition ? : "), entree(&prop) ) printf ("\n** incorrect **\n") ; analyse (prop, tir, &bpos, &bchif) ; printf ("\n %22d P %d C\n", bpos, bchif) ; ncoup++ ; } while (bpos < NPOS && ncoup < NCMAX) ; /* affichage résultats */ if (bpos == NPOS) printf ("vous avez trouvé en %d coups", ncoup) ; else { int i ; printf ("vous n'avez pas trouvé en %d coups\n", NCMAX) ; printf ("la bonne combinaison était : ") ; for (i=0 ; i
151

152

Exe rcice s e n langage C

/*************************************************/ /* fonction de tirage de la combinaison secrète */ /*************************************************/ void tirage (int tir []) { int i ; for (i=0 ; i
/*************************************************/ /* fonction de lecture de la proposition du joueur */ /*****************************************************/ int entree (int prop []) { char ch[NPOS+3] ; /* chaîne où sera lue la proposition du joueur */ int i ; /* lecture proposition joueur dans chaîne ch */ ch[0] = NPOS+1 ; /* préparation longueur maxi chaîne lue */ cgets (ch) ; /* contrôles */ if (strlen (&ch[2]) != NPOS) return(-1) ; for (i=2 ; i '1'+NCHIF-1) return(-1) ; /* extraction des chiffres choisis */ for (i=0 ; i
III. H asard e t ré cré ations

153

/* comptage bonnes positions */ *bpos = 0 ; for (i=0 ; i
Com m e ntaire s *Le nom bre de positions (NPO S) e t le nom bre de ch iffre s (NCH IF) ont é té définis par #de fine , ce q ui e n facilite l'é ve ntue lle m odification. *La fonction tirage fait appe là l'algorith m e de tirage au h asard d'un e ntie r, te lq ue nous l'avons e xposé dans l'e xe rcice III-1. Toute fois, ici, le nom bre tiré doit apparte nir à l'inte rvalle [1,NCH IF] e t non à l'inte rvalle [0,NCH IF]. C'e s t ce q ui e xpliq ue q ue le nom bre ré e ltiré dans l'inte rvalle [0,1[ soit m ultiplié par NCH IF e t q ue l'on ajoute 1 au ré s ultat. *La fonction e ntre e lit, com m e pré vu, la proposition du joue ur sous form e d'une ch aî ne . Elle e n e ffe ctue les contrôles re q uis e n re s tituant la valeur 0 lors q ue la ré pons e e s t valide et la ré pons e -1 dans le cas contraire . Note z q ue la décision de dem ande r, e n cas d'erreur, une nouve lle proposition au joue ur e s t prise dans le program m e principale t non dans la fonction e lle-m ê m e . *Le s argum e nts de la fonction analy s e sont transm is par leur adre s s e , afin q ue leur valeur puis s e ê tre m odifié e . C'e s t ce q ui justifie leur dé claration sous form e de pointe urs sur de s e ntie rs. N'oublie z pas q ue les nom s de tableaux corre s ponde nt à leur adre s s e ;c'e s t ce q ui justifie q ue dans l'appe lde analy s e , on trouve e ffe ctive m e nt les sym boles prop e t tir, alors q ue , par ailleurs, on y trouve & bpos e t & bch if. *D ans la boucle s uivante (du program m e principal) :

154

Exe rcice s e n langage C while (printf ("proposition ? : "), entree(&prop) ) printf ("\n** incorrect **\n") ;

l'e xpre s s ion figurant dans w h ile utilise un "opérate ur s é q ue ntie l", ce q ui pe rm e t ainsi de sim plifie r q ue lque pe u l'é criture . A titre indicatif, voici de ux constructions é q uivalente s , l'une parfaite m e nt structuré e , l'autre bas é e s ur l'utilisation de bre ak (les valeurs des sym boles VR A I e t FAUX étant re s pe ctive m e nt 1 e t 0) : ok = FAUX ; while (!ok) { printf ("proposition ? : ") ; if (entree(&prop)) ok = VRAI ; else printf ("\n** incorrect **\n") ; }

do { printf ("proposition ? : ") ; if (entree(&prop)) break ; else printf ("\n** incorrect **\n) ; while(1) ;

D ISCUSSIO N *Ici, la saisie de la proposition du joue ur e s t parfaite m e nt satisfaisante , m ê m e pour un program m e "ré e l". En particulie r, e lle autoris e les corre ctions, m ê m e aprè s q ue l'utilisate ur a frappé le dernie r ch iffre . *Par contre , te lq u'ile s t propos é ici, ce program m e ch oisit toujours la m ê m e com binaison, ce q ui e nlève q ue lque inté rê t à la pratiq ue ré guliè re du je u (m ais q ui pe ut facilite r la m ise au point du program m e ). Pour ré m édier à ce tte lacune , il suffit d'introduire , dans la fonction tirage , une initialisation du gé né rate ur de nom bre s aléatoire s , lors de son prem ie r appe l, com m e nous l'avons fait dans l'e xe rcice III-2. *Le program m e s upporte , sans aucune m odification, de s valeurs q ue lconq ues de NPO S e t des valeurs de NCH IF infé rie ure s à 10. Ile s t facile d'aller au-de là, e n m odifiant sim plem e nt la fonction e ntre e .

IV : TRIS, FUSIO NS ET RECH ERCH E EN TA BLE

Nous vous proposons ici de s e xe rcices de program m ation d'algorith m e s classiques ayant trait aux tris e t fusions de tableaux, ainsi qu'à la re ch e rch e e n table.

IV-1 Tri par e xtraction s im pl e ________________________________________________________________________________________

Enoncé R é aliser un program m e de tri par valeurs décroissantes d'un tableau d'e ntie rs, e n utilisant l'algorith m e dit "par e xtraction sim ple" q ui se définit de la m aniè re s uivante : - O n re ch e rch e le plus grand de s n é lém e nts du tableau. - O n é ch ange ce t é lém e nt ave c le pre m ie r é lém e nt du tableau. - Le plus petit é lém e nt s e trouve alors e n pre m iè re position. O n pe ut alors appliq ue r les deux opé rations précédente s aux n-1 é lém e nts re s tants, puis aux n-2, ... e t ce la jus q u'à ce q u'ilne re s te plus q u'un s e ulé lém e nt (le dernie r - q ui e s t alors le plus petit). Le program m e affich e ra tous les "ré s ultats inte rm édiaire s ", c'e s t-à -dire les valeurs du tableau, aprè s ch aq ue é ch ange de deux élém e nts.

Exe m pl e combien de valeurs à trier : 8 donnez vos valeurs à trier

156

Exe rcice s e n langage C

3 9 2 7 11 6 2 8 ---- valeurs à trier ---3 9 2 7 11 6

2

8

11 11 11 11 11 11 11

6 6 6 6 3 3 3

2 2 2 2 2 2 2

8 8 2 2 2 2 2

3

2

2

9 9 9 9 9 9 9

2 2 8 8 8 8 8

7 7 7 7 7 7 7

3 3 3 3 6 6 6

---- valeurs triées ---11 9 8 7 6

________________________________________________________________________________________

ANALYSE L'algorith m e propos é par l'é noncé pe ut s e form aliser com m e s uit, e n te nant com pte des conve ntions d'indice s propre s au langage C : R é pé te r, pour i variant de 0 à n-2 : - re ch e rch e r k

m

te lq ue t(k ) soit le plus grand de s t(k ), pour k allant de i à n-1, m

- é ch ange r les valeurs de t(k ) e t de t(i). m

Program m e #include #define NMAX 100

/* nombre maximal de valeurs à trier */

main() { int t [NMAX], nval, kmax, tempo,

/* /* /* /*

tableau contenant les valeurs à trier */ nombre de valeurs à trier */ position du maximum temporaire */ valeur temporaire pour échange valeurs */

IV. Tris, fusions e t re ch e rch e e n table i, j, k ; /* lecture des valeurs à trier */ printf ("combien de valeurs à trier : ") ; scanf ("%d", &nval) ; if (nval > NMAX) nval = NMAX ; printf ("donnez vos valeurs à trier\n") ; for (k=0 ; k t[kmax]) kmax = j ; tempo = t[kmax] ; /* mise en place maxi partiel t[kmax] = t[i] ; t[i] = tempo ; for (k=0 ; k
Com m e ntaire s Ce program m e fonctionne pour toute s les valeurs de NMAX, en particulie r : - pour NM A X infé rie ur ou é galà 0, ilne fait rie n, - pour NM A X = 1, illit une valeur q u'ilaffich e te lle q ue lle.

*/ */ */ */

*/

157

158

Exe rcice s e n langage C

IV-2 Tri par pe rm utation s im pl e ________________________________________________________________________________________

Enoncé Ecrire une fonction ré alisant le tri par valeurs croissantes d'un tableau d'e ntie rs, e n utilisant l'algorith m e de tri par pe rm utation sim ple (dit de "la bulle"), q ui se définit ainsi (n re pré s e ntant le nom bre d'élém e nts du tableau) : O n parcourt l'e ns e m ble du tableau, de puis sa fin jus q u'à son début, e n com parant deux élém e nts cons é cutifs, e n les inve rsant s'ils sont m alclas s é s . O n s e re trouve ainsi ave c le plus petit é lém e nt placé e n tê te du tableau. O n re nouve lle une te lle opé ration (dite "pas s e ") ave c les n-1 é lém e nts re s tants, puis ave c les n-2 é lém e nts re s tants, e t ainsi de suite ... jus q u'à ce q ue : - soit l'avant-dernier élém e nt ait é té clas s é (le dernie r é tant alors obligatoire m e nt à sa place ), - soit q u'aucune pe rm utation n'ait e u lie u pe ndant la derniè re pas s e (ce q ui prouve alors q ue l'e ns e m ble du tableau e s t conve nablem e nt ordonné ). O n pré voira e n argum e nts : - l'adresse du tableau à trie r, - son nom bre d'élém e nts, - un indicate ur pré cisant si l'on souh aite q ue la fonction affich e les valeurs du tableau aprè s ch aq ue pe rm utation (0 pour non, 1 pour oui).

Exe m pl e combien de valeurs à trier : 6 donnez vos valeurs à trier 2 8 4 7 0 8 ---- valeurs à trier ---2 8 4 7 0 8 2 2

8 8

4 0

0 4

7 7

8 8

IV. Tris, fusions e t re ch e rch e e n table 2 0 0 0

0 2 2 2

8 8 4 4

4 4 8 7

7 7 7 8

---- valeurs triées ---0 2 4 7 8

159

8 8 8 8

8

________________________________________________________________________________________

ANALYSE L'algorith m e nous e s t indiq ué par l'é noncé . Nous utiliserons cependant une ré pé tition de type tant q u e (instruction w h ile) q ui pe rm e t de prendre conve nablem e nt e n com pte le cas où l'on appe lle la fonction de tri e n lui fournissant e n argum e nt un nom bre de valeurs infé rie ur ou é galà 1. D ans la m ise en oeuvre de ce t algorith m e , nous fe rons appe là un e ntie r i spécifiant le rang à partir duq ue lle tableau n'e s t pas e ncore trié . Initialem e nt, ilfaudra pré voir q u'aucun é lém e nt n'e s t e ncore à sa place , ce q ui conduira à l'initialisation artificie lle de i à -1 (puis q ue e n C, le pre m ie r é lém e nt d'un tableau porte le num é ro 0). D'autre part, un indicate ur logiq ue nom m é pe rm ut nous s e rvira à pré cis e r si au m oins une perm utation a e u lie u au cours de la derniè re pas s e . Si nous notons nvalle nom bre de valeurs de notre tableau, l'algorith m e de tri pe ut alors s'é nonce r com m e s uit : Tant q ue i ne désigne pas le dernie r é lém e nt du tableau (c'e s t-à -dire i < nval-1) e t q ue pe rm ut e s t VR A I, nous e ffe ctuons une passe. Cette derniè re consiste e n une s ucce s s ion de com paraisons des élém e nts de rang j e t j+1, j décrivant tous les é lém e nts depuis l'avant-dernier jus q u'à ce lui de rang i+1 (autre m e nt dit, j décroissant de nval-2 à i+1). A ch aq ue pe rm utation, nous donnons à pe rm ut la valeur VR A I ;nous aurons, bie n sûr, pris soin d'initialiser pe rm ut à FAUX au début de ch aq ue pas s e . Note z q ue l'utilisation d'une ré pé tition de type tant q u e (dans laq ue lle la condition de poursuite fait inte rve nir l'indicate ur pe rm ut) nous oblige à initialiser artificie llem e nt pe rm ut à VR A I, e n tout début de travail.

Program m e #include #define VRAI 1 #define FAUX 0 #define NMAX 100 main() {

/* pour "simuler" des ... */ /* ... valeurs logiques */ /* nombre maximal de valeurs à trier */

160

Exe rcice s e n langage C void bulle(int [], int, int ) ; int t [NMAX], nval, k ;

/* prototype fonction de tri */ /* tableau contenant les valeurs à trier */ /* nombre de valeurs à trier */

/* lecture des valeurs à trier */ printf ("combien de valeurs à trier : ") ; scanf ("%d", &nval) ; if (nval > NMAX) nval = NMAX ; printf ("donnez vos valeurs à trier\n") ; for (k=0 ; k
IV. Tris, fusions e t re ch e rch e e n table

161

{ permut = FAUX ; for (j=nval-2 ; j>i ; j--) { if ( t[j] > t[j+1] ) { permut = VRAI ; tempo = t[j] ; t[j] = t[j+1] ; t[j+1] = tempo ; if (affich) { for (k=0 ; k
Com m e ntaire s D ans la fonction bullle, la déclaration : int * t ;

e s t é q uivalente à : int t[] ;

D ISCUSSIO N Les deux algorith m e s proposés dans l'e xe rcice pré cédent e t dans ce lui-ci corre s ponde nt à ce q ue l'on appe lle des "m é th odes directe s ". D 'une m aniè re gé né rale, ce s ont des algorith m e s s im ples à program m e r, m ais q ui né ce s s ite nt un 2

nom bre de com paraisons de l'ordre de n (note z q u'ile xiste une troisiè m e m é th ode directe dite "tri par ins e rtion"). En fait, ile xiste des m é th odes dite s "é volué e s " q ui conduis e nt à un nom bre de com paraisons de l'ordre de n *log n. Ce lles -ci débouch e nt sur des program m e s plus com plexe s e t les opé rations q u'e lles font inte rve nir sont e lles -m ê m e s plus gourm ande s e n te m ps q ue ce lles des m é th odes directe s . Aussi, les m é th ode s é volué e s ne pre nne nt vé ritablem e nt d'inté rê t q ue pour de s valeurs é levé e s d e n.

162 Exe rcice s e n langage C A titre indicatif, nous vous fournissons ici l'algorith m e re latif à la m é th ode é volué e la plus perform ante , nom m é e "Tri rapide " (Quick sort), inve nté e par C. A. R . H oare . Ce t algorith m e , délicat à program m e r, e s t bas é s ur l'opé ration de "s e gm e ntation" d'un tableau ;ce lle-ci consiste à partage r un tableau e n de ux partie s , nom m é e s s e gm e nts, te lles q ue tout é lém e nt de l'une s oit infé rie ur ou é gal à tout é lém e nt de l'autre . Une te lle s e gm e ntation pe ut ê tre ré alisée par l'algorith m e s uivant : - Pre ndre un é lém e nt au h asard (on pe ut pre ndre l'é lém e nt du m ilie u). Soit m sa valeur. - R e ch e rch e r, de puis le début du tableau, le pre m ie r é lém e nt t(i) te lq ue t(i)> m . - R e ch e rch e r, de puis la fin du tableau, le pre m ie r é lém e nt t(j) te lq ue t(j)< m . - Pe rm ute r t(i) e t t(j). - Poursuivre ce "parcours" du tableau jus q u'à ce q ue i e t j s e re ncontre nt. Le tri propre m e nt dit s'e ffe ctue e n appliq uant à nouve au l'opé ration de s e gm e ntation à ch aq ue s e gm e nt obte nu, puis aux s e gm e nts obte nus par segm e ntation de ce s s e gm e nts,... e t ainsi de suite jus q u'à ce q ue ch aq ue s e gm e nt ne contie nne plus q u'un s e ulé lém e nt. Note z q u'une te lle m é th ode s e prê te particuliè re m e nt bien à une program m ation ré cursive .

IV-3 Tri d'un tabl e au de ch aî ne s ________________________________________________________________________________________

Enoncé Ecrire une fonction utilisant la m é th ode de tri par e xtraction sim ple (décrite dans l'e xe rcice IV-1) pour trie r un tableau de ch aî ne s , par ordre alph abétiq ue (sans distinction e ntre m ajuscules e t m inuscules ). Ce tte fonction re ce vra, e n argum e nt : - l'adresse d'un tableau de pointe urs sur les ch aî ne s conce rné e s , - le nom bre de ch aî ne s à trie r. Le tri propre m e nt dit porte ra, non sur les valeurs des ch aî ne s e lles -m ê m e s , m ais uniq ue m e nt sur le tableau de pointe urs. O n te s te ra ce tte fonction à l'aide d'un program m e principalcré ant un sim ple tableau de ch aî ne s (ayant donc ch acune une longue ur m axim ale donnée).

IV. Tris, fusions e t re ch e rch e e n table

163

Exe m pl e combien de chaînes à trier ? 7 donnez vos 7 chaînes (validez chacune par 'return') C Turbo C Basic Pascal Turbo Pascal Fortran ADA

voici vos chaînes triées ADA Basic C Fortran Pascal Turbo C Turbo Pascal ________________________________________________________________________________________

ANALYSE La m é th ode de tri a é té décrite dans l'e xe rcice IV-1. Il e s t ce pe ndant né ce s s aire de procéder à d'adaptations :

plusieurs sorte s

- ilfaut e n faire une fonction, - la re lation d'ordre q ui s e rt au tri ne porte plus sur de s e ntie rs, m ais sur de s ch aî nes de caractè re s ;ce la im pliq ue de re courir à la fonction stricm p (e t non strcm p, puis q ue l'on souh aite ne pas distingue r les m ajuscules des m inuscules ), - les é lém e nts à pe rm ute r s e ront des pointe urs e t non plus des entie rs.

164

Exe rcice s e n langage C

Program m e #include #include #define NCHMAX 100 /* nombre maximal de chaînes à traiter */ #define LGMAX 25 /* longueur maximale d'une chaîne (sans \0) */ main() { void trichaines (char * *, int ) ; /* prototype fonction de tri */ char chaines [NCHMAX] [LGMAX+1] ; /* tableau des chaînes */ char * adr [NCHMAX] ; /* tableau pointeurs sur les chaînes */ int nch, /* nombre de chaîne à trier */ i ; /* lecture des chaînes et préparation du tableau de pointeurs */ printf ("combien de chaînes à trier ? ") ; scanf ("%d", &nch) ; if (nch > NCHMAX) nch = NCHMAX ; getchar() ; /* pour forcer la lecture de fin de ligne */ printf ("donnez vos %d chaînes (validez chacune par 'return')\n", nch) ; for (i=0 ; i
IV. Tris, fusions e t re ch e rch e e n table

165

i, j ; for (i=0 ; i 0 ) kmax = j ; tempo = adr[kmax] ; adr[kmax] = adr[i] ; adr[i] = tempo ; } }

Com m e ntaire s *Ici, les ch aî ne s à trie r ont é té placé e s (par le program m e principal) dans un tableau de caractè re s (nom m é ch aine s ) à deux dim e nsions. Note z bie n q u'ilne s e rait pas possible d'en inve rs e r l'ordre des dim e nsions ;ile s t e n e ffe t né ce s s aire q ue tous les caractè res d'une m ê m e ch aî ne s oie nt cons é cutifs. *Bie n q ue ce la n'ait pas é té e xplicite m e nt dem andé par l'é noncé , nous avons prévu un contrôle s ur la longue ur de s ch aî ne s fournie s au clavie r ;pour ce faire , nous avons fait appe là la fonction fge ts, e n l'appliq uant au fich ie r stdin. L'instruction : fgets (chaines[i], LGMAX+1, stdin) ;

lit au m axim um LGM AX caractè re s s ur stdin e t les range à l'adre s s e ch aine [i], e n com plétant le tout par un zé ro de fin de ch aî ne . Ainsi, on é vite les ris q ues de déborde m e nt m é m oire q ue pré s e nte ge ts. Toute fois un lége r inonvé nie nt apparaî t. En e ffe t, tant q ue le nom bre de caractè re s m axim al(LGM AX) n'e s t pas atte int, le caractè re \n q ui a s e rvi à délim ite r la ch aî ne lue e s t rangé e n m é m oire , au m ê m e titre q ue les autre s . En re vanch e , lors q ue le nom bre m axim alde caractè re s a é té atte int, alors précisém e nt q ue ce caractè re \n n'a pas é té re ncontré , on ne trouve plus ce caractè re e n m é m oire (le caractè re nulde fin de ch aî ne , q uant à lui, e s t bien toujours présent). Ce t inconvé nie nt e s t surtout s e nsible lors q ue l'on affich e à nouve au les ch aî ne s par printf aprè s leur tri : les ch aî nes de longue ur m axim ale ne s e ront pas suivies d'un ch ange m e nt de ligne . Note z bie n q u'e n e m ployant puts on obtie ndrait, e n re vanch e , 1 caractè re de ch ange m e nt de ligne pour les ch aî nes de longue ur m axim ale (transm is par la fonction puts m ê m e ) e t 2 caractè res de ch ange m e nt de ligne pour les autre s ch aî ne s (ce lui figurant dans la ch aî ne e t ce lui transm is par puts). D ans un "program m e opé rationne l", ilfaudrait gé re r conve nablem e nt ce tte s ituation, ce q ue nous n'avons pas fait ici.

166 Exe rcice s e n langage C *R appe lons q ue , aprè s la lecture par scanf du nom bre de ch aî ne s à traite r, le pointe ur re s te (com m e à l'accoutum é e ) positionné s ur le dernie r caractè re non e ncore utilisé ;dans le m e illeur de s cas, ils'agit de \n (m ais ilpe ut y avoir d'autre s caractè re s avant si l'utilisate ur a é té distrait). Dans ces conditions, la lecture ulté rie ure d'une ch aî ne par ge ts conduira à lire ... une ch aî ne vide. Pour é vite r ce problèm e , nous avons placé une instruction ge tch ar q ui absorbe ce caractè re \n. En toute rigue ur, si l'on souh aitait traite r corre cte m e nt le cas où l'utilisate ur a fourni trop d'inform ation pour le scanf pré cédent, il s e rait né ce s s aire d'opérer une lecture d'une ch aî ne par ge ts (ilfaudrait pré voir un e m place m e nt à ce t e ffe t!). *D ans la fonction trich aine s , le pre m ie r argum e nt adr a é té déclaré par : char * * adr

Ils'agit d'un pointe ur sur le tableau de pointe urs sur les diffé re nte s ch aî ne s . Nous aurions pu é galem e nt le déclare r par : char * adr[]

Note z d'ailleurs q ue nous avons utilisé le "form alism e " tableau au s e in de la fonction e lle-m ê m e . Ainsi : adr[i] = adr[j]

aurait pu s e form uler : * (adr+i) = * (adr+j)

*Nous vous rappe lons q ue la fonction stricm p com pare les deux ch aî nes dont on lui fournit les adre s s e s e t e lle fournit une valeur e ntiè re définie com m e é tant : - positive s i la pre m iè re ch aî ne arrive aprè s la s e conde , au s e ns de l'ordre défini par le code des caractè re s (sans te nir com pte de la diffé re nce e ntre m ajuscules e t m inuscules pour les 26 lettres de l'alph abet), - nulle s i les deux ch aî ne s s ont é gales , - né gative s i la pre m iè re ch aî ne arrive avant la s e conde .

D ISCUSSIO N D 'une m aniè re gé né rale, iln'e s t pas néce s s aire q ue les ch aî ne s à trie r soient, com m e ici, im planté e s e n m é m oire de m aniè re cons é cutive . D e m ê m e , la fonction trich aine s propos é e pourrait tout aussi bien opérer sur des ch aî nes dont les e m place m e nts auraie nt é té alloué s "dynam iq ue m e nt" (le ch apitre V vous propose d'ailleurs un exercice dans ce sens).

IV. Tris, fusions e t re ch e rch e e n table

167

IV-4 Fus ion de de ux tabl e aux ordonné s La fusion consiste à ras s e m bler e n un s e ultableau ordonné les é lém e nts de deux tableaux, e ux-m ê m e s ordonné s . ________________________________________________________________________________________

Enoncé R é aliser une fonction q ui fusionne deux tableaux d'e ntie rs ordonné s par valeurs croissante s . O n pré voira e n argum e nts : - les adresses des trois tableaux conce rné s , - le nom bre de valeurs de ch acun des deux tableaux à fusionne r. Pour te s te r ce tte fonction, on é crira un program m e principalq ui lit au clavie r de ux e ns e m bles de valeurs q ue l'on trie ra au pré alable à l'aide de la fonction bulle ré alisée dans l'e xe rcice IV-2.

Exe m pl e combien de donnez vos 3 9 2 8 11 combien de donnez vos 12 4 6 3 1

valeurs pour le premier tableau ? 5 valeurs valeurs pour le second tableau ? valeurs 9 6

premier tableau à fusionner 2 3 8 9 11 second tableau à fusionner 1 3 4 6 6

9

7

12

résultat de la fusion des deux tableaux 1 2 3 3 4 6 6 8 9 9 11 12 ________________________________________________________________________________________

168

Exe rcice s e n langage C

ANALYSE La dém arch e , as s e z sim ple, s'inspire de ce lle q ue l'on adopte rait pour ré s oudre "à la m ain" un te lproblèm e . Ilsuffit, e n e ffe t, d'avance r e n parallèle dans ch acun des deux tableaux à fusionne r (t1 e t t2), e n pré levant, à ch aq ue fois, le plus pe tit des deux élém e nts e t e n l'introduisant dans le tableau ré s ultant t. Plus précisém e nt, nous som m e s am e né s à utiliser trois indice s : - i1 : pre m ie r é lém e nt de t1 non e ncore pris e n com pte , - i2 : pre m ie r é lém e nt de t2, non e ncore pris e n com pte , - i : e m place m e nt du proch ain é lém e nt à introduire dans t. Nous initialisons ces trois indice s à zé ro (com pte te nu de s conve ntions du C). Nous ré pé tons alors le traite m e nt suivant : Ch oisir le plus petit des élém e nts t1(i1) e t t2(i2) e t le place r e n t(i). Incré m e nte r de 1 la valeur de l'indice corre s pondant à l'é lém e nt e xtrait (i1 ou i2), ainsi que celle de i. Nous poursuivons ainsi jus q u'à ce q ue l'un des deux tableaux soit é puis é . Ilne re s te plus alors q u'à re copie r la fin de l'autre tableau.

Program m e #include #define NMAX1 100 #define NMAX2 100

/* nombre maximal de valeurs du premier tableau */ /* nombre maximal de valeurs du second tableau */

main() { void fusion(int [], int [], int [], int, int ) ; /* proto fonction de fusion */ void bulle(int [], int) ; /* proto fonction servant à assurer l'ordre des tableaux */ int t1 [NMAX1], t2 [NMAX2], t [NMAX1+NMAX2] ; int nval1, nval2, k ;

/* /* /* /* /*

premier tableau à second tablleau à tableau résultant nombre de valeurs nombre de valeurs

fusionner */ fusionner */ de la fusion */ à prélever dans t1 */ à prélever dans t2 */

/* lecture des valeurs des deux ensembles à fusionner */ printf ("combien de valeurs pour le premier tableau ? ") ; scanf ("%d", &nval1) ;

IV. Tris, fusions e t re ch e rch e e n table if (nval1 > NMAX1) nval1 = NMAX1 ; printf ("donnez vos valeurs\n") ; for (k=0 ; k NMAX2) nval2 = NMAX2 ; printf ("donnez vos valeurs\n") ; for (k=0 ; k
") ;

/* tri préalable et affichage des valeurs à fusionner */ bulle (t1, nval1) ; bulle (t2, nval2) ; printf ("\npremier tableau à fusionner\n") ; for (k=0 ; k
/********************************************************/ /* fonction de fusion de deux tableaux */ /********************************************************/ void fusion (int t[], int t1[], int t2[], int nval1, int nval2) /* t1 et t2 : tableaux à fusionner */ /* t :tableau résultant */ /* nval1 : nombre de valeurs du premier tableau t1 */ /* nval2 : nombre de valeurs du second tableau t2 */ { int i1, i2, /* indices courants dans les tableaux à fusionner */ i, /* indice courant dans le tableau résultant */ k ;

169

170

Exe rcice s e n langage C i = 0 ; i1 = 0 ; i2 = 0 ; while (i1 < nval1 && i2 < nval2) { if ( t1[i1] < t2[i2] ) t[i++] = t1[i1++] ; else t[i++] = t2[i2++] ; } if (i1 == nval1) for (k=i2 ; k
}

/*******************************************************/ /* fonction de tri d'un tableau (méthode de la bulle) */ /*******************************************************/ void bulle (int t[], int nval) { int i, j, tempo, k, permut ; i = -1 ; permut = 1 ; while (i < nval-1 && permut) { permut = 0 ; for (j=nval-2 ; j>i ; j--) if ( t[j] > t[j+1]) { permut = 1 ; tempo = t[j] ; t[j] = t[j+1] ; t[j+1] = tempo ; } i++ ; } }

Com m e ntaire s *Pour e ffe ctue r le tri pré alable des deux tableaux fournis e n donné e , nous avons re pris la fonction bulle ré alisée dans l'e xe rcice IV-2. Nous en avons toute fois supprim é les instructions perm e ttant d'affich e r, sur dem ande , les im pre s s ions inte rm édiaire s .

IV. Tris, fusions e t re ch e rch e e n table

171

IV-5 Re ch e rch e dich otom iq ue L'e xe rcice II-4 de facturation par code faisait inte rve nir un algorith m e s é q ue ntie lde re ch e rch e e n table. Nous vous proposons ici de réaliser un algorith m e plus perform ant de re ch e rch e par "dich otom ie ". ________________________________________________________________________________________

Enoncé Ecrire un program m e q ui re ch e rch e , à partir d'un code d'article (num é riq ue ), l'inform ation q ui lui e s t associé e , à savoir un libellé (ch aî ne ) e t un prix unitaire (ré e l). Com m e dans l'e xe rcice II-4, le program m e utilisera un tableau de s tructure s , déclaré à un nive au global, pour cons e rve r les inform ations re q uis e s . Ce tte fois, par contre , ces derniè re s s e ront rangé e s par ordre croissant du num é ro de code . La localisation d'un num é ro de code donné se fe ra par une re ch e rch e dich otom iq ue . Ce lle-ci consiste à profite r de l'ordre du tableau pour accé lére r la re ch e rch e e n procédant com m e s uit : - O n considè re l'é lém e nt figurant au "m ilie u" du tableau. Si le code ch e rch é lui e s t é gal, la re ch e rch e e s t te rm iné e . S'illui e s t infé rie ur, on e n conclut q ue le code re ch e rch é ne pe ut s e trouve r q ue dans la pre m iè re m oitié du tableau ; dans le cas contraire , on e n conclut q u'ils e trouve dans la s e conde m oitié . - O n re com m e nce alors l'opé ration sur la "m oitié " conce rné e , puis sur la m oitié de ce tte m oitié , e t ainsi de suite ... jus q u'à ce q ue l'une des conditions suivante s s oit satisfaite : *on a trouvé l'é lém e nt ch e rch é , *on e s t sûr q u'ilne figure pas dans le tableau.

Exe m pl es code article recherché : 24 le code 24 n'existe pas ________________ code article recherché : 19 article de code 19 libellé : Balance de ménage prix : 278.00 ________________________________________________________________________________________

172

Exe rcice s e n langage C

ANALYSE L'algorith m e propos é par l'é noncé s uggè re d'utiliser trois variables pe rm e ttant de spécifie r, à un instant donné , la partie du tableau dans laq ue lle s 'e ffe ctue la re ch e rch e : gauch e : début de la partie re s tant à e xplore r, droite : fin de la partie re s tant à e xplore r, m ilie u : position ch oisie pour le "m ilie u" de ce tte partie re s tant à e xplore r. Note z déjà q ue ce tte notion de m ilie u e s t q ue lque pe u am biguë. Nous convie ndrons q u'e lle corre s pond à la partie e ntiè re de la m oye nne des indice s gauch e e t droite . L'algorith m e de re ch e rch e par dich otom ie pe ut alors s'é nonce r ainsi (t désignant le tableau, n le nom bre de code s e t x l'é lém e nt ch e rch é ) : - Initialiser gauch e e t droite de façon q u'ils désignent l'e ns e m ble du tableau. - R é pé te r le traite m e nt suivant : *D é te rm ine r le m ilie u de la partie à e xplore r : m ilie u = (gauch e + droite ) / 2 *Com pare r l'é lém e nt ch e rch é x ave c t(m ilie u) : + S'ils sont é gaux, l'é lém e nt ch e rch é e s t localisé en position m ilie u, + Si x e s t supérieur à t(m ilie u), l'é lém e nt ch e rch é ne pe ut s e s itue r q ue dans la partie droite ;on ré alise l'affe ctation : debut = m ilie u + 1 + dans le cas contraire , l'é lém e nt ch e rch é ne pe ut s e s itue r q ue dans la partie gauch e ;on ré alise l'affe ctation : fin = m ilie u - 1 Ilnous re s te à spécifie r la condition d'arrê t (ou de poursuite ) de ce tte ré pé tition. O n pe ut déjà note r q ue , à ch aq ue parcours de la boucle, soit la valeur de gauch e augm e nte , soit ce lle de droite dim inue . Ainsi, on e s t sûr q u'au bout d'un nom bre fini de tours on aboutira à l'une des situations suivante s : - l'é lém e nt a é té localisé. - la valeur de gauch e e s t supérieure à ce lle de droite . Elles nous fournis s e nt donc tout nature llem e nt la condition de fin de notre boucle.

IV. Tris, fusions e t re ch e rch e e n table

173

Note z q ue , dans un pre m ie r te m ps, la valeur de gauch e devie nt é gale à ce lle de droite ;m ais, dans ce cas, nous ne savons pas encore si le s e ulé lém e nt re s tant à e xam ine r e s t ou non é galà x ;aussi est-ilné ce s s aire de faire un tour supplém e ntaire pour s'e n assure r.

Program m e #include /* ------ structure contenant les informations relatives aux /* différents articles -------------#define NBART 6 /* nombre total d'articles */ typedef struct { int code ; /* code article */ char * lib ; /* libellé */ float pu ; /* prix unitaire */ } t_article ;

*/ */

t_article article [NBART] = { 11, "Gaufrier", 268.0, 14, "Cafetière 12 T", 235.0, 16, "Grille-pain", 199.50, 19, "Balance de ménage", 278.0, 25, "Centrifugeuse", 370.0, 26, "Four raclette 6P", 295.25 } ; /* ----------------------------------------------------------------------*/ #define VRAI 1 #define FAUX 0 main() { int coderec, codecour, gauche, droite, milieu, trouve ;

/* pour "simuler" des ..... */ /* ..... valeurs logiques */

/* /* /* /* /* /*

code article recherché */ code courant */ limite gauche de la recherche */ limite droite de la recherche */ nouvelle limite (droite ou gauche */ indicateur code trouvé/non trouvé */

printf ("code article recherché : ") ; scanf ("%d", &coderec) ; gauche = 0 ; droite = NBART-1 ; trouve = FAUX ;

174

Exe rcice s e n langage C while (gauche <= droite && !trouve) { milieu = (gauche+droite) / 2 ; codecour = article[milieu].code ; if ( codecour == coderec ) trouve = VRAI ; else if ( codecour < coderec) gauche = milieu + 1 ; else droite = milieu - 1 ; }

if (trouve) printf ("article de code %d\nlibellé : %s\nprix : %10.2f", coderec, article[milieu].lib, article[milieu].pu) ; else printf ("le code %d n'existe pas", coderec) ; }

Com m e ntaire s *Note z bie n la condition ré gissant la boucle while : gauche <= droite && !trouve

- D 'une part, com m e nous l'avons dit dans notre analyse, nous poursuivons notre e xploration, m ê m e q uand les valeurs de gauch e e t droite sont é gales , de m aniè re à savoir si le s e ulé lém e nt re s tant à e xam ine r convie nt ou non. - D 'autre part, nous y faisons inte rve nir un indicate ur logiq ue (trouve ). Nous aurions pu nous e n pas s e r, à condition de place r un bre ak dans la boucle. Toute fois, dans ce cas, il aurait fallu pré voir, e n fin de boucle, un te s t supplém e ntaire pe rm e ttant de savoir si la re ch e rch e avait é té fructue us e ou non.

D ISCUSSIO N Ilfaut pre ndre garde , dans le déroulem e nt de l'algorith m e , à ne pas s e conte nte r de pre ndre com m e nouve lle borne de la partie de tableau à e xplore r la valeur de m ilie u, e n é crivant : debut = m ilie u ou : fin = m ilie u En e ffe t, dans ce cas, on ne pe ut plus prouve r q ue la boucle s 'ach è ve e n un nom bre fini de tours. Ce rtaine s s ituations conduis e nt d'ailleurs à une boucle infinie .

V : GESTIO N D Y NA M IQUE

Les données d'un program m e s e ré partissent e n trois caté gorie s : statiq ue s , autom atiq ue s e t dynam iq ue s . Les données statiq ue s s ont définies dè s la com pilation ;la ge s tion des données autom atiq ue s re s te transpare nte au program m e ur e t s e ules les données dynam iq ue s s ont vé ritablem e nt cré é e s (dans le tas) sur son initiative . D 'une m aniè re gé né rale, l'utilisation de données dynam iq ue s fournit des solutions à des problèm e s te ls q ue : - ge s tion de données dont l'am pleur n'e s t pas connue lors de la ré alisation du program m e , - m ise en oeuvre de structures dites dynam iq ue s , te lles q ue les liste s ch aî né e s ou les arbres binaire s . Ce ch apitre vous e n propos e q ue lque s e xe m ples .

V-1 Cribl e dynam iq ue ________________________________________________________________________________________

Enoncé R é aliser un program m e q ui dé te rm ine les pre m ie rs nom bre s pre m ie rs par la m é th ode du crible d'Eratosth è ne , e xpos é e dans l'e xe rcice I-2. Ce tte fois, par contre , le nom bre d'entie rs à considérer ne sera pas fixé par le program m e , m ais fourni e n donné e . Le program m e alloue ra dynam iq ue m e nt l'e m place m e nt m é m oire né ce s s aire au dé roulem e nt de l'algorith m e . En cas de m é m oire insuffisante , ildem ande ra à l'utilisate ur de form uler une dem ande m oins im portante . O n s'astre indra ici à utiliser la fonction m al l oc.

Exe m pl e combien d'entiers voulez-vous examiner : 200

176

Exe rcice s e n langage C

entre 1 et 200 les nombres premiers sont : 2 3 5 7 11 13 31 37 41 43 47 53 73 79 83 89 97 101 127 131 137 139 149 151 179 181 191 193 197 199

17 59 103 157

19 61 107 163

23 67 109 167

29 71 113 173

________________________________________________________________________________________

ANALYSE L'algorith m e lui-m ê m e a déjà é té e xposé dans l'e xe rcice I-2. La nouve auté ré s ide ici dans l'allocation dynam iq ue de l'e s pace im parti au tableau d'e ntie rs. Pour ce faire , la dém arch e la plus classique consiste à faire appe là la fonction m alloc, com m e nous le pré conis e l'é noncé .

Program m e #include #include #define VRAI 1 #define FAUX 0 main() { unsigned n, * raye, prem, i ; int na ;

/* pour simuler des ...*/ /* ... valeurs "logiques" */

/* nombre d'entiers à considérer */ /* pointeur sur tableau servant de crible */ /* dernier nombre premier considéré */ /* compteur de nombres premiers affichés */

/* lecture du nombre d'entiers à considérer et allocation dynamique du tableau correspondant */ do { printf ("combien d'entiers voulez-vous examiner : ") ; scanf ("%u", &n) ; raye = (unsigned *) malloc ( (n+1)*sizeof(unsigned) ) ; if (raye == NULL) printf ("** mémoire insuffisante ") ; } while (raye == NULL) ;

V.Ge s tion dynam iq u e /* initialisations du crible */ for (i=1 ; i<=n ; i++) raye[i] = FAUX ; raye[1] = VRAI ;

177

/* mise à "zéro" du crible */ /* on raye le nombre 1 */

/* passage au crible */ prem = 1 ; while (prem*prem <= n) { while (raye[++prem] && prem
Com m e ntaire s *L'allocation de l'e s pace m é m oire né ce s s aire au tableau d'e ntie rs e s t ré alisée par l'instruction : raye = (unsigned *) malloc ( (n+1)*sizeof(unsigned) ) ;

dans laq ue lle raye e s t un pointe ur sur des entie rs non signé s . O r, le prototype de m alloc e s t pré cis é m e nt : void * malloc (size_t) ;

Le ré s ultat fourni par m alloc e s t un "pointe ur gé né riq ue " q ui pe ut ê tre conve rti im plicite m e nt e n un pointe ur de n'im porte q ue ltype . Aussi, l'opé rate ur de "cast" (unsigne d *) n'e s t pas indispensable ici. Notre instruction d'allocation m é m oire aurait pu s'é crire : raye = malloc ( (n+1) * sizeof(unsigned) ) ;

178

Exe rcice s e n langage C

En ce q ui conce rne l'argum e nt de m alloc, ce lui-ci e s t a priori d'un type size _t défini (par type de f) dans stdlib.h . Le type e xact corre s pondant dépend de l'im plém e ntation (m ais ile s t toujours non signé - e n gé né ral, ils'agit de unsigne d int). Note z q ue le ré s ultat fourni par size of e s t du m ê m e type size _t. R appe lons q ue m alloc fournit e n ré s ultat un pointe ur sur le début de la zone conce rné e lors q ue l'allocation a ré ussi et un pointe ur nuldans le cas contraire (note z q ue le sym bole NULLe s t défini dans stdlib.h ). *En ce q ui conce rne l'algorith m e de passage au crible, vous re m arq ue z q ue nous avons e m ployé e xacte m e nt les m ê m e s instructions q ue dans le program m e de l'e xe rcice I-2. Pourtant, dans ce dernie r, le sym bole raye désignait un tableau d'entie rs, tandis q u'ici ildésigne un pointe ur sur des entie rs. Ce la e s t possible parce q u'e n langage C, un nom de tableau e s t un pointe ur (constant).

D ISCUSSIO N *Le ch oix du type unsigne d pour n e s t q ue lque pe u arbitraire ;ile s t guidé par le fait q ue m alloc adm e t gé né ralem e nt un argum e nt de ce type . En supposant q ue te le s t le cas, on constate q u'alors l'e xpre s s ion : (n+1) * sizeof (unsigned)

conduit à des valeurs e rronées dè s q ue la valeur de n*size of(int) dépas s e la capacité du type int (n'oublie z pas q u'iln'y a pas de déte ction de dépas s e m e nt de capacité pour les opé rations portant sur des entie rs). Le ré s ultat pe ut alors ê tre catastroph iq ue car le nom bre d'octe ts dem andé s à m alloc s e trouve ê tre infé rie ur à ce lui ré e llem e nt utilisé. Le problèm e s e com pliq ue e ncore un pe u si l'on tie nt com pte de ce q ue , dans ce rtaine s im plém e ntations, le type size _t pe u corre s pondre à autre ch os e q ue unsigne d int. En toute rigue ur, ilfaudrait donc s'assure r q ue le nom bre de valeurs dem andé e s par l'utilisate ur e s t e ffe ctive m e nt infé rie ur à une ce rtaine lim ite à fixe r e n fonction de l'im plém e ntation conce rné e .

V-2 Cré ation dynam iq ue de ch aî ne s Lors q u'un program m e doit traite r un grand nom bre de ch aî nes de longue ur variable e t q ue ce nom bre n'e s t pas connu a priori, ilpe ut s'avé re r inté re s s ant de faire alloue r dynam iq ue m e nt (par le program m e ) l'e s pace m é m oire né ce s s aire au stock age des ch aî ne s . C'e s t ce q ue vous propose cet e xe rcice q ui pe ut ê tre considéré com m e pré alable à un traite m e nt ulté rie ur de ce s ch aî ne s (par e xe m ple un tri com m e vous le propos e ra l'e xe rcice V-3).

V.Ge s tion dynam iq u e

179

________________________________________________________________________________________

Enoncé Ecrire un program m e q ui lit un nom bre q ue lconq ue de ch aî ne s au clavie r e t q ui les range e n m é m oire dans des e m place m e nts alloués dynam iq ue m e nt au fur e t à m e s ure des besoins. Le s adresses de ch acune des ch aî ne s s e ront cons e rvées dans un tableau de pointe urs. Ce dernie r s e ra ré s e rvé dans le program m e (e n clas s e autom atiq ue ) e t sa taille (fixe ) im pos e ra donc une valeur m axim ale au nom bre de ch aî ne s q u'ils e ra ainsi possible de traite r. L'utilisate ur signalera q u'ila fourni sa derniè re ch aî ne e n la faisant suivre d'une ch aî ne "vide". Le program m e affich e ra e nsuite les ch aî ne s lue s , à titre de sim ple contrôle. R e m arque : on utilisera la fonction m alloc e t on supposera q ue les ligne s lue s au clavie r ne pe uve nt jam ais dépas s e r 127 caractè re s .

Exe m pl e ----- chaîne C ----- chaîne Turbo C ----- chaîne Basic ----- chaîne Pascal ----- chaîne Turbo Pascal ----- chaîne

numéro 1 (return pour finir) numéro 2 (return pour finir) numéro 3 (return pour finir) numéro 4 (return pour finir) numéro 5 (return pour finir) numéro 6 (return pour finir)

fin création

liste des chaînes créées ------- chaîne numéro 1 C ------- chaîne numéro 2 Turbo C ------- chaîne numéro 3

180

Exe rcice s e n langage C

Basic ------- chaîne numéro 4 Pascal ------- chaîne numéro 5 Turbo Pascal ________________________________________________________________________________________

ANALYSE L'é noncé nous im pose donc de définir, au s e in du program m e , un tableau de pointe urs destiné à conte nir les adresses des ch aî ne s à cré e r. Ch aq ue ch aî ne s e ra d'abord lue dans une zone inte rm édiaire (non dynam iq ue ). O n lui alloue ra e nsuite , dynam iq ue m e nt, à l'aide de la fonction m alloc, un e m place m e nt dont la taille corre s pond e xacte m e nt à sa longue ur ;l'adre s s e ainsi obte nue s e ra m é m orisée dans le tableau de pointe urs. Le traite m e nt s e ra inte rrom pu : - soit q uand le tableau de pointe urs e s t plein, - soit q uand l'utilisate ur fournit une ch aî ne vide. D e plus, à ch aq ue allocation ré alisée par m alloc, on s'assure ra q ue l'e s pace m é m oire né ce s s aire a pu ê tre obte nu. D ans le cas contraire , on pré voira d'inte rrom pre le program m e .

Program m e #include #include #include #define NCHMAX 1000 #define LGLIGNE 127 main() { char ligne [LGLIGNE+1], * adr [NCHMAX], * ptr ; int nch, i ;

/* pour la fonction exit */ /* nombre maximal de chaînes */ /* longueur maximale d'une ligne d'écran */

/* /* /* /*

chaîne servant à lire une ligne écran */ tableau de pointeurs sur les chaînes */ pointeur courant sur une chaîne */ compteur du nombre de chaînes */

/* mise à zéro du tableau de pointeurs */

V.Ge s tion dynam iq u e

181

for (i=0 ; i
Com m e ntaire s *Ici, com pte te nu de ce q ue nous précisait l'é noncé , nous avons ch oisi de lire nos ch aî nes dans un tableau de 128 caractè re s , à l'aide de la fonction ge ts. *Nous avons re m is à "zé ro" le tableau de pointe urs sur nos ch aî ne s . Ils'agit là d'une opé ration superflue m ais q ui pe ut s'avé re r utile pe ndant la ph ase de m ise au point du program m e . Note z l'usage du sym bole NULL;prédéfini dans le fich ie r stdlib.h , ilcorre s pond à la constante pointe ur nulle. *La cré ation de s ch aî ne s e s t ré alisée par une boucle tant q u e (instruction w h ile), dans laq ue lle nous avons prévu de ux autre s s ortie s :

182 Exe rcice s e n langage C - une s ortie par bre ak , dans le cas où l'utilisate ur a fourni une ch aî ne vide, - un arrê t e xce ptionne ldu program m e par e xit, dans le cas où l'allocation dynam iq ue a é ch oué . Ce tte fonction (dont le prototype figure dans stdlib.h ) re q uie rt un argum e nt ;sa valeur e s t transm ise au systè m e e t e lle pourrait é ve ntue llem e nt ê tre ré cupé ré e par d'autre s program m e s . Note z q ue , e n l'abs e nce de l'instruction #include re lative à stdlib.h , le com pilate ur acce pte un appe lde e xit sans argum e nt (ile s t incapable de déte cte r l'e rre ur - laq ue lle n'a d'ailleurs aucune incide nce s ur l'e xé cution du program m e lui-m ê m e ). Nature llem e nt, beaucoup d'autre s form ulations s e raie nt possibles .

D ISCUSSIO N *Le fait de ré s e rve r le tableau dans le program m e (e n clas s e autom atiq ue ) im pos e une lim ite au nom bre de ch aî ne s q u'il e s t ainsi possible de traite r ;ce tte lim ite e s t indé pe ndante de la m é m oire ré e llem e nt disponible. O n pe ut am é liore r q ue lque pe u la situation e n faisant é galem e nt al l ouer dynam iquem ent l 'espace nécessaire à ce tabl eau de pointeurs. Il faut toute fois e n connaî tre la taille (ou du m oins une valeur m axim ale) lors de l'e xé cution du program m e . Ce la pe ut faire l'obje t d'une donnée fournie par l'utilisate ur com m e dans l'e xe rcice s uivant.

V-3 Tri dynam iq ue de ch aî ne s ________________________________________________________________________________________

Enoncé Ecrire un program m e pe rm e ttant de trie r par ordre alph abétiq ue des pré cédent, on alloue ra dynam iq ue m e nt des em place m e nts m é m oire leurs adre s s e s s e ront cons e rvées dans un tableau de pointe urs. e m place m e nt alloué dynam iq ue m e nt e n début de program m e ;pour valeur m axim ale du nom bre de ch aî ne s q u'ils e ra am e né à fournir.

ch aî ne s fournie s e n donné e . Com m e dans l'e xe rcice aux ch aî ne s , au fur e t à m e s ure de leur lecture , e t Par contre , ici, ce dernie r ve rra, lui aussi, son ce faire , on de m ande ra à l'utilisate ur de fournir une

O n utilisera l'algorith m e de "tri par e xtraction sim ple" e xposé dans l'e xe rcice V-1 e t on fe ra appe là la fonction m alloc.

Exe m pl e

V.Ge s tion dynam iq u e nombre maximal ------- chaîne C ------- chaîne Turbo C ------- chaîne Basic ------- chaîne Pascal ------- chaîne Turbo Pascal ------- chaîne Fortran ------- chaîne ADA ------- chaîne

183

de chaînes ? 100 numéro 1 (return pour finir) numéro 2 (return pour finir) numéro 3 (return pour finir) numéro 4 (return pour finir) numéro 5 (return pour finir) numéro 6 (return pour finir) numéro 7 (return pour finir) numéro 8 (return pour finir)

fin création

liste triée des chaînes crées ADA Basic C Fortran Pascal Turbo C Turbo Pascal ________________________________________________________________________________________

ANALYSE Ilnous suffit e n fait d'adapte r le program m e de l'e xe rcice pré cédent, e n lui adjoignant : - la ré s e rvation dynam iq ue du tableau de pointe urs, - le tri du tableau de ch aî ne s ainsi cré é , par ré organisation de s pointe urs. Nous utiliserons pour cela l'algorith m e de tri par e xtraction sim ple Ce lui-ci a é té e xposé dans l'é noncé de l'e xe rcice V-1 e t son adaptation au tri de ch aî ne s a é té e xpliq uée dans l'analyse de l'e xe rcice V-2.

184

Exe rcice s e n langage C

Program m e #include #include #include #define LGLIGNE 127 main() { char ligne [LGLIGNE+1], * * adr, * ptr, * tempo ; unsigned nchmax, nch, i, j, kmax ;

/* longueur maximale d'une ligne d'écran */

/* /* /* /* /* /*

chaîne servant à lire une ligne écran */ adresse tableau pointeurs sur les chaînes */ pointeur courant sur une chaîne */ pointeur temporaire pour éch. 2 pointeurs */ nombre maximal de chaînes */ compteur du nombre de chaînes */

/* création et mise à zéro du tableau de pointeurs */ printf ("nombre maximum de chaînes ? ") ; scanf ("%d", &nchmax) ; getchar() ; /* pour sauter la validation */ if ( (adr = malloc (nchmax*sizeof(char*)) ) == NULL) { printf ("\n\n*** erreur allocation dynamique") ; exit(-1) ; /* arrêt si erreur alloc dynam */ } for (i=0 ; i
*/ ;

*/

*/

V.Ge s tion dynam iq u e

185

printf ("\nfin création\n") ; /* tri des chaînes par réarrangement des pointeurs */ for (i=0 ; i 0 ) kmax = j ; tempo = adr[kmax] ; adr[kmax] = adr[i] ; adr[i] = tempo ; } /* liste triées des chaînes ainsi créées */ printf ("\n\nliste triée des chaînes crées\n\n") ; for (i=0 ; i
Com m e ntaire s *D ans le program m e de l'e xe rcice V-2, le sym bole adr désignait un tableau de pointe urs. Ici, ce m ê m e sym bole désigne un pointe ur sur un tableau de pointe urs. O r, m algré ce tte diffé re nce appare nte , vous constate z q ue nous e m ployons toujours la notation : adr[i] ave c la m ê m e signification dans les deux cas. En fait, dans le pré cédent program m e , adr é tait une constante pointeur dont la valeur é tait ce lle de l'adresse de début du tableau de pointe urs. Dans le pré s e nt program m e , adr e s t une variabl e pointeur dont la valeur e s t é galem e nt ce lle de début du tableau de pointe urs. Ainsi, dans les deux cas : adr[i] e s t é q uivalent à : *(adr + i) Note z ce pe ndant q ue l'é q uivalence e ntre les deux program m e s n'e s t pas totale. En e ffe t, dans le pre m ie r cas, adr n'e s t pas une lvalue (m ot anglais dont une traduction approch é e pourrait ê tre : valeur à gauch e ) ;par e xe m ple, l'e xpre s s ion adr++ s e rait incorre cte . Dans le s e cond cas, par contre , adr e s t bien une lvalue .

186 Exe rcice s e n langage C *Nous n'avons pris aucune pré caution particuliè re e n ce q ui conce rne les lecture s au clavie r q ui sont ré alisées ici par ge ts e t scanf. Indé pe ndam m e nt des anom alie s h abitue lles e ncourue s e n cas de données incorrecte s (ch aî ne trop longue pour ge ts, donné e non num é riq ue pour scanf), un problèm e s upplém e ntaire apparaî t, lié au fait q u'aprè s une lecture par scanf, le pointe ur re s te positionné s ur le dernie r caractè re non e ncore utilisé, à savoir ici le \n (du m oins si l'utilisate ur a validé norm alem e nt, sans fournir d'inform ations supplém e ntaire s ). Si la lecture s uivante e s t, à son tour, e ffe ctué e par scanf, aucun problèm e particulie r ne s e pos e , le caractè re \n é tant sim plem e nt ignoré . Iln'e n va plus de m ê m e lors q ue la lecture s uivante e s t e ffe ctué e par ge ts ;dans ce cas, e n e ffe t, ce caractè re e s t inte rpré té com m e un caractè re de "fin" e t ge ts fournit... une ch aî ne vide. C'est pour é vite r ce ph é nom è ne q ue nous avons dû introduire une instruction ge tch ar pour absorber le \n.

D ISCUSSIO N Pour pouvoir alloue r conve nablem e nt l'e m place m e nt du tableau de pointe urs, notre program m e a besoin q ue l'utilisate ur lui fournis s e une valeur m axim ale du nom bre de ch aî ne s . Si nous souh aitions q u'ile n soit autre m e nt, ils e rait né ce s s aire de pouvoir alloue r provisoire m e nt un e m place m e nt à ce tableau, q uitte à l'é te ndre e nsuite au fur e t à m e s ure des besoins à l'aide de la fonction re alloc. Une te lle e xte nsion pourrait ê tre ré alisée, soit à ch aq ue nouve lle ch aî ne e ntré e , soit par blocs de taille fixe (par e xe m ple toute s les 100 ch aî ne s ).

V-4 Cré ation d'une l is te ch aî né e O n appe lle liste ch aî né e ou liste lié e une s uite ordonnée d'é lém e nts dans laq ue lle ch aq ue é lém e nt, sauf le dernie r, com porte un pointe ur sur l'é lém e nt suivant.

________________________________________________________________________________________

Enoncé Ecrire un program m e q ui cré e une liste ch aî née d'é lém e nts com portant ch acun : - un nom (ch aî ne ) d'au m axim um 10 caractè re s , - un â ge . Le s inform ations corre s pondante s s e ront lue s au clavie r e t l'utilisate ur frappe ra un nom "vide" aprè s les données relative s au de rnie r é lém e nt.

V.Ge s tion dynam iq u e

187

Le program m e affich e ra e nsuite les inform ations conte nues dans la liste ainsi cré é e , dans l'ordre inve rse de ce lui dans leq ue le lles auront é té fournie s . O n pré voira de ux fonctions : l'une pour la cré ation, l'autre pour la liste . Elles posséderont com m e uniq ue argum e nt l'adresse de début de la liste (pointe ur sur le pre m ie r é lém e nt).

Exe m pl e om : Laurence age : 19 nom : Yvette age : 35 nom : Catherine age : 20 nom : Sebastien age : 21 nom :

NOM Sebastien Catherine Yvette Laurence

AGE 21 20 35 19

________________________________________________________________________________________

ANALYSE Ch aq ue é lém e nt de notre liste s e ra re pré s e nté par une s tructure . Nous voyons q ue ce lle-ci doit conte nir un pointe ur sur un é lém e nt de m ê m e type . Ce la fait inte rve nir une ce rtaine "ré cursivité " dans la déclaration corre s pondante , ce q ui e s t acce pté e n C. En ce q ui conce rne l'algorith m e de cré ation de la liste , deux possibilité s s 'offre nt à nous : - Ajoute r ch aq ue nouve lé lém e nt à la fin de la liste . Le parcours ulté rie ur de la liste s e fe ra alors dans le m ê m e ordre q ue ce lui dans leq ue lles données corre s pondante s ont é té introduite s . - Ajoute r ch aq ue nouve lé lém e nt e n début de liste . Le parcours ulté rie ur de la liste s e fe ra alors dans l'ordre inve rs e de ce lui dans leq ue lles données corre s pondante s ont é té introduite s .

188 Exe rcice s e n langage C Com pte te nu de ce q ue l'é noncé nous dem ande d'affich e r la liste à l'e nve rs, aprè s sa cré ation, ilparaî t plus apportun de ch oisir la s e conde m é th ode . Com m e dem andé , la cré ation de la liste s e ra ré alisée par une fonction. Le program m e principals e conte nte ra de ré s e rve r un pointe ur (nom m é de but) destiné à désigner le pre m ie r é lém e nt de la liste . Sa valeur e ffe ctive s e ra fournie par la fonction de cré ation. L'algorith m e de cré ation, q uant à lui, consiste ra à ré pé te r le traite m e nt d'insertion d'un nouve lé lém e nt e n début de liste , à savoir : - cré e r dynam iq ue m e nt un e m place m e nt pour un nouve lé lém e nt e t y range r les inform ations fournie s au clavie r, - affe cte r au pointe ur conte nu dans ce nouve lé lém e nt l'ancie nne valeur de de but, - affe cte r à de but l'adresse de ce nouve lé lém e nt. Nous convie ndrons, de plus, q ue le dernie r é lém e nt de la liste possè de un pointe ur nul, ce q ui nous facilite ra l'initialisation de l'algorith m e ;e n e ffe t, ce lle-ci s e ram è ne alors à l'affe ctation à de but d'une valeur nulle.

Program m e #include #include #include #define LGNOM 20

/* longueur maximale d'un nom */

typedef struct element /* définition du type élément */ { char nom [LGNOM+1] ; /* nom */ int age ; /* age */ struct element * suivant ; /* pointeur element suivant */ } t_element ;

main() { void creation (t_element * *) ; void liste (t_element *) ; t_element * debut ; creation (&debut) ; liste (debut) ; }

/* fonction de création de la liste */ /* fonction de liste de la liste */ /* pointeur sur le début de la liste */

V.Ge s tion dynam iq u e

/****************************************************/ /* fonction de création d'une liste chaînée */ /****************************************************/ void creation (t_element * * adeb) { char nomlu [LGNOM+1] ; /* pour lire un nom au clavier */ t_element * courant ; /* pour l'échange de valeurs de pointeurs */ * adeb = NULL ;

/* liste vide au départ */

while (1) /* boucle de création apparemment infinie ... */ { /* ... mais, en fait, interrompue sur "nom vide" */ printf ("nom : ") ; gets (nomlu) ; if (strlen(nomlu)) { courant = (t_element *) malloc (sizeof(t_element)) ; strcpy (courant->nom, nomlu) ; printf ("age : ") ; scanf ("%d", &courant->age) ; getchar() ; /* pour sauter le \n */ courant->suivant = * adeb ; * adeb = courant ; } else break ; /* sortie boucle si nom vide */ } }

/******************************************************/ /* fonction de liste d'une liste chaînée */ /******************************************************/ void liste (t_element * debut) { printf ("\n\n NOM AGE\n\n") ; while (debut) { printf ("%15s %3d\n", debut->nom, debut->age) ; debut = debut->suivant ; } }

189

19 0

Exe rcice s e n langage C

Com m e ntaire s *Nous avons ici ch oisi de déclare r notre s tructure à un nive au globale t de faire appe là type de f. Ce tte déclaration à un nive au globalé vite de devoir dé crire la m ê m e s tructure e n diffé re nts e ndroits, ce q ui s e rait, non s e ulem e nt laborie ux m ais, de surcroî t, source d'erreurs. Par contre , le re cours à type de f n'apporte q u'une s im plification des déclarations des é lém e nts de ce type (dans le cas contraire , ilsuffirait de re m place r t_e le m e nt par struct e le m e nt). Note z bie n, par contre , q u'iln'e s t pas possible de re m place r, au s e in de la définition de notre s tructure , l'é criture : struct element * suivant

par : t_element * suivant

*La fonction de cré ation re çoit e n argum e nt l 'adresse du pointe ur de but, car e lle doit pouvoir lui attribue r une valeur. La fonction de liste , q uant à e lle, s e conte nte de la val eur de ce m ê m e pointe ur. Ce tte diffé re nce s e ré pe rcute nature llem e nt sur la m aniè re d'utiliser cet argum e nt dans ch acune des deux fonctions. Note z d'ailleurs q ue nous avons pu nous pe rm e ttre , dans la fonction de liste , de m odifie r la valeur ainsi reçue (le pointe ur de but y décrit succe s s ive m e nt les diffé re nts é lém e nts de la liste ). *Là e ncore , les lecture s au clavie r ont é té ré alisées par scanf e t ge ts, donc sans prote ctions particuliè re s . Com m e nous l'avons déjà signalé dans le pré cédent e xe rcice , l'utilisation conjointe de ces deux fonctions pose un problèm e lié au fait q ue , aprè s une lecture par scanf, le pointe ur re s te positionné s ur le dernie r caractè re non e ncore utilisé, à savoir (gé né ralem e nt) \n. C'e s t ce q ui justifie l'introduction d'une instruction ge tch ar pour absorber ce caractè re inte m pe s tif.

VI : RECURSIVITE

La ré cursivité e s t une notion dé licate m ais q ui a l'avantage de conduire s ouve nt à des program m e s s im ples . Le s trois prem ie rs e xe rcices de ce ch apitre s ont plutôt des "e xe rcices d'école" destiné s à vous faire e xplore r diffé re nte s situations e n vous forçant à é crire une fonction ré cursive , là où, e n pratiq ue , on ne s e rait pas am e né à le faire .

VI-1 l e cture ré curs ive (1) ________________________________________________________________________________________

Enoncé Ecrire une fonction ré cursive de lecture d'une valeur e ntiè re au clavie r. La fonction de vra s'appe ler e lle-m ê m e dans le cas où l'inform ation fournie e s t incorre cte (non num é riq ue ). O n pré voira une fonction à un argum ent (l'adresse de la variable pour laq ue lle on ve ut lire une valeur) e t sans val eur de retour. O n pourra faire appe là fge ts e t sscanf pour dé te cte r conve nablem e nt les ré pons e s incorre cte s .

Re m arq ue Nous vous cons e illons de com pare r ce t e xe rcice au suivant dans leq ue lle m ê m e problèm e e s t ré s olu par l'e m ploi d'une fonction ré cursive s ans argum e nt e t ave c valeur de re tour.

Exe m pl e

19 2

Exe rcice s e n langage C

donnez un nombre entier : un ** réponse incorrecte - redonnez-la : 'à ** réponse incorrecte - redonnez-la : 40 -- merci pour 40 ________________________________________________________________________________________

ANALYSE Au sein de la fonction (q ue nous nom m e rons lecture ), nous lirons la valeur atte ndue à l'aide de fge ts (..., stdin), associé à sscanf, com m e nous l'avons déjà fait dans ce rtains des exe rcice s pré cédents. Nous considé re rons la ré ponse de l'utilisate ur com m e corre cte lors q ue le code de re tour de sscanf s e ra é galà 1. Si te l n'e s t pas le cas, nous fe rons à nouve au appe là la m ê m e fonction lecture .

Program m e #include #define LG_LIG 20 main() { void lecture (int *) ; int n ;

/* longueur maxi information lue au clavier */

/* prototype fonction (récursive) de lecture */ /* entier à lire */

printf ("donnez un nombre entier : ") ; lecture (&n) ; printf ("-- merci pour %d", n) ; } void lecture (int *p) { int compte ; char ligne[LG_LIG+1] ;

/* compteur du nb de valeurs OK */ /* pour lire une ligne au clavier par fgets */ /* +1 pour tenir compte du \0 de fin */

fgets (ligne, LG_LIG, stdin) ; compte = sscanf (ligne, "%d", p) ; if (!compte) { printf ("** réponse incorrecte - redonnez la : ") ; lecture (p) ;

VI. R é cursivité

19 3

} }

Com m e ntaire s *Note z bie n q u'au s e in de la fonction lecture , au nive au de l'appe lde sscanf, nous voyons apparaî tre p e t non & p, puis q ue ici p e s t déjà un pointe ur sur la variable dont on ve ut lire la valeur. *Si nous avions utilisé sim plem e nt ge ts (com m e dans l'e xe rcice VI.5 de la pre m iè re partie ) au lie u de fge ts (..., stdin), nous aurions pu égalem e nt nous proté ge r de m auvais e s ré ponses de l'utilisate ur, m ais nous aurions dû définir une taille m axim ale pour la ch aî ne lue au clavie r ;nous aurions couru le ris q ue de "débordem e nt m é m oire ", dans le cas où l'utilisate ur aurait fourni une ré pons e trop longue .

D ISCUSSIO N Ch aq ue nouve lappe lde lecture e ntraî ne l'allocation autom atiq ue , sur la pile, d'e m place m e nts pour : - l'argum e nt p, - les obje ts locaux : com pte e t ligne . O r, e n fait, ne s ont né ce s s aire s q ue les valeurs corre s pondant au de rnie r appe lde lecture (ce lui où la lecture s 'e s t conve nablem e nt déroulée ) ;dans ce s conditions, l'e m pilem e nt des diffé re nts e m place m e nts alloué s au tableau ligne e s t superflu. Si l'on souh aite faire q ue lque s é conom ies d'espace m é m oire à ce nive au, on pe ut s'arrange r pour q ue ce t e m place m e nt ne s oit ré s e rvé q u'une s e ule fois : - soit dans le program m e appe lant (ici le program m e principal) ;dans ce cas, ilfaudra e n transm e ttre l'adre s s e e n argum e nt, ce q ui e ntraî ne l'e m pilem e nt d'une variable s upplém e ntaire . - soit e n clas s e globale ;dans ce cas, on pe ut é galem e nt traite r de la sorte com pte e t p (c'e s t-à -dire , e n fait, n), ce q ui supprim e du m ê m e coup tous les argum e nts e t les obje ts locaux de lecture . Note z q u'ilre s te ra q uand m ê m e , à ch aq ue appe l, une allocation autom atiq ue d'espace pour l'adre s s e d e re tour. - soit e n clas s e s tatiq ue (static) au s e in de la fonction. Là e ncore , nous pouvons traite r de la m ê m e m aniè re la variable com pte , la variable p, q uant à e lle, re s tant soum ise aux e m pilem e nts.

19 4

Exe rcice s e n langage C

VI-2 Le cture ré curs ive (2) ________________________________________________________________________________________

Enoncé Ecrire une fonction ré cursive de lecture d'une valeur e ntiè re au clavie r. La fonction de vra s'appe ler e lle-m ê m e dans le cas où l'inform ation fournie e s t incorre cte (non num é riq ue ). O n pré voira ce tte fois une fonction dans laq ue lle la valeur de re tour e s t la valeur lue (iln'y aura donc pas d'argum e nts). Là e ncore , on pourra faire appe là fge ts (..., stdin) e t sscanf pour dé te cte r conve nablem e nt les ré pons e s incorre cte s .

Re m arq ue Ce t e xe rcice e s t surtout destiné à ê tre com paré au pré cédent dans leq ue lle m ê m e problèm e e s t ré s olu par l'e m ploi d'une fonction ave c argum e nt e t sans valeur de re tour.

Exe m pl e donnez un nombre entier : un ** réponse incorrecte - redonnez la : 'à ** réponse incorrecte - redonnez la : 40 -- merci pour 40 ________________________________________________________________________________________

ANALYSE Com m e pré cédem m e nt, au s e in de notre fonction (nom m é e lecture ), nous lirons la valeur atte ndue à l'aide de fge ts associé à sscanf. Nous considé re rons la ré ponse de l'utilisate ur com m e corre cte lors q ue le code de re tour de sscanf s e ra é galà 1. Si ce la n'e s t pas le cas, nous fe rons de nouve au appe là la m ê m e fonction lecture .

VI. R é cursivité

19 5

Program m e

#include #define LG_LIG 20 main() { int lecture (void) ; int n ;

/* longueur maxi information lue au clavier */

/* fonction (récursive) de lecture */ /* entier à lire */

printf ("donnez un nombre entier : ") ; n = lecture() ; printf ("-- merci pour %d", n) ; } int lecture (void) { int compte, p ; char ligne[LG_LIG+1] ;

/* compteur du nb de valeurs OK */ /* entier à lire */ /* pour lire une ligne au clavier par fgets */

fgets (ligne, LG_LIG, stdin) ; compte = sscanf (ligne, "%d", &p) ; if (!compte) { printf ("** réponse incorrecte - redonnez-la : ") ; p = lecture() ; } return(p) ; }

Com m e ntaire s *Ce tte fois, on note ra q ue p dé s igne une variable locale de type int, dont l'e m place m e nt e s t alloué autom atiq ue m e nt à ch aq ue appe lde la fonction lecture , de la m ê m e m aniè re q ue pour les autre s obje ts locaux com pte e t ligne . Par ailleurs, si aucun e m place m e nt n'e s t alloué ici pour un q ue lconq ue argum e nt, ilfaut e n pré voir un pour la valeur de re tour. O n re m arq ue d'ailleurs q u'ici ce tte valeur s e trouve "propagé e " de proch e e n proch e , lors du "dépilem e nt" des appe ls. *Pre ne z garde à ne pas é crire :

19 6

Exe rcice s e n langage C if (!compte) { printf ("** réponse incorrecte - redonnez-la : ") ; p = lecture() ; } else return (p) ;

car la fonction ne re nve rrait une valeur q ue lors q ue la lecture s e s e rait déroulée conve nablem e nt. Note z d'ailleurs q ue dans ce cas, bon nom bre de com pilate urs vous prévie ndrait par un m e s s age d'ave rtissem e nt ("w arning"). Par contre , ils e rait tout à fait corre ct (e t é q uivalent) d'écrire : if (!compte) { printf ("** réponse incorrecte - redonnez la : ") ; return (lecture()) ; } else return (p) ;

D ISCUSSIO N Le s re m arq ue s faites dans le pré cédent e xe rcice à s'appliq ue nt e ncore ici.

propos des em pilem e nts de ligne (e t é ve ntue llem e nt com pte )

VI-3 Le cture ré curs ive (3) ________________________________________________________________________________________

Enoncé Ecrire une fonction ré cursive de lecture d'un entie r au clavie r. La fonction de vra s'appe ler e lle-m ê m e dans le cas où l'inform ation fournie e s t incorre cte . Ce tte fois, la fonction possédera 3 argum e nts : - le m e s s age q u'e lle doit im prim e r avant de lire une valeur (le m e s s age "donne z un nom bre e ntie r :" ne s e ra donc plus affich é par le program m e principal), - l'adresse de la variable dans laq ue lle on doit lire une valeur, - le nom bre m axim ald'essais autoris é s .

VI. R é cursivité

19 7

Elle fournira un code de re tour é galà 0 si la lecture a fini par aboutir e t à -1 lors q ue la lecture n'a pas pu aboutir dans le nom bre d'essais im partis. Com m e dans les deux pré cédents e xe rcice s , on fe ra appe là fge ts associé e à sscanf.

Exe m pl es donnez un nombre entier : huit ** réponse incorrecte - redonnez-la : 8 -- merci pour 8 ____________________ donnez un nombre entier : un ** réponse incorrecte - redonnez-la ** réponse incorrecte - redonnez-la ** réponse incorrecte - redonnez-la ** réponse incorrecte - redonnez-la -- nombre d'essais dépassé

: : : :

deux trois quatre cinq

________________________________________________________________________________________

ANALYSE Le m e s s age à im prim e r s e ra transm is sous form e de l'adresse d'une ch aî ne . La fonction affich e ra ce m e s s age dè s son appe l. Son conte nu de vra donc ê tre : donne z un nom bre e ntie r : dans l'appe linitialde la fonction (ré alisé dans le program m e principal), e t : **ré pons e incorre cte - re donne z -a : dans l'appe lde la fonction par e lle-m ê m e e n cas de ré pons e incorre cte . En ce q ui conce rne le nom bre m axim ald'appe ls, on le transm e ttra par valeur e t on s'arrange ra pour faire décroî tre s a valeur de 1 à ch aq ue appe l. La ré cursivité des appe ls ce s s e ra lors q ue l'une des deux conditions suivante s s e ra satisfaite : - valeur lue corre cte - on fournira alors 0 com m e valeur de re tour,

19 8 Exe rcice s e n langage C - nom bre m axim ald'appe ls dépas s é - on fournira alors -1 com m e valeur de re tour.

Program m e #include #define LG_LIG 20 /* longueur maxi information lue au clavier */ main() { int lecture (char *, int *, int) ; /* proto fonction (récursive) de lecture */ int n ; /* entier à lire */ const nessais = 5 ; /* nombre d'essais autorisés */ if ( lecture ("donnez un nombre entier : ", &n, nessais) != -1) printf ("-- merci pour %d", n) ; else printf ("-- nombre d'essais dépassés") ; } int lecture (char * mes, int * p, int nmax) /* mes : adresse message à afficher avant lecture */ /* p : adresse de la valeur à lire */ /* nmax : nombre d'essais autorisés */ { int compte ; /* compteur du nb de valeurs OK */ char ligne [LG_LIG] ; /* pour lire une ligne au clavier par fgets */ printf ("%s", mes) ; fgets (ligne, LG_LIG, stdin) ; compte = sscanf (ligne, "%d", p) ; if (!compte) if (--nmax) return (lecture ("** réponse incorrecte - redonnez la : ", p, nmax) ) ; else return (-1) ; else return (0) ; }

Com m e ntaire s *Nous avons ch oisi ici de faire affich e r le m e s s age : nom bre d'e s s ais dépassé

VI. R é cursivité

19 9

dans le program m e principal. Ils'agit là d'un ch oix arbitraire puis q ue nous aurions tout aussi bien pu le faire affich e r par la fonction e lle-m ê m e .

VI-4 Puis s ance e ntiè re ________________________________________________________________________________________

Enoncé k

Ecrire une fonction ré cursive pe rm e ttant de calculer la valeur de x pour x ré e lq ue lconq ue e t k e ntie r re latif q ue lconq ue . O n e xploite ra les proprié té s s uivante s : 0

x = 1, k

x =x

pour k = 1,

-k

k

x = 1 /x k

k -1

k

k /2

x = (x x = (x

pour k positif,

)x )x

pour k positif im pair, pour k positif pair.

O n te s te ra ce tte fonction à l'aide d'un program m e principalpe rm e ttant à l'utilisate ur de fournir e n donné e s les valeurs de x e t de k .

Exe m pl es donnez une valeur réelle : 4 donnez une puissance entière : -2 4.000000e+000 à la puissance -2 = 6.250000e-002 _______________________

donnez une valeur réelle : 5.2

200

Exe rcice s e n langage C

donnez une puissance entière : 3 5.200000e+000 à la puissance 3 = 1.406080e+002 ________________________________________________________________________________________

ANALYSE L'é noncé fournit les "définitions ré cursive s " à e m ploye r.

Program m e

#include main() { double puissance(double, int) ; double x ; int n ;

/* proto fonction d'élévation à la puissance */ /* valeur dont on cherche la puissance neme */ /* puissance à laquelle on veut élever x */

printf ("donnez une valeur réelle : ") ; scanf ("%le", &x) ; printf ("donnez une puissance entière : ") ; scanf ("%d", &n) ; printf ("%le à la puissance %d = %le", x, n, puissance (x, n) ) ; } double puissance (double x, int n) { double z ; if (n < 0) return (puissance (1.0/x, -n) ) ; else if (n == 0) return (1) ; else if (n == 1) return (x) ; else if (n%2 == 0) { z = puissance (x, n/2) ; return (z*z) ; } else return (x * puissance (x, n-1) ) ;

/* puissance négative */ /* x puissance 0 égale 1 */ /* x puissance 1 égale x */ /* puissance paire */

/* puissance impaire */

VI. R é cursivité

201

}

Com m e ntaire s Ile s t pré fé rable d'écrire : z = puissance (x, n/2) ; return (z*z) ;

plutôt q ue : return (puissance (x,n/2) * puissance (x,n/2) ) ;

q ui produirait deux fois plus d'appe ls de la fonction puissance .

VI-5 Fonction d'A ck e rm ann ________________________________________________________________________________________

Enoncé Ecrire une fonction ré cursive calculant la valeur de la fonction d'Ack e rm ann, dé finie pour m e t n, e ntie rs positifs ou nuls, par : A(m ,n) = A(m -1, A(m ,n-1) ) pour m > 0 e t n> 0, A(0,n) = n+ 1 pour n> 0, A(m ,0) = A(m -1,1) pour m > 0. Ce tte fonction possédera e n argum e nt les valeurs de m e t de n et fournira e n ré s ultat la valeur de A corre s pondante . O n visualisera l'e m pilem e nt des appe ls e t leur dé pilem e nt e n affich ant un m e s s age accom pagné de la valeur des deux argum e nts lors de ch aq ue e ntrée dans la fonction ainsi que juste avant sa sortie (dans ce dernie r cas, on affich e ra é galem e nt la valeur q ue la fonction s'apprê te à re tourne r). O n te s te ra ce tte fonction à l'aide d'un program m e principalauq ue lon fournira e n donné e s les valeurs de m e t de n.

202

Exe rcice s e n langage C

Exe m pl e valeurs de m et ** entrée Acker ** entrée Acker ** entrée Acker -- sortie Acker -- sortie Acker ** entrée Acker -- sortie Acker -- sortie Acker

n ? (1, (1, (0, (0, (1, (0, (0, (1,

: 1 1 1) 0) 1) 1) = 2 0) = 2 2) 2) = 3 1) = 3

Acker (1, 1) = 3 ________________________________________________________________________________________

Program m e #include main() { int m, n, a ; int acker (int, int) ;

/* prototype fonction de calcul fonction d'Ackermann */

printf ("valeurs de m et n ? : ") ; scanf ("%d %d", &m, &n) ; a = acker (m, n) ; printf ("\n\nAcker (%d, %d) = %d", m, n, a) ; } /***********************************************************/ /* fonction récursive de calcul de la fonction d'Ackermann */ /***********************************************************/ int acker (int m, int n) { int a ; /* valeur de la fonction */ printf ("** entrée Acker (%d, %d)\n", m, n) ;

VI. R é cursivité

203

if (m<0 || n<0) a = -1 ; /* cas arguments incorrects */ else if (m == 0) a = n+1 ; else if (n == 0) a = acker (m-1, 1) ; else a = acker (m-1, acker(m, n-1) ) ; printf ("-- sortie Acker (%d, %d) = %d\n", m, n, a) ; return (a) ; }

VI-6 Tours d e H anoi ________________________________________________________________________________________

Enoncé R é aliser une fonction ré cursive proposant une s olution au problèm e dit des tours de H anoi, leq ue ls'é nonce ainsi : O n dispose de trois piq ue ts, num é roté s 1, 2 e t 3 e t de n disques de tailles diffé re nte s . Au départ, ces disques sont e m pilés par taille décroissante s ur le piq ue t num é ro 1. Le but du je u e s t de déplace r ce s n disq ues du piq ue t num é ro 1 sur le piq ue t num é ro 3, e n re s pe ctant les contrainte s s uivante s : - on ne déplace q u'un s e uldisque à la fois (d'un piq ue t à un autre ), - un disq ue ne doit jam ais ê tre placé au-de s s us d'un disq ue plus petit q ue lui. O n te s te ra ce tte fonction ave c un program m e principalpe rm e ttant de ch oisir, e n donné e , le nom bre totalde disques à déplace r (n). Si vous n'ê te s pas fam iliaris é ave c ce type de problèm e , nous vous cons e illons de te nte r tout d'abord de le ré s oudre m anue llem e nt avant de ch e rch e r à program m e r la fonction de m andé e .

Exe m pl e combien de disques ? 4 déplacer un disque de 1 en 2

204

Exe rcice s e n langage C

déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer déplacer

un un un un un un un un un un un un un un

disque disque disque disque disque disque disque disque disque disque disque disque disque disque

de de de de de de de de de de de de de de

1 2 1 3 3 1 1 2 2 3 2 1 1 2

en en en en en en en en en en en en en en

3 3 2 1 2 2 3 3 1 1 3 2 3 3

________________________________________________________________________________________

ANALYSE Pour n=1, la solution e s t é vidente ;ilsuffit de déplace r l'uniq ue disque du piquet num é ro 1 au piq ue t num é ro 3. D è s q ue n e s t supérieur à 1, on re m arq ue q u'il e s t né ce s s aire d'utiliser le piq ue t num é ro 2 pour de s s tock age s inte rm édiaire s . O n pe ut considérer que le problèm e consiste à déplace r n disques du piquet num é ro 1 ve rs le piq u e t num é ro 3, e n utilisant le piq u e t num é ro 2 com m e piq u e t inte rm é diaire . O n pe ut m ontre r q ue ce tte opé ration s e décom pos e e n trois opérations plus sim ples : - déplace r les n-1 disq ue s s upé rie urs du piq ue t num é ro 1 ve rs le piq ue t num é ro 2 ;pe ndant ce tte ph as e , on pe ut utiliser le piq ue t num é ro 3 com m e piq ue t inte rm édiaire , - déplace r les n-1 disq ues du piq ue t num é ro 2 ve rs le piq ue t num é ro 3 ;là e ncore , on pe ut utiliser le piq ue t num é ro 1 com m e piq ue t inte rm édiaire (le disque initialem e nt pré s e nt sur ce piq ue t é tant plus grand q ue tous les disques à déplace r). Ce la nous conduit à la ré alisation d'une fonction ré cursive possédant com m e argum e nts : - le nom bre de disques à déplace r, - le num é ro du piq ue t "de départ", - le num é ro du piq ue t "d'arrivé e ", - le num é ro du piq ue t "inte rm édiaire ".

VI. R é cursivité

Program m e #include main() { void hanoi (int, int, int, int) ; int nd ; /* nombre total de disques */ printf ("combien de disques ? ") ; scanf ("%d", &nd) ; hanoi (nd, 1, 3, 2) ; } /***********************************************/ /* fonction résolvant le pb des tours de hanoi */ /***********************************************/ void hanoi (int n, int depart, int but, int inter) /* n : nombre de disques à déplacer */ /* depart : tour d'où l'on part */ /* but : tour où l'on arrive */ /* inter : tour intermédiaire */ { if (n>0) { hanoi (n-1, depart, inter, but) ; printf ("déplacer un disque de %d en %d\n", depart, but) ; hanoi (n-1, inter, but, depart) ; } }

205

VII : TRA ITEM ENT D E FICH IERS

Le s e xe rcices de ce ch apitre vous fournis s e nt des exe m ples classiques de traite m e nt de fich ie rs corre s pondant à diffé re nts aspects : - traite m e nt s é q ue ntie l, - accè s direct, - fich ie rs de type te xte .

VII-1 Cré ation s é q ue ntie l l e de fich ie r ________________________________________________________________________________________

Enoncé Ecrire un program m e de création séquentiel l e d'un fich ie r com portant, pour un ce rtain nom bre de pe rsonne s , les inform ations suivante s , fournie s au clavie r : - nom (au m axim um 20 caractè re s ), - â ge , - nom bre d'enfants, - â ge de ch acun des diffé re nts e nfants ;on ne dem ande ra (e t donc on n'e nre gistre ra) q ue l'â ge des 15 pre m ie rs e nfants (m ais le nom bre figurant dans le ch am p pré cédent pourra ê tre s upé rie ur à 15). L'utilisate ur fournira un nom "vide" pour signaler q u'iln'a plus de personne s à e nre gistre r.

208 Exe rcice s e n langage C O n ne pré voira aucun contrôle particulie r au nive au de la saisie des données

Exe m pl e donnez le nom du fichier à créer : person ----- pour terminer la saisie, donnez un nom 'vide' --nom : dubois age : 32 nombre enfants : 1 age enfant no 1 : 7 nom age nombre enfants

: dunoyer : 29 : 0

nom age nombre enfants age enfant no 1 age enfant no 2 age enfant no 3

: : : : : :

nom

:

dutronc 45 3 21 18 17

-------- FIN CREATION FICHIER ---------________________________________________________________________________________________

ANALYSE La structure de ch aq ue e nre gistre m e nt du fich ie r dé coule de l'é noncé . Ce pe ndant, e n ce q ui conce rne la m aniè re de re pré s e nte r le nom des personne s , nous devons décide r de la pré s e nce ou de l'abs e nce du caractè re de fin de ch aî ne (\0). Ici, nous avons ch oisi, par facilité , d'introduire ce caractè re , ce q ui im pliq ue q ue la zone corre s pondante s oit de longue ur 21. Pour cré e r notre fich ie r, nous utiliserons les fonctions de nive au 2, c'e s t-à -dire ici fope n e t fw rite . R appe lons q ue ce lles ci travaillent ave c un pointe ur sur une s tructure de type FILE (prédéfini dans stdio.h ). La valeur de ce pointe ur nous e s t fournie par fope n ;ce tte fonction re s titue un pointe ur nule n cas d'erreur d'ouve rture . La cré ation du fich ie r consiste s im plem e nt à ré pé te r les actions :

VII. Traite m e nt de fich ie rs - lecture d'inform ations au clavie r, - é criture de ce s inform ations dans le fich ie r. Ce tte ré pé tition doit ê tre inte rrom pue à la re ncontre d'un nom vide.

Program m e #include #include #include #define LGNOM 20 #define NBENFMAX 15 #define LNOMFICH 20 main() { char nomfich [LNOMFICH+1] ; FILE * sortie ; struct { char nom [LGNOM+1] ; int age ; int nbenf ; int agenf [NBENFMAX] ; } bloc ; int i ;

/* longueur maxi d'un nom */ /* nombre maxi d'enfants */ /* longueur maxi nom de fichier */

/* nom du fichier à créer */ /* descripteur fichier (niveau 2) */ /* description d'un enregistrement */ /* du fichier */

/* ouverture fichier à créer */ /* attention : mode d'ouverture w au lieu de wb dans certains cas */ printf ("donnez le nom du fichier à créer : ") ; gets (nomfich) ; if ( (sortie = fopen (nomfich, "w")) == NULL ) { printf ("***** erreur ouverture - abandon programme") ; exit(-1) ; } /* création du fichier à partir d'informations */ /* fournies au clavier */ printf ("----- pour terminer la saisie, donnez un nom 'vide' ---\n") ; do { printf ("nom : ") ; /* saisie nom */ gets (bloc.nom) ; if ( strlen(bloc.nom) == 0) break ; /* sortie boucle si nom vide */ printf ("age : ") ; scanf ("%d", &bloc.age) ; /* saisie age */

209

210

Exe rcice s e n langage C printf ("nombre enfants : ") ; scanf ("%d", &bloc.nbenf) ; /* saisie nb enfants for (i=0 ; i < bloc.nbenf && i < NBENFMAX ; i++) { printf ("age enfant no %d : ", i+1) ; /* saisie age des scanf ("%d", &bloc.agenf[i]) ; /* différents enfants } getchar() ; /* pour éliminer \n printf ("\n") ; fwrite (&bloc, sizeof(bloc), 1, sortie) ; /* écriture fichier

*/ */ */ */ */

} while (1) ; /* fin création */ fclose(sortie) ; printf ("\n -------- FIN CREATION FICHIER ----------") ; }

Com m e ntaire s *Note z le "m ode d'ouve rture " w b : w : ouve rture e n é criture ;si le fich ie r n'e xiste pas, ile s t cré é . S'ile xiste , son ancie n conte nu e s t pe rdu. b : m ode dit "binaire " ou "non translaté ". En fait, l'indication b ne s e justifie q ue dans les im plém e ntations q ui distingue nt les fich ie rs de te xte des autre s . Une te lle distinction e s t m otivé e par le fait q ue le caractè re de fin de ligne (\n) possè de, sur certains systè m e s , une re pré s e ntation particuliè re obte nue par la succe s s ion de deux caractè re s . La pré s e nce de b é vite le ris q ue q ue le fich ie r conce rné s oit considéré com m e un fich ie r de type te xte , ce q ui am è ne rait une inte rpré tation non souh aité e d e s couples de caractè re s re pré s e ntant une fin de ligne . *Ici, nous avons fait appe là la fonction e xit (son prototype figure dans stdlib.h ) pour inte rrom pre le program m e e n cas d'erreur d'ouve rture du fich ie r. Ils'agit là d'un ch oix arbitraire . Nous aurions pu de m ande r à l'utilisate ur de propos e r un autre nom de fich ie r. *En ce q ui conce rne la boucle de cré ation du fich ie r, nous avons ch oisi de la program m e r sous form e d'une boucle infinie : do ....... .......

VII. Traite m e nt de fich ie rs

211

while (1) ;

q ue nous inte rrom pons au m om e nt opportun par bre ak . Nous aurions pu é galem e nt ch oisir d'introduire les pre m iè re s instructions de la boucle dans l'e xpre s s ion conditionnant une instruction w h ile, de ce tte m aniè re : while (printf("nom

: "), gets(bloc.nom), strlen(bloc.mot) )

*Com m e pré vu par l'é noncé , aucun contrôle particulie r n'e s t e ffe ctué s ur les données qui sont donc lue s par scanf e t ge ts. Là e ncore s e pos e le problèm e d'ignore r le \n q ui subsiste aprè s une lecture par scanf, ce q ui im pose d'introduire artificie llem e nt une instruction ge tch ar (pour plus de détails sur ce problèm e , voye z les com m e ntaires de l'e xe rcice V-3). *R appe lons q ue la fonction d'é criture dans le fich ie r (fw rite ) possè de 4 argum e nts : - L'adresse de début d'un e ns e m ble de blocs à é crire (note z bie n la notation & bloc e t non sim plem e nt bloc, dans la m e s ure où le nom d'une s tructure désigne sa valeur e t non son adre s s e , com m e ce la e s t le cas pour un tableau). - La taille d'un bloc. Note z q u'ici nous avons utilisé la fonction size of, ce q ui assure la portabilité du program m e . - Le nom bre de blocs de ce tte taille à é crire (ici, 1). - L'adresse de la structure décrivant le fich ie r (e lle a é té fournie par fope n).

D ISCUSSIO N *Ce program m e n'e xam ine pas le code de re tour de fw rite , leq ue lpré cis e le nom bre de blocs ré e llem e nt é crits dans le fich ie r (ce nom bre é tant infé rie ur au nom bre s ouh aité e n cas d'erreur d'écriture ). Ilfaut toute fois note r, à ce propos, q ue , gé né ralem e nt, un ce rtain nom bre d'erreurs sont "ré cupé ré e s " par le systè m e q ui affich e alors lui-m ê m e s on propre m e s s age . *Com m e le pré voyait l'é noncé , ce program m e n'e s t pas proté gé d'éve ntue lles e rre urs dans les ré pons e s fournie s par l'utilisate ur. A titre indicatif, voici q ue lque s s ituations q ue l'on pe ut re ncontre r : - Si l'utilisate ur fournit un nom de fich ie r de plus de 20 caractè re s , ily aura é cras e m e nt d'inform ations e n m é m oire . Ici, ils e rait toute fois as s e z facile de re m édier à ce problèm e e n attribuant au sym bole LNO M FICH une valeur supérieure au nom bre de caractè re s q ue l'on pe ut frappe r au clavie r dans l'im plém e ntation conce rné e . O n pourrait é galem e nt lire un nom bre de caractè re s lim ité s e n utilisant, au lie u de ge ts (nom fich ), l'instruction : fgets (nomfich, LNOMFICH, stdin) ;

Note z toute fois q ue , dans ce cas, les caractè re s s upplém e ntaire s frappé s é ve ntue llem e nt par l'utilisate ur sur la m ê m e "ligne " s e raie nt pris e n com pte par une proch aine instruction de lecture s ur l'e ntré e s tandard.

212 Exe rcice s e n langage C D ans ce rtaine s im plém e ntations (notam m e nt Turbo/Borland C e t C/Quick C M icrosoft), ile s t possible de ré gler com plète m e nt le problèm e e n utilisant l'instruction cge ts q ui a le m é rite de lim ite r, non s e ulem e nt le nom bre de caractè re s pris e n com pte , m ais é galem e nt ce ux e ffe ctive m e nt frappé s au clavie r. - Si l'utilisate ur fournit plus de caractè re s q ue n'e n atte nd scanf, ce ux-ci s e ront utilisés (ave c plus ou m oins de bonh e ur) par une lecture s uivante . Là e ncore , le problèm e ne pe ut ê tre conve nablem e nt ré glé q ue d'une façon dépendant de l'im plém e ntation, par e xe m ple ave c la fonction cge ts (associé e , ce tte fois, à sscanf) cité e pré cédem m e nt. - Si l'utilisate ur fournit des caractè re s non num é riq ue s là où scanf atte nd des ch iffre s , le ré s ultat de la lecture s e ra arbitraire ;le program m e ne s 'e n ape rce vra pas puisq u'ilne te s te pas le code de re tour de scanf (q ui fournit le nom bre de valeurs e ffe ctive m e nt lue s ). De plus, là e ncore , les caractè re s non traité s s e ront re pris par une lecture ulté rie ure . Le pre m ie r point pe ut, là e ncore , ê tre ré s olu par l'e m ploi de sscanf, associé à fge ts (..., stdin). Là e ncore , dans ce rtaine s im plém e ntations, cge ts (associé e à sscanf) pe rm e t de ré gler totalem e nt le problèm e .

VII-2 Lis te s é q ue ntie l l e d'un fich ie r ________________________________________________________________________________________

Enoncé R é aliser un program m e pe rm e ttant d'affich e r succe s s ive m e nt ch acun de s e nre gistre m e nts d'un fich ie r analogue à ce ux cré é s par le program m e pré cédent. Le program m e pré s e nte ra un s e ule nre gistre m e nt à la fois, accom pagné d'un num é ro pré cisant son rang dans le fich ie r (on attribue ra le num é ro 1 au pre m ie r e nre gistre m e nt) ;ilatte ndra q ue l'utilisate ur frappe la touch e re turn avant de pas s e r à l'e nre gistre m e nt suivant. L'affich age des inform ations s e ra ré alisé par une fonction à laq ue lle on transm e ttra e n argum e nt l'e nre gistre m e nt à affich e r e t son num é ro. Le m odè le m ê m e de la structure corre s pondante s e ra, q uant à lui, dé fini à un nive au global. Le program m e devra s'assure r de l'e xiste nce du fich ie r à liste r.

Exe m pl e donnez le nom du fichier à lister : person enregistrement numéro : 1 NOM AGE NOMBRE D'ENFANTS

: dubois : 32 : 1

VII. Traite m e nt de fich ie rs AGE ENFANT

1

:

213

7

enregistrement numéro : 2 NOM AGE NOMBRE D'ENFANTS

: dunoyer : 29 : 0

enregistrement numéro : 3 NOM AGE NOMBRE D'ENFANTS AGE ENFANT 1 AGE ENFANT 2 AGE ENFANT 3

: : : : : :

dutronc 45 3 21 18 17

-------- FIN LISTE FICHIER ---------________________________________________________________________________________________

Program m e

#include #include #define LGNOM 20 #define NBENFMAX 15 #define LNOMFICH 20

/* longueur maxi d'un nom */ /* nombre maxi d'enfants */ /* longueur maxi nom de fichier */

struct enreg { char nom [LGNOM+1] ; int age ; int nbenf ; int agenf [NBENFMAX] ; } ;

214

Exe rcice s e n langage C

main() { void affiche (struct enreg *, int) ; char nomfich [LNOMFICH+1] ; FILE * entree ; struct enreg bloc ; int num ;

/* /* /* /* /*

fonction d'affichage */ nom du fichier à lister */ descripteur fichier (niveau 2) */ enregistrement fichier */ numéro d'enregistrement */

/* ouverture fichier à lister */ /* attention : mode d'ouverture : r au lieu de rb dans certains cas */ do { printf ("donnez le nom du fichier à lister : ") ; gets (nomfich) ; if ( (entree = fopen (nomfich, "rb")) == 0 ) printf ("fichier non trouvé\n") ; } while (!entree) ; /* liste du fichier */ num = 1 ; while (fread(&bloc, sizeof(bloc), 1, entree), ! feof(entree) ) { affiche (&bloc, num++) ; getchar() ; /* attente frappe "return" */ } /* fin liste */ fclose(entree) ; printf ("\n\n -------- FIN LISTE FICHIER ----------") ; } /*************************************************/ /* fonction d'affichage d'un enregistrement */ /*************************************************/ void affiche (struct enreg * bloc, int num) { int i ; printf ("\n\nenregistrement numéro : %d\n\n", num) ; printf ("NOM : %s\n", bloc->nom) ; printf ("AGE : %d\n", bloc->age) ; printf ("NOMBRE D'ENFANTS : %d\n", bloc->nbenf) ; for (i=0 ; i < bloc->nbenf && i < NBENFMAX ; i++)

VII. Traite m e nt de fich ie rs printf ("AGE ENFANT %2d

215

: %2d\n", i+1, bloc->agenf[i]) ;

}

Com m e ntaire s *Note z le m ode d'ouve rture rb : r : ouve rture e n lecture . Si le fich ie r n'e xiste pas, fope n fournit un pointe ur nul. b : ouve rture e n m ode "binaire " ou "non translaté " (pour plus d'inform ations sur la diffé re nce e ntre les m ode s translaté e t non translaté , voye z les com m e ntaires de l'e xe rcice VII-1). *R appe lons q ue la fonction de lecture fre ad possè de 4 argum e nts, com parables à ce ux de fw rite : - l'adresse de début d'un e ns e m ble de blocs à lire , - la taille d'un bloc (e n octe ts), - le nom bre de blocs de ce tte taille à lire , - l'adresse de la structure décrivant le fich ie r (e lle a é té fournie par fope n). *La fonction fe of pre nd la valeur vrai (1) lors q ue la fin de fich ie r a é té e ffe ctive m e nt re ncontré e . Autre m e nt dit, ilne suffit pas, pour dé te cte r la fin d'un fich ie r, d'avoir sim plem e nt lu son dernier octe t ;ile s t, de plus, né ce s s aire d'avoir te nté de lire au-de là. C'e s t ce q ui justifie q ue ce tte condition soit e xam iné e aprè s fre ad e t non avant. *Voye z la façon dont nous avons program m é la boucle de lecture des diffé re nts e nre gistre m e nts du fich ie r. Ce la nous é vite une s ortie e n cours de boucle par bre ak , com m e dans : do { fread (&bloc, sizeof(bloc), 1, entree) ; if (feof(entree)) break ; affiche (&bloc, num++) ; getchar() ; } while (1) ;

ou un te s t supplém e ntaire dans la boucle com m e dans :

216

Exe rcice s e n langage C do { fread (&bloc, sizeof(bloc), 1, entree) ; if (!feof(entree)) { affiche (&bloc, num++) ; getchar ; } } while (!feof(entree)) ;

D ISCUSSIO N *Ce program m e n'e xam ine pas le code de re tour de fre ad (ce lui-ci pré cis e le nom bre de blocs ré e llem e nt lus). *Notre program m e n'e s t pas proté gé contre la fourniture par l'utilisate ur d'un nom de fich ie r de plus de 20 caractè re s . Voye z la discussion de l'e xe rcice pré cédent. *Le passage à l'e nre gistre m e nt suivant e s t déclench é par la frappe de re turn. M ais si l'utilisate ur frappe un ou plusieurs caractè re s (validés par re turn), ilve rra dé filer plusieurs enregistre m e nts de suite . La solution à ce problèm e dépe nd, ici e ncore , de l'im plém e ntation. Par e xe m ple, dans un environne m e nt D O S, ave c Turbo/Borland C/C+ + ou Quick C/C M icrosoft, ilsuffira de "vider le tam pon du systè m e " par : while (kbhit()) getch ;

avant ch aq ue atte nte .

VII-3 Corre ction de fich ie r ________________________________________________________________________________________

Enoncé R é aliser un program m e pe rm e ttant d'effe ctue r de s corre ctions sur un fich ie r analogue à ce ux cré é s par le program m e de l'e xe rcice VII-1.

VII. Traite m e nt de fich ie rs

217

L'utilisate ur dé s igne ra un e nre gistre m e nt par son num é ro d'ordre dans le fich ie r. Le program m e s 'assure ra de s on e xiste nce e t l'affich e ra d'abord te lq ue lavant de dem ande r les m odifications à lui apporte r. Ces derniè re s s e ront e ffe ctué e s ch am p par ch am p. Pour ch aq ue ch am p, le program m e e n affich e ra à nouve au la valeur, puis ildem ande ra à l'utilisate ur d'e ntre r une é ve ntue lle valeur de re m place m e nt. Si aucune m odification n'e s t souh aité e , ilsuffira à ce dernie r de ré pondre directe m e nt par la frappe de re turn. O n pré voira de ux fonctions : - une pour l'affich age d'un enregistre m e nt (on pourra re pre ndre la fonction affich e de l'e xe rcice pré cédent), - une pour la m odification d'un e nre gistre m e nt.

Exe m pl e donnez le nom du fichier à modifier : person numéro enregistrement à modifier (0 pour fin) : 14 numéro enregistrement à modifier (0 pour fin) : 2

enregistrement numéro : 2 NOM AGE NOMBRE D'ENFANTS

: dunoyer : 29 : 0

entrez vos nouvelles infos (return si pas de modifs) NOM : Dunoyer AGE : NOMBRE D'ENFANTS : 1 AGE ENFANT 1 : 15 numéro enregistrement à modifier (0 pour fin) : 0

-------- FIN MODIFICATIONS FICHIER ---------________________________________________________________________________________________

218

Exe rcice s e n langage C

ANALYSE A partir du m om e nt où l'on souh aite re trouve r un e nre gistre m e nt par son rang dans le fich ie r, ilparaî t logiq ue de ré aliser un "accè s direct". R appe lons q u'e n langage C ce lui-ci s'obtie nt e n agissant sur la valeur d'un pointe ur dans le fich ie r à l'aide de la fonction fs e e k . La lecture e t l'é criture , q uant à e lles , re s te nt toujours ré alisées par les fonctions fre ad e t fw rite . L'é noncé ne nous im pos e pas de contrôle s ur l'inform ation lue au clavie r. Né anm oins, nous devons ê tre e n m e s ure d'acce pte r e t de re connaî tre com m e te lle une "ré pons e vide". D ans ce s conditions, nous ne pouvons pas em ploye r scanf q ui ris q ue rait de conduire à un bouclage s ur le caractè re \n. Une s olution à un te lproblèm e consiste à lire tout d'abord la ré ponse de l'utilisate ur sous form e d'une ch aî ne , ce q ui pe rm e t de déce ler conve nablem e nt les ré pons e s vides. Si l'on souh aite une s olution dé pe ndante de l'im plém e ntation, ce la pe ut s e faire s oit ave c ge ts, soit (si l'on souh aite lim ite r le nom bre de caractè re s pris e n com pte ) ave c fge ts (..., stdin).Ici, nous utiliserons la pre m iè re possibilité , e n faisant appe l à une zone de 128 caractè re s (dans bon nom bre d'im plém e ntations, on ne pe ut pas frappe r au clavie r de "ligne s " plus longue s !). Lors q u'une inform ation num é riq ue e s t atte ndue , ilnous suffit alors de "décode r" le conte nu de ce tte ch aî ne . Ce la pe ut s e faire , soit ave c la fonction sscanf assortie (ici) d'un form at %d, soit ave c la fonction standard atoi. Par souci de dive rsité , nous avons ch oisi ici la s e conde .

Program m e

#include #include #define #define #define #define #define

VRAI 1 FAUX 0 LGNOM 20 NBENFMAX 15 LNOMFICH 20

/* /* /* /* /*

pour simuler ..... */ ..... des booléens */ longueur maxi d'un nom */ nombre maxi d'enfants */ longueur maxi nom de fichier */

struct enreg { char nom [LGNOM+1] ; int age ; int nbenf ; int agenf [NBENFMAX] ; } ; main() {

VII. Traite m e nt de fich ie rs void affiche (struct enreg *, int) ; void modifie (struct enreg *) ; char nomfich [LNOMFICH+1] ; FILE * fichier ; struct enreg bloc ; int num, horsfich ; long nb_enreg, pos ;

/* /* /* /* /* /* /* /* /*

fonction d'affichage */ fonction de modif d'un enreg */ nom du fichier à lister */ descripteur fichier (niveau 2) */ enregistrement fichier */ numéro d'enregistrement */ indicateur "logique" */ nbre d'enregistrements du fichier */ position courante (octets) dans fich */

/* ouverture (en mise à jour) fichier à modifier et calcul de sa taille */ /* attention, mode d'ouverture r+ au lieu de r+b dans certains cas */ do { printf ("donnez le nom du fichier à modifier : ") ; gets (nomfich) ; if ( (fichier = fopen (nomfich, "r+b")) == 0 ) printf ("fichier non trouvé\n") ; } while (! fichier) ; fseek (fichier, 0, 2) ; nb_enreg = ftell (fichier) / sizeof(bloc) ; /* boucle de corrections d'enregistrements */ /* jusqu'à demande d'arrêt */ do { do { printf ("\nnuméro enregistrement à modifier (0 pour fin) : "); scanf ("%d", &num) ; getchar() ; /* pour sauter le dernier \n" */ horsfich = num < 0 || num > nb_enreg ; } while (horsfich) ; if (num == 0 ) break ; /* sortie boucle si demande arrêt pos = (num-1) * sizeof(bloc) ; /* calcul position courante fseek (fichier, pos, 0) ; /* positionnement fichier fread (&bloc, sizeof(bloc), 1, fichier) ; /* lecture enreg affiche (&bloc, num) ; /* affichage enreg modifie (&bloc) ; /* modif enreg fseek (fichier, pos, 0) ; /* repositionnement fichier fwrite (&bloc, sizeof(bloc), 1, fichier) ; /* réécriture enreg

*/ */ */ */ */ */ */ */

219

220

Exe rcice s e n langage C } while (1) ;

/* fin modifications */ fclose(fichier) ; printf ("\n\n -------- FIN MODIFICATIONS FICHIER ----------\n") ; } /*************************************************/ /* fonction d'affichage d'un enregistrement */ /*************************************************/ void affiche (struct enreg * bloc, int num) { int i ; printf ("\n\nenregistrement numéro : %d\n\n", num) ; printf ("NOM : %s\n", bloc->nom) ; printf ("AGE : %d\n", bloc->age) ; printf ("NOMBRE D'ENFANTS : %d\n", bloc->nbenf) ; for (i=0 ; i < bloc->nbenf && i < NBENFMAX ; i++) printf ("AGE ENFANT %2d : %2d\n", i+1, bloc->agenf[i]) ; } /***************************************************/ /* fonction de modification d'un enregistrement */ /***************************************************/ void modifie (struct enreg * bloc) { char ligne[127] ; /* chaîne de lecture d'une ligne d'écran */ int i ; printf ("\n\n\entrez vos nouvelles infos (return si pas de modifs)\n") ; printf ("NOM : ") ; gets (ligne) ; if (strlen(ligne)) strcpy (bloc->nom, ligne) ; printf ("AGE : ") ; gets (ligne) ; if (strlen(ligne)) bloc->age = atoi(ligne) ; printf ("NOMBRE D'ENFANTS

: ") ;

VII. Traite m e nt de fich ie rs

221

gets (ligne) ; if (strlen(ligne)) bloc->nbenf = atoi(ligne) ; for (i=0 ; i < bloc->nbenf && i < NBENFMAX ; i++) { printf ("AGE ENFANT %2d : ", i+1) ; gets (ligne) ; if (strlen(ligne)) bloc->agenf[i] = atoi(ligne) ; } }

Com m e ntaire s *Nous avons ouve rt le fich ie r dans le m ode r+ b, leq ue lautoris e la m ise à jour (lecture e t é criture e n un e m place m e nt q ue lconq ue du fich ie r). Note z q u'ilfaut é vite r d'é crire ici rb+ , ce q ui ne provoq ue rait gé né ralem e nt pas d'erreur d'ouve rture , m ais q ui e m pê ch e rait toute é criture dans le fich ie r (ici, notre program m e ne s 'ape rce vrait pas de ce tte anom alie puis q u'ilne te s te pas le code de re tour de fw rite ). En ce q ui conce rne l'indication b, rappe lons q ue ce lle-ci n'e s t indispensable q ue dans les im plém e ntations q ui distingue nt les fich ie rs de type te xte des autre s . R e voye z é ve ntue llem e nt les com m e ntaires de l'e xe rcice VII.1. *Aprè s l'ouve rture du fich ie r, nous e n dé te rm inons la taille (dans la variable nb_e nre g) à l'aide des fonctions fs e e k e t fte ll. Plus précisém e nt : fseek (fichier, 0, 2)

nous place à 0 octe t de la fin (code 2) du fich ie r e t : ftell (fichier)

nous donne la position courante du pointe ur associé au fich ie r (q ui pointe ici sur la fin). Ilnous e s t alors facile de la transform e r e n un nom bre d'enregistre m e nts, e n la divisant par la taille d'un enregistre m e nt. *N'oublie z pas q u'aprè s avoir lu un e nre gistre m e nt, ile s t né ce s s aire , avant de le ré é crire , de positionne r à nouve au le pointe ur dans le fich ie r.

D ISCUSSIO N

222 Exe rcice s e n langage C *Com m e dans les pré cédents program m e s , nous n'avons pas introduit de prote ctions particuliè re s vis-à -vis des réponses fournie s par l'utilisate ur (voye z les discussions des précédents program m e s ). Toute fois, ici, la m aniè re m ê m e dont nous avons program m é la saisie des corre ctions, iln'e xiste pas, à ce nive au, de ris q ue de "plangage " cons é cutif à une m auvais e ré pons e puis q ue nous n'avons pas fait appe là scanf.

VII-4 Com ptage de l e ttre s e t m ots d'un fich ie r te xte ________________________________________________________________________________________

Enoncé Ecrire un program m e q ui, à partir d'un fich ie r te xte , déte rm ine : - le nom bre de caractè re s q u'ilcontie nt, - le nom bre de ch acune des lettres de l'alph abet (on ne considérera que les m inuscules ), - le nom bre de m ots, - le nom bre de ligne s. Le s fins de ligne s ne devront pas ê tre com ptabilisées dans les caractè re s . O n adm e ttra q ue deux m ots sont toujours s é paré s par un ou plusieurs des caractè re s s uivants : - fin de ligne - e s pace - ponctuation : : . , ;?! - pare nth è s e s : ( ) - guillem e ts : " - apostroph e : ' O n adm e ttra é galem e nt, pour sim plifie r, q u'aucun m ot ne pe ut ê tre com m e ncé s ur une ligne e t s e poursuivre s ur la suivante . Ile s t cons e illé de ré aliser une fonction pe rm e ttant de décide r si un caractè re donné, transm is en argum e nt, e s t un de s s é parate urs m e ntionné s ci-de s s us. Elle re s titue ra la valeur 1 lors q ue le caractè re e s t un s é parate ur e t la valeur 0 dans le cas contraire .

VII. Traite m e nt de fich ie rs

223

Exe m pl e donnez le nom du fichier à examiner : b:letfic.c votre fichier contient 87 lignes, 371 mots et 3186 caractères dont : 69 fois la lettre a 6 fois la lettre b 74 fois la lettre c 36 fois la lettre d 163 fois la lettre e ........ 110 fois la lettre t 63 fois la lettre u 7 fois la lettre v 3 fois la lettre w 6 fois la lettre x 0 fois la lettre y 1 fois la lettre z et 1979 autres caractères ________________________________________________________________________________________

ANALYSE Com m e nous avons déjà e u l'occasion de le voir dans les e xe rcice s I-5 e t I-6, ce type de problèm e pe ut ê tre ré s olu d'au m oins deux m aniè re s : - e n e ffe ctuant une ré pé tition du traite m e nt d'un caractè re , - e n e ffe ctuant une ré pé tition du traite m e nt d'une ligne , lui-m ê m e constitué de la ré pé tition du traite m e nt de ch acun des caractè re s q u'e lle contie nt. Toute fois, ici, nous avons à faire à un fich ie r dans leq ue lla longue ur m axim ale d'une ligne n'e s t pas connue a priori, ce q ui re nd la s e conde m é th ode difficile à m e ttre e n oe uvre . Nous ch oisirons donc la pre m iè re ;ch aq ue caractè re du fich ie r s e ra donc lu par fge tc. R appe lons q ue ce rtaine s im plém e ntations distingue nt les fich ie rs de type te xte des autre s . Dans ce cas, une te lle distinction n'e s t pas lié e au conte nu m ê m e du fich ie r (e n fait, on pe ut toujours considérer qu'un fich ie r, q ue lq ue s oit son conte nu, e s t form é d'une suite d'octe ts, donc, finalem e nt, d'une s uite de caractè re s ). Elle a sim plem e nt pour obje ctif de

224 Exe rcice s e n langage C faire e n sorte q ue , pour le program m e , les "fins de ligne " apparais s e nt toujours m até rialisées par un caractè re uniq ue , à savoir \n (alors q ue , pré cis é m e nt, ce rtaine s im plém e ntations, DOS notam m e nt, re pré s e nte nt une fin de ligne par un "coupe " de caractè re s ). Lors q u'une te lle distinction e s t né ce s s aire , ile s t pré vu d'introduire l'indication t, au nive au du m ode d'ouve rture du fich ie r (de m ê m e q u'on y introduisait l'indication b pour signaler q u'ilne s 'agissait pas d'un fich ie r de type te xte ). Bie n e nte ndu, ici, nous avons tout inté rê t à profite r de ce tte possibilité , de m aniè re à nous facilite r la déte ction de s fins de ligne e t, surtout, à obte nir un program m e portable (à l'e xce ption, é ve ntue llem e nt, de l'indication t). Le s com ptage s à e ffe ctue r au nive au de s caractè re s (nom bre de caractè re s , nom bre de ch acune des m inuscules ) pe uve nt ê tre ré alisés de façon nature lle, à condition toute fois de ne pas com ptabiliser \n com m e un caractè re (au contraire , à sa re ncontre , ilfaudra incré m e nte r le com pte ur de ligne s ). En ce q ui conce rne les com ptages de m ots, nous procéderons com m e dans le pre m ie r program m e de l'e xe rcice I-6 e n e m ployant : - une fonction pe rm e ttant de te s te r si un caractè re e s t un s é parate ur, - un indicate ur logiq ue : m ot_e n_cours.

Program m e #include #define LNOMFICH 20 #define VRAI 1 #define FAUX 0

/* longueur maximale d'un nom de fichier */ /* pour "simuler" des ..... */ /* ..... valeurs logiques */

main() { int sep (char) ; /* fonction test "caractère séparateur?" */ char nomfich [LNOMFICH+1] ; /* nom du fichier à examiner */ FILE * entree ; char c ; int compte [26], numl, ntot, nautres, nmots, nlignes, mot_en_cours, i ;

/* /* /* /* /* /* /* /* /*

descripteur du fichier à examiner */ caractère courant */ pour compter les différentes lettres */ rang lettre courante dans l'alphabet */ compteur nombre total de caractères */ compteur carac autres que minuscules */ compteur du nombre de mots */ compteur du nombre de lignes */ indicateur logique : mot trouvé */

VII. Traite m e nt de fich ie rs /* entrée du nom de fichier à examiner et ouverture */ /* attention, mode r au lieu de rt, dans certains cas */ do { printf ("donnez le nom du fichier à examiner : ") ; gets (nomfich) ; if ( (entree = fopen (nomfich, "rt")) == NULL) printf ("***** fichier non trouvé\n") ; } while (entree == NULL) ;

/* initialisations */ for (i=0 ; i<26 ; i++) compte[i] = 0 ; ntot = 0 ; nautres = 0 ; nmots = 0 ; nlignes = 0 ; mot_en_cours = FAUX ; /* boucle d'examen de chacun des caractères du fichier */ while ( c = fgetc (entree), ! feof (entree) ) { if (c == '\n') nlignes++ ; /* comptages au niveau caractères */ else { ntot++ ; numl = c -'a' ; if (numl >= 0 && numl < 26) compte[numl]++ ; else nautres++ ; } if (sep(c)) { if (mot_en_cours) { nmots++ ; mot_en_cours = FAUX ; } } else mot_en_cours = VRAI ;

/* comptages au niveau mots */

} /* affichage résultats */ printf ("\nvotre fichier contient %d lignes, %d mots\n", nlignes, nmots) ;

225

226

Exe rcice s e n langage C printf ("et %d caractères dont :\n", ntot) ; for (i=0 ; i<26 ; i++) printf ("%d fois la lettre %c\n", compte[i], 'a'+i) ; printf ("\net %d autres caractères\n", nautres) ;

} /*********************************************************/ /* fonction de test "caractère séparateur" */ /*********************************************************/ int sep (char c) { char sep[12] = {'\n', ' ', ',', ';', ':', '.', '?', '!', '(', ')', '"', '\'' } ; int nsep=12, i ;

/* /* /* /* /* /*

fin de ligne */ espace */ ponctuation */ parenthèses */ guillemets, apostr*/ nbre séparateurs */

i = 0 ; while ( c!=sep[i] && i
Com m e ntaire s Le fich ie r a é té ouve rt e n m ode rt : r : ouve rture e n lecture . Si le fich ie r n'e xiste pas, fope n fournit un pointe ur nul. t : ouve rture e n m ode translaté (voye z à ce propos, le pre m ie r com m e ntaire de l'e xe rcice VII-1). Note z q ue le ch oix du m ode translaté n'e s t jam ais absolum e nt indispensable. Toute fois, com m e nous l'avons dit dans l'analyse, ilnous facilite la déte ction de fin de ligne e t, de plus, ilre nd le program m e transportable (par e xe m ple s ous UNIX, où une fin de ligne e s t re pré s e nté e par \n).

VII. Traite m e nt de fich ie rs

227

D ISCUSSIO N Nous avons suppos é (im plicite m e nt) q ue notre program m e traitait un vé ritable fich ie r te xte , autre m e nt dit q ue ce dernie r s e te rm inait par une fin de ligne . Si ce la n'é tait pas le cas : - la derniè re ligne ne s e rait pas com ptabilisée, - le dernie r m ot ne s e rait pas com ptabilisé, à m oins d'ê tre s uivi d'au m oins un séparate ur.

VIII : ANALYSE NUM ERIQUE

Ce ch apitre vous propose q ue lque s applications du langage C à l'analyse num é riq ue . Nous avons ch e rch é à y introduire les te ch niq ues de program m ation q ui inte rvie nne nt fré q ue m m e nt dans ce dom aine . Citons, par e xe m ple : - la re pré s e ntation e t les m anipulations de m atrice s , - la re pré s e ntation de nom bre s com plexe s , - la ré alisation de m odules s usce ptibles de travailler ave c une fonction q ue lconq ue ou ave c des tableaux de dim e nsions q ue lconq ue s .

VIII-1 Produit de m atrice s ré e l l es ________________________________________________________________________________________

Enoncé Ecrire une fonction calculant le produit de deux m atrice s ré e lles . O n supposera q ue le pre m ie r indice de ch aq ue tableau re pré s e ntant une m atrice corre s pond à une ligne . O n pré voira e n argum e nts : - les adresses des deux m atrice s à m ultiplie r e t ce lle de la m atrice produit, - le nom bre de ligne s e t le nom bre de colonnes de la pre m iè re m atrice , - le nom bre de colonnes de la s e conde m atrice (son nom bre de ligne s é tant obligatoire m e nt é galau nom bre de colonnes de la pre m iè re ). Un program m e principalpe rm e ttra de te s te r ce tte fonction.

230

Exe rcice s e n langage C

Exe m pl e MATRICE A 0 1 2 1 2 3 2 3 4 3 4 5 4 5 6

3 4 5 6 7

MATRICE B 0 1 2 1 2 3 2 3 4 3 4 5 PRODUIT A x B 14 20 26 20 30 40 26 40 54 32 50 68 38 60 82

ANALYSE R appe lons q ue s i A est une m atrice n, p (n ligne s e t p colonne s ) e t si B e s t une m atrice p, q , la m atrice produit : C=A x B e s t une m atrice n, q d é finie par : c = ij

Program m e #define N 5 #define P 4 #define Q 3

a b ik

kj

VIII. Analy s e num é riq u e main() { void prod_mat(double *, double *, double *, int, int, int) ; double a[N][P], b[P][Q], c[N][Q] ; int i, j ; /* initialisation matrice a */ for (i=0 ; i
231

232

Exe rcice s e n langage C

}

void prod_mat ( double * a, double * b, double * c, int n, int p, int q) { int i, j, k ; double s ; double *aik, *bkj, *cij ; cij = c ; for (i=0 ; i
Com m e ntaire s *D ans la fonction prod_m at, nous n'avons pas pu utiliser le "form alism e " des tableaux pour les m atrice s a, b e t c car ce lles -ci possè dent deux dim e nsions non connue s lors de la com pilation du program m e . R appe lons q u'un te lproblèm e ne s e pos e pas lors q u'ils'agit de tableaux à une s e ule dim e nsion (car une notation te lle q ue t[i] a toujours un sens, quelle q ue s oit la taille de t) ou lors q u'ils'agit d'un tableau à plusieurs dim e nsions dont s e ule la pre m iè re e s t inconnue (com pte te nu de la m aniè re dont les é lém e nts d'un tableau sont rangé s e n m é m oire ). D ans ce s conditions, nous som m e s obligé de faire appe lau form alism e des pointe urs pour re pé re r un é lém e nt q ue lconq ue de nos m atrice s . Pour ce faire , nous transm e ttons à la fonction prodm at l'adresse de début des trois m atrice s conce rné e s . Note z q u'e n toute rigue ur (du m oins d'aprè s la norm e ANSI), dans le program m e m ain, un sym bole te lq ue a e s t du type (double [P]) * (c'e s t-à -dire q u'ilre pré s e nte un pointe ur sur des blocs de P é lém e nts de type double), e t non pas sim plem e nt du type double*. Ildoit donc ê tre conve rti dans le type double *, ce tte conve rsion ne m odifiant pas, e n fait, l'adre s s e corre s pondante (re voye z é ve ntue llem e nt les com m e ntaires de l'e xe rcice V.5 de la pre m iè re partie de ce t ouvrage ). Ce tte conve rsion q ue lque pe u fictive pe ut soit ê tre m ise en place autom atiq ue m e nt par le com pilate ur, au vu du

VIII. Analy s e num é riq u e

233

prototype , soit ê tre e xplicité e à l'aide d'un opé rate ur de "cast" ;ce tte derniè re façon de faire a souve nt le m é rite d'évite r des m e s s ages d'ave rtissem e nt inte m pe s tifs ("w arnings"). *Note z q ue , dans la définition de la fonction prodm at, nous avons dû te nir com pte de la m aniè re dont le langage C range e n m é m oire les é lém e nts d'un tableau à deux dim e nsions (suivant ce q u'on nom m e abusive m e nt les "ligne s " du tableau, c'e s t-à -dire s uivant l'ordre obte nu e n faisant varie r e n pre m ie r le dernie r indice ). Plus précisém e nt : - Le sym bole aik re pré s e nte un pointe ur courant sur les é lém e nts a . Pour ch aq ue valeur de i, aik e s t initialisé à ik

l'adresse du pre m ie r é lém e nt de la ligne i de la m atrice a (a+i*p) e t ile s t incré m e nté d'une colonne , e n m ê m e te m ps q ue l'indice k (d'où la pré s e nce de aik ++ dans la boucle e n k ). - D e m ê m e , bk j re pré s e nte un pointe ur courant sur les é lém e nts b . Pour ch aq ue valeur de j, bk j e s t initialisé à kj

l'adresse du pre m ie r é lém e nt de la colonne j de la m atrice b (b+j) e t ile s t incré m e nté d'une ligne e n m ê m e te m ps q ue l'indice k (d'où la pré s e nce de bkj=bkj+q dans la boucle e n k ). - Enfin, cij re pré s e nte un pointe ur courant sur les é lém e nts c . Ile s t initialisé à l'adresse du pre m ie r é lém e nt de la ij

m atrice c. Ilprogresse de 1 à ch aq ue tour de la boucle la plus inte rne e n j (note z q u'iln'e n aurait pas é té ainsi si nous avions inve rs é les deux boucles e n i e t j).

D ISCUSSIO N *O n a souve nt te ndance à dire q u'une fonction com m e prod_m at travaille s ur de s m atrices de dim e nsions variables . En fait, le te rm e e s t q ue lque pe u am bigu. Ainsi, dans notre e xe m ple, les m atrices dont on transm e t l'adre s s e e n argum e nt à prod_m at ont une taille bien déte rm inée dans le program m e principal. Iln'e n re s te pas m oins q ue : - d'une part, la m ê m e fonction pe ut travailler sur des m atrices de tailles diffé re nte s , - d'autre part, rie n n'e m pê ch e rait q u'au s e in du program m e principal, les m atrice s a, b e t c voie nt leur taille définie uniq ue m e nt lors de l'e xé cution e t leurs e m place m e nts alloués dynam iq ue m e nt. *Au sein d'une fonction com m e prod_m at, ile s t possible d'em ploye r le form alism e des tableaux à la place de ce lui de s pointe urs e n faisant appe là un artifice . Ce lui-ci consiste à cré e r, pour ch aq ue m atrice , un tableau de pointe urs conte nant l'adresse de début de ch aq ue ligne . Ainsi, par e xe m ple, pour la m atrice a, on pourrait ré s e rve r un tableau nom m é ada par : double * * ada ;

Ils e rait re m pli de la m aniè re s uivante : for (i=1 ; i
234

Exe rcice s e n langage C

D ans ce s conditions, e n e ffe t, la notation ada [i] [j] corre s pondrait (com pte te nu de l'associativité de gauch e à droite de l'opé rate ur []) à : (ada [i]) [j]

c'e s t-à -dire à : * (ada [i] + j)

Autre m e nt dit, ce tte notation ada [i] [j] désignerait sim plem e nt la val eur de l'é lém e nt situé à l'inte rs e ction de la ligne i e t de la colonne j de la m atrice a. O n note ra q ue pour q ue ce t artifice s oit utilisable au s e in d'une fonction com m e prod_m at, ce ns é e travailler sur des m atrices de taille q ue lconq ue , ile s t né ce s s aire q ue les e m place m e nts des tableaux de pointe urs te ls q ue ada soient alloué s dynam iq ue m e nt.

VIII-2 A rith m é tiq ue com pl e xe ________________________________________________________________________________________

Enoncé Ecrire deux fonctions calculant la som m e e t le produit de deux nom bre s com plexe s . Ces dernie rs s e ront re pré s e nté s par une s tructure com portant deux élém e nts de type double, corre s pondant à la partie ré e lle e t à la partie im aginaire . Ch acune de ce s fonctions com porte ra trois argum e nts : - l'adresse des deux nom bre s com plexe s (structure s ) conce rné s , - l'adresse du ré s ultat (structure ). Un program m e principalpe rm e ttra de te s te r ces deux fonctions ave c les valeurs com plexe s : 0,5 + i 1+ i

VIII. Analy s e num é riq u e

235

Exe m pl e 0.500000 + 1.000000 i et 1.000000 + 1.000000 i ont pour somme 1.500000 + 2.000000 i et pour produit -0.500000 + 1.500000 i ________________________________________________________________________________________

ANALYSE Soit deux nom bre s com plexe s : x = a + ib y = c + id O n sait q ue : x + y = (a+ c) + i (b+ d) e t q ue : x y = (ac - bd) + i (ad + bc)

Program m e typedef struct { double reel ; double imag ; } complexe ; main() { void somme (complexe *, complexe *, complexe *) ; void produit (complexe *, complexe *, complexe *) ; complexe z1, z2, s, p ; z1.reel = 0.5 ; z1.imag = 1.0 ; z2.reel = 1.0 ; z2.imag = 1.0 ; somme (&z1, &z2, &s) ; produit (&z1 ,&z2, &p) ; printf ("%lf + %lf i et %lf + %lf i \n",

236

Exe rcice s e n langage C z1.reel, z1.imag, z2.reel, z2.imag) ; printf ("ont pour somme %lf + %lf i \n", s.reel, s.imag) ; printf ("et pour produit %lf + %lf i \n", p.reel, p.imag) ;

} void somme (complexe * x, complexe * y, complexe * som) { som->reel = x->reel + y->reel ; som->imag = x->imag + y->imag ; } void produit (complexe * x, complexe * y, complexe * prod) { prod->reel = x->reel * y->reel - x->imag * y->imag ; prod->imag = x->reel * y->imag + x->imag * y->reel ; }

Com m e ntaire s *Nous avons défini, à un nive au global, un m odè le de structure nom m é com plexe . *Note z bie n q ue , dans le program m e principal, l'accè s à une s tructure s e fait par l'opé rate ur "." (com m e dans z1.re e l) car z1 désigne ici la val eur d'une s tructure ;par contre , dans les fonctions, ils e fait par l'opé rate ur -> (com m e dans x>re e l) car x dé s igne alors l 'adresse d'une s tructure . O n pe ut toute fois é vite r l'e m ploi de ce t opé rate ur, e n re m arq uant q ue x-> re e le s t é q uivalent à (*x).re e l. *En toute rigue ur, d'aprè s la norm e ANSI, ile s t possible de transm e ttre , e n argum e nt d'une fonction, la valeur d'une structure . Aussi, aurions-nous pu pré voir q ue som m e e t produit re çoive nt les valeurs des com plexe s s ur les q ue ls porte l'opé ration. En re vanch e , le ré s ultat devrait toujours ê tre transm is par valeur puis q ue déte rm iné par la fonction e llem ê m e . Par e xe m ple, la définition de som m e aurait pu ê tre : void somme (complexe x, complexe y, complexe * som) { prod->reel = x.reel + y.reel ; prod->imag = x.imag + y.imag ; }

VIII. Analy s e num é riq u e

237

D ISCUSSIO N D ans la pratiq ue , les fonctions som m e e t produit s e raie nt com pilée s s é paré m e nt des fonctions les utilisant. Pour ce faire , ile s t né ce s s aire q u'e lles disposent de la description de la structure com plexe . O n voit q u'on ris q ue alors d'ê tre am e né à décrire une m ê m e s tructure à diffé re nte s re pris e s . Ce rte s , ici la ch os e n'e s t pas bien grave , dans la m e s ure où ce tte définition e s t sim ple. D'une m aniè re gé né rale, toute fois, on a tout inté rê t à ré gler ce type de problèm e e n plaçant une fois pour toute s une te lle définition dans un fich ie r (d'e xte nsion h , par e xe m ple) q u'on incorpore par #include dans tous les program m e s e n ayant besoin.

VIII-3 Produit de m atrice s com pl e xe s ________________________________________________________________________________________

Enoncé Ecrire une fonction calculant le produit de deux m atrice s com plexe s . Ch aq ue m atrice s e ra dé finie com m e un tableau à deux dim e nsions dans leq ue lch aq ue é lém e nt s e ra une s tructure re pré s e ntant un nom bre com plexe ;ce tte s tructure s e ra constituée de deux é lém e nts de type double corre s pondant à la partie ré e lle e t à la partie im aginaire du nom bre . O n supposera q ue le pre m ie r indice du tableau re pré s e ntant une m atrice corre s pond à une ligne . O n pré voira e n argum e nts : - les adresses des deux m atrice s à m ultiplie r, - l'adresse de la m atrice produit, - le nom bre de ligne s e t de colonnes de la pre m iè re m atrice , - le nom bre de colonnes de la deuxiè m e m atrice (son nom bre de ligne s é tant obligatoire m e nt é galau nom bre de colonnes de la pre m iè re ). O n ré alisera un program m e principalpe rm e ttant de te s te r ce tte fonction. O n pourra é ve ntue llem e nt faire appe laux fonctions som m e e t produit ré alisées dans l'e xe rcice VIII-2 pour calculer la som m e e t le produit de deux nom bre s com plexe s .

Exe m pl e MATRICE A 0+ 0i

1+

2i

2+

4i

3+

6i

238

Exe rcice s e n langage C 1+ 2+ 3+ 4+

1i 2i 3i 4i

2+ 3+ 4+ 5+

3i 4i 5i 6i

3+ 4+ 5+ 6+

5i 6i 7i 8i

MATRICE B 0+ 0i 1+ 1i 2+ 2i 3+ 3i

1+ 2+ 3+ 4+

2i 3i 4i 5i

2+ 3+ 4+ 5+

4i 5i 6i 7i

PRODUIT A x B -14+ 42i -32+ 66i -14+ 54i -36+ 90i -14+ 66i -40+ 114i -14+ 78i -44+ 138i -14+ 90i -48+ 162i

-50+ -58+ -66+ -74+ -82+

90i 126i 162i 198i 234i

4+ 5+ 6+ 7+

7i 8i 9i 10i

________________________________________________________________________________________

ANALYSE Le s form ules de définition du produit de m atrice s com plexe s re s te nt ce lles proposées dans l'analyse de l'e xe rcice VIII-1 pour les m atrice s ré e lles ;ilsuffit d'y re m place r les opé rations + e t x portant sur des réels par les opé rations som m e e t produit de deux com plexe s (les rè gles de ces deux opé rations ont é té e xposées dans l'analyse de l'e xe rcice VIII-2).

Program m e

#define N 5 #define P 4 #define Q 3 typedef struct { double reel ; double imag ; } complexe ;

VIII. Analy s e num é riq u e main() { void prod_mat (complexe *, complexe *, complexe *, int, int, int) ; complexe a[N][P], b[P][Q], c[N][Q] ; int i, j ;

/* initialisation matrice a */ for (i=0 ; i
239

240

Exe rcice s e n langage C /* affichage produit */ printf (" PRODUIT A x B\n") ; for (i=0 ; i
} /*********************************************************/ /* fonction de calcul de produit de 2 matrices complexes */ /*********************************************************/ void prod_mat ( complexe * a, complexe * b, complexe * c, int n, int p, int q) { void produit() ; int i, j, k ; complexe s, pr ; complexe *aik, *bkj, *cij ; cij = c ; for (i=0 ; ireel = x->reel * y->reel - x->imag * y->imag ; prod->imag = x->reel * y->imag + x->imag * y->reel ; }

VIII. Analy s e num é riq u e

241

Com m e ntaire s La fonction prod_m at pe ut ê tre considérée com m e une adaptation de la fonction prod_m at de l'e xe rcice VIII-1. Ce tte fois, les sym boles aik , bk j e t cij désignent, non plus des pointe urs sur de s ré e ls, m ais des pointe urs sur une s tructure re pré s e ntant un nom bre com plexe . La souplesse du langage C e n m atiè re d'opérations arith m é tiq ue s s ur les pointe urs fait q ue les instructions d'incré m e ntation de ce s q uantité s re s te nt les m ê m e s (l'unité é tant ici la structure com plexe - soit 2 é lém e nts de type double, au lie u d'une valeur de type double).

D ISCUSSIO N Le s re m arq ue s faites dans l'e xe rcice VIII-2, à propos de la description de la structure com plexe re s te nt nature llem e nt valables ici.

VIII-4 Re ch e rch e de zé ro d'une fonction par dich otom ie ________________________________________________________________________________________

Enoncé Ecrire une fonction dé te rm inant, par dich otom ie , le zé ro d'une fonction q ue lconq ue (ré e lle d'une variable ré e lle e t continue ). O n supposera connu un inte rvalle [a,b] sur leq ue lla fonction ch ange de signe, c'est-à -dire te lq ue f(a).f(b) soit né gatif. O n pré voira e n argum e nts : - les valeurs des bornes a e t b (de type double) de l'inte rvalle de départ, - l'adresse d'une fonction pe rm e ttant de calculer la valeur de f pour une valeur q ue lconq ue de la variable. O n supposera q ue l'e n-tê te de ce tte fonction e s t de la form e : double fct (x) double x ;

242

Exe rcice s e n langage C

- l'adresse d'une variable de type double destiné e à re cue illir la valeur approch ée du zé ro de f, - la valeur de la pré cision (absolue ) souh aité e (de type double). Le code de re tour de la fonction s e ra de -1 lors q ue l'inte rvalle fourni e n argum e nt ne convie nt pas, c'e s t-à -dire : - soit lors q ue la condition a
Exe m pl e zéro de la fonction sin entre -1 et 1 à 1e-2 près = 0.000000e+000 zéro de la fonction sin entre -1 et 2 à 1e-2 près = 1.953125e-003 zéro de la fonction sin entre -1 et 2 à 1e-12 près = -2.273737e-013 ________________________________________________________________________________________

ANALYSE La dém arch e consiste donc, aprè s avoir vé rifié q ue l'inte rvalle re çu e n argum e nt é tait conve nable, à ré pé te r le traite m e nt suivant : - pre ndre le m ilie u m de [a,b] : m = (a+ b)/2 - calculer f(m ), - si f(m ) = 0, le zé ro e s t e n m , - si f(a).f(m )< 0, ile xiste un zé ro sur [a,m ] ;on re m place donc l'inte rvalle [a,b] par [a,m ] e n faisant : b=m - si f(a).f(m )> 0, ile xiste un zé ro sur [b,m ] ;on re m place donc l'inte rvalle [a,b] par [b,m ], e n faisant : a=m Le traite m e nt e s t inte rrom pu soit lors q ue l'inte rvalle [a,b] aura é té s uffisam m e nt réduit, c'e s t-à -dire lors q ue |b-a| est infé rie ur à la pré cision souh aité e , soit lors q ue le zé ro a é té localisé exacte m e nt (f(m )=0).

VIII. Analy s e num é riq u e

Program m e #include #include /* pour la fonction sin */ main() { /* fonction de recherche d'un zéro par dichotomie */ int dichoto ( double (*(double)(), double, double, double *, double) ; double z, /* zéro recherché */ a, b, /* bornes de l'intervalle de recherche */ eps ; /* précision souhaitée */ dichoto (sin, -1.0, 1.0, &z, 1.0e-2) ; printf ("zéro de la fonction sin entre -1 et 1 à 1e-2 près = %le\n",z); dichoto (sin, -1.0, 2.0, &z, 1.0e-2) ; printf ("zéro de la fonction sin entre -1 et 2 à 1e-2 près = %le\n",z); dichoto (sin, -1.0, 2.0, &z, 1.0e-12) ; printf ("zéro de la fonction sin entre -1 et 2 à 1e-12 près = %le\n",z); } /*************************************************************/ /* fonction de recherhce dichotomique du zéro d'une fonction */ /*************************************************************/ int dichoto ( double (* f)(double), double a, double b, double * zero, double eps) /* /* /* /*

f : fonction dont on cherche le zéro */ a, b : bornes de l'intervalle de recherche */ zero : zéro estimé */ eps : précision souhaitée) */

{ double m, fm, fa, fb ;

/* milieu de l'intervalle courant */ /* valeur de f(m) */ /* valeurs de f(a) et de f(b) */

fa = (*f)(a) ; fb = (*f)(b) ; if (fa*fb >= 0 || a >= b) return (-1) ;

while (b-a > eps) { m = (b+a) / 2.0 ;

/* intervalle incorrect */

243

244

Exe rcice s e n langage C fm = (*f)(m) ; if (fm == 0) break ; if (fa*fm < 0) { b fb } else { a fa }

/* zéro atteint */ = m ; = fm ; = m ; = fm ;

} * zero = m ; return (0) ; }

Com m e ntaire s *Note z, dans la fonction dich oto : - la déclaration de l'argum e nt corre s pondant à l'adresse de la fonction dont on ch e rch e le zé ro : double (*f)(double) Ce lle-ci s'inte rprè te com m e s uit : (*f) e s t une fonction re ce vant un argum e nt de type double e t fournissant un ré s ultat de type double, *f e s t donc une fonction re ce vant un argum e nt de type double e t fournissant un ré s ultat de type double, f e s t donc un pointe ur sur une fonction re ce vant un argum e nt de type double e t fournissant un ré s ultat de type double. - l'utilisation du sym bole f ;ainsi (*f)(a) re pré s e nte la valeur de la fonction (*f) (fonction d'adre s s e f), à laq ue lle on fournit l'argum e nt a. Le s m ê m e s ré flexions s'appliq ue nt au prototype s e rvant à déclare r dich oto. *La fonction dich oto re ce vant e n argum e nt les val eurs des argum e nts a e t b (et non de s adresses), nous pouvons nous pe rm e ttre de les m odifie r au s e in de la fonction, sans q ue ce la ait d'incide nce s ur les valeurs e ffe ctives des borne s définies dans le program m e principal. *Voye z com m e nt, dans le program m e principal, un sym bole com m e sin e s t inte rpré té par le com pilate ur com m e l'adresse d'une fonction prédéfinie ;ile s t toute fois néce s s aire d'avoir incorporé s on prototype (situé dans m ath .h ) ;e n

VIII. Analy s e num é riq u e

245

l'abs e nce de l'instruction #include corre s pondante , le com pilate ur dé te cte rait un e rre ur puis q ue alors le sym bole sin ne s e rait pas défini.

D ISCUSSIO N En th é orie , la m é th ode de dich otom ie conduit toujours à une s olution, ave c une pré cision aussi grande q u'on le désire , à partir du m om e nt où la fonction ch ange e ffe ctive m e nt de signe sur l'inte rvalle de départ. En pratiq ue , toute fois, les ch os e s ne s ont pas toujours aussi idylliq ue s , com pte te nu de la lim itation de la pré cision des calculs. Tout d'abord, si on im pos e une pré cision trop faible par rapport à la pré cision de l'ordinate ur, on pe ut aboutir à ce q ue : m = (a+b)/2

soit é galà l'une des deux bornes a ou b. Ile s t alors facile de m ontre r q ue l'algorith m e pe ut boucler indé finim e nt. D 'autre part, les valeurs de f(a) e t de f(b) sont né ce s s aire m e nt é valué e s d e m aniè re approch é e . Dans le cas de form ules q ue lque pe u com plexe s , on pe ut trè s bien aboutir à une s ituation dans laq ue lle f(a).f(b) e s t positif. La pre m iè re s ituation e s t as s e z facile à é vite r : ilsuffit de ch oisir une pré cision re lative (atte ntion, ici, notre fonction travaille ave c une pré cision absolue ) infé rie ure à ce lle de l'ordinate ur. Iln'e n va pas de m ê m e pour la s e conde dans la m e s ure où iln'e s t pas toujours possible de m aî tris e r la pré cision des calculs des valeurs de f.