ESTIA - Unit´ e d’enseignement en Informatique 1
reAnn´ ee
·2016/2017
Programmation Proc´ edurale en Langage C – TD4 Pointeurs : chaˆınes de caract` eres, tableaux, vecteurs et matrices
Exercice 1 : Comparaison de chaˆınes de caract` eres 1) Que font ces deux programmes ?
1 /* V E R S I O N 1 */
2 # i n c l u d e < s t d i o . h >
3
4 # d e f i n e M A X L E N 20 5
6 int m a i n () {
7 c h a r m o t 1 [ M A X L E N ] ; 8 c h a r m o t 2 [ M A X L E N ] ; 9
10 p r i n t f ( " D o n n e z un mot : " ) ; 11 s c a n f ( " % s " , m o t 1 ) ;
12
13 p r i n t f ( " D o n n e z un mot : " ) ; 14 s c a n f ( " % s " , m o t 2 ) ;
15
16 if ( m o t 1 == m o t 2 )
17 p r i n t f ( " Ces d e u x m o t s s o n t e g a u x \ n " ) ; 18 e l s e
19 p r i n t f ( " Ces d e u x m o t s s o n t d i f f e r e n t s \ n " ) ; 20
21 r e t u r n 0 ; 22 }
1 /* V E R S I O N 2 */
2 # i n c l u d e < s t d i o . h >
3 # i n c l u d e < s t r i n g . h > /* s t r c m p () */
4
5 # d e f i n e M A X L E N 20 6
7 int m a i n () {
8 c h a r m o t 1 [ M A X L E N ] ; 9 c h a r m o t 2 [ M A X L E N ] ; 10
11 p r i n t f ( " D o n n e z un mot : " ) ; 12 s c a n f ( " % s " , m o t 1 ) ;
13
14 p r i n t f ( " D o n n e z un mot : " ) ; 15 s c a n f ( " % s " , m o t 2 ) ;
16
17 if (! s t r c m p ( mot1 , m o t 2 ) )
18 p r i n t f ( " Ces d e u x m o t s s o n t e g a u x \ n " ) ; 19 e l s e
20 p r i n t f ( " Ces d e u x m o t s s o n t d i f f e r e n t s \ n " ) ; 21
22 r e t u r n 0 ; 23 }
2) Ces programmes sont-ils ´ equivalents ? Que fait la fonction strcmp() ? (Regardez partie 10 du cours. . .) 3) Combien de comparaisons sont effectivement r´ ealis´ ees, lors de l’ex´ ecution, ` a la ligne 16 de la version 1 ? ` a la ligne 17 de la version 2 ?
4) Pourquoi mettre un ! devant strcmp() ?
Exercice 2 : Allocation m´ emoire
Pour les besoins d’un programme, il est souhait´ e une fonction qui alloue dynamiquement de la m´ emoire pour un tableau de N valeurs initialis´ ees avec la valeur val. Ci-dessous, deux versions de la fonction creer tableau() implantent ce m´ ecanisme.
3 /* V E R S I O N 1 *
4 * F o n c t i o n q u i c r e e un t a b l e a u de * 5 * t a i l l e s i z e et le r e m p l i a v e c v a l */
6 int * c r e e r _ t a b l e a u ( int size , int val ) { 7 int i , res [ s i z e ] ;
8
9 /* I n i t i a l i s e r le t a b l e a u */
10 for ( i =0 ; i < s i z e ; i ++)
11 res [ i ] = val ;
12
13 r e t u r n res ; 14 }
4 /* V E R S I O N 2 *
5 * F o n c t i o n q u i c r e e un t a b l e a u de t a i l l e * 6 * s i z e et le r e m p l i a v e c v a l . Le t a b l e a u * 7 * c r e e d e v r a e t r e l i b e r e a v e c f r e e () */
8 int * c r e e r _ t a b l e a u ( int size , int val ) {
9 int i , * res ;
10
11 /* A l l o c a t i o n de m e m o i r e p o u r le t a b l e a u */
12 res = m a l l o c ( s i z e * s i z e o f ( int ) ) ; 13 if ( res == N U L L ) {
14 f p r i n t f ( stderr , " E r r o r : m e m o r y a l l o c a t i o n \ n " ) ;
15 e x i t (1) ;
16 }
17
18 /* I n i t i a l i s e r le t a b l e a u */
19 for ( i =0 ; i < s i z e ; i ++)
20 res [ i ] = val ;
21
22 r e t u r n res ; 23 }
1) En quoi ces fonctions sont-elles diff´ erentes ?
2) La compilation de la version 1 de la fonction ´ emet un ”warning ”. Selon vous, pourquoi ? 3) Quel comportement anormal peut produire l’utilisation de la version 1 ?
Guillaume Rivi`ere
– 1 –
ESTIA - Unit´ e d’enseignement en Informatique 1
reAnn´ ee
·2016/2017
Voici un exemple de programme utilisant la fonction creer tableau(), ainsi que des exemples d’ex´ ecutions :
25 int m a i n () {
26 int * tab , N , i ;
27
28 p r i n t f ( " C o m b i e n de v a l e u r s : " ) ; 29 s c a n f ( " % d " , & N ) ;
30
31 tab = c r e e r _ t a b l e a u ( N , 0) ; 32
33 /* A f f i c h e r le t a b l e a u */
34 for ( i =0 ; i < N ; i ++) 35 p r i n t f ( " % d " , tab [ i ]) ; 36 p r i n t f ( " \ n " ) ;
37 38 39
40 r e t u r n 0 ; 41 }
Avec la version 1 Avec la version 2
4) Comment expliquer les affichages produits par le programme lors de l’utilisation de la version 1 de creer tableau() ? 5) Quel appel manque-t-il ` a la ligne 38 du programme pour une utilisation correcte de la version 2 de creer tableau() ?
Exercice 3 : Parcours de matrices
En C, une matrice est un tableau de tableaux (ou donc un pointeur vers un tableau de pointeurs). Comme pour les tableaux, il est possible de cr´ eer une matrice de mani` ere ”en dur”, i.e. allou´ e ` a la compilation. Par exemple, pour une matrice de taille N×M :
int mat[N][M] ;
Le programme, incomplet, ci-dessous proc` ede ` a l’affichage d’une matrice carr´ e. Compl´ etez ce programme pour initialiser la matrice de mani` ere ` a obtenir l’affichage ci-dessous.
1 # i n c l u d e < s t d i o . h >
2
3 int m a i n () {
4 int i , j ;
5 int m [ 5 ] [ 5 ] ; 6
7 /* I n i t i a l i s e r l e s v a l e u r s de la m a t r i c e */
8 9 10 11 12 13 14 15 16 17 18
19 /* A f f i c h a g e de la m a t r i c e */
20 for ( i =0 ; i <5 ; i ++) {
21 for ( j =0 ; j <5 ; j ++)
22 p r i n t f ( " %2 d " , m [ i ][ j ]) ; 23 p r i n t f ( " \ n " ) ;
24 }
25
26 r e t u r n 0 ; 27 }
Guillaume Rivi`ere
– 2 –
ESTIA - Unit´ e d’enseignement en Informatique 1
reAnn´ ee
·2016/2017
Exercice 4 : Le module Matrice (avec une petite couche de g´ enie logiciel. . .)
Nous souhaitons ´ ecrire un paquetage de manipulation de matrices de r´ eels. Pour ce faire, le type structur´ e sera le suivant :
typedef struct matrice { int n, m ;
int **mat ; } *matrice ;
A titre d’exemple, voici un paquetage de manipulation de ` vecteurs de r´ eels :
4 # i f n d e f _ _ V E C T E U R _ H 5 # d e f i n e _ _ V E C T E U R _ H 6
7 /* S t r u c t u r e de d o n n e e */
8 t y p e d e f s t r u c t v e c t e u r {
9 int s i z e ;
10 f l o a t * tab ; 11 } * v e c t e u r ; 12
13 /* C r e a t i o n / D e s t r u c t i o n */
14 v e c t e u r v e c t e u r _ c r e e r ( int N ) ;
15 v o i d v e c t e u r _ d e t r u i r e ( v e c t e u r v ) ; 16
17 /* A c c e s a la s t r u c t u r e */
18 f l o a t v e c t e u r _ g e t _ v a l ( v e c t e u r v , int i ) ;
19 v o i d v e c t e u r _ s e t _ v a l ( v e c t e u r v , int i , f l o a t val ) ; 20 int v e c t e u r _ t a i l l e ( v e c t e u r v ) ;
21
22 /* F o n c t i o n s de m a n i p u l a t i o n */
23 v o i d v e c t e u r _ r e m p l i r ( v e c t e u r v , f l o a t val ) ; 24 v o i d v e c t e u r _ a f f i c h e r ( v e c t e u r v ) ;
25 v o i d v e c t e u r _ c o p i e r ( v e c t e u r dst , v e c t e u r src ) ; 26 v e c t e u r v e c t e u r _ d u p l i q u e r ( v e c t e u r v ) ;
27 v o i d v e c t e u r _ s c a l a i r e ( v e c t e u r v , f l o a t k ) ; 28 f l o a t v e c t e u r _ s o m m e ( v e c t e u r v ) ;
29 c h a r v e c t e u r _ e g a l ( v e c t e u r v1 , v e c t e u r v2 ) ; 30 v o i d v e c t e u r _ a d d i t i o n ( v e c t e u r dst ,
31 v e c t e u r src1 ,
32 v e c t e u r s r c 2 ) ;
33 f l o a t v e c t e u r _ p r o d u i t _ s c a l a i r e ( v e c t e u r v1 ,
34 v e c t e u r v2 ) ;
35
36 # e n d i f /* _ _ V E C T E U R _ H */
4 # i n c l u d e < s t d i o . h >
5 # i n c l u d e < s t d l i b . h >
6 # i n c l u d e < a s s e r t . h >
7 # i n c l u d e " v e c t e u r . h "
8
9 v e c t e u r v e c t e u r _ c r e e r ( int N ) { 10 v e c t e u r res ;
11
12 /* A l l o c a t i o n de la s t r u c t u r e */
13 res = m a l l o c ( s i z e o f ( s t r u c t v e c t e u r ) ) ; 14 a s s e r t ( res != N U L L ) ;
15
16 /* A l l o c a t o n du t a b l e a u */
17 res - > s i z e = N ;
18 res - > tab = m a l l o c ( N * s i z e o f ( f l o a t ) ) ; 19 a s s e r t ( res - > tab != N U L L ) ;
20
21 r e t u r n res ; 22 }
23
24 v o i d v e c t e u r _ d e t r u i r e ( v e c t e u r v ) { 25 /* L i b e r e r le t a b l e a u */
26 f r e e ( v - > tab ) ;
27 /* L i b e r e r la s t r u c t u r e */
28 f r e e ( v ) ; 29 }
30
31 f l o a t v e c t e u r _ g e t _ v a l ( v e c t e u r v , int i ) { 32 r e t u r n v - > tab [ i ] ;
33 } 34
35 v o i d v e c t e u r _ s e t _ v a l ( v e c t e u r v , int i ,
36 f l o a t val ) {
37 v - > tab [ i ] = val ; 38 }
39
40 int v e c t e u r _ t a i l l e ( v e c t e u r v ) { 41 r e t u r n v - > s i z e ;
42 }
Construction de la structure de donn´ ee dans la fonction vecteur creer() dans vecteur.c : (exemple avec N valant 5)
ligne 10 :
ligne 13 :
ligne 18 :
Guillaume Rivi`ere
– 3 –
ESTIA - Unit´ e d’enseignement en Informatique 1
reAnn´ ee
·2016/2017
Suite du fichier vecteur.c :
43
44 v o i d v e c t e u r _ r e m p l i r ( v e c t e u r v , f l o a t val ) {
45 int i ;
46 for ( i =0 ; i < v - > s i z e ; i ++) 47 v - > tab [ i ] = val ;
48 } 49
50 v o i d v e c t e u r _ a f f i c h e r ( v e c t e u r v ) {
51 int i ;
52 for ( i =0 ; i < v - > s i z e ; i ++) 53 p r i n t f ( " % 5 . 2 f " , v - > tab [ i ]) ; 54 p r i n t f ( " \ n " ) ;
55 } 56
57 v o i d v e c t e u r _ c o p i e r ( v e c t e u r dst , v e c t e u r src ) {
58 int i ;
59 a s s e r t ( dst - > s i z e == src - > s i z e ) ; 60 for ( i =0 ; i < dst - > s i z e ; i ++) 61 dst - > tab [ i ] = src - > tab [ i ] ; 62 }
63
64 v e c t e u r v e c t e u r _ d u p l i q u e r ( v e c t e u r v ) {
65 int i ;
66 v e c t e u r res = v e c t e u r _ c r e e r ( v - > s i z e ) ; 67 for ( i =0 ; i < v - > s i z e ; i ++)
68 res - > tab [ i ] = v - > tab [ i ] ; 69 r e t u r n res ;
70 } 71
72 v o i d v e c t e u r _ s c a l a i r e ( v e c t e u r v , f l o a t k ) {
73 int i ;
74 for ( i =0 ; i < v - > s i z e ; i ++) 75 v - > tab [ i ] *= k ;
76 } 77
78 f l o a t v e c t e u r _ s o m m e ( v e c t e u r v ) {
79 int i ;
80 f l o a t sum = 0. ;
81 for ( i =0 ; i < v - > s i z e ; i ++) 82 sum += v - > tab [ i ];
83 r e t u r n sum ; 84 }
85
86 c h a r v e c t e u r _ e g a l ( v e c t e u r v1 , v e c t e u r v2 ) {
87 int i ;
88 c h a r e g a u x = ( v1 - > s i z e == v2 - > s i z e ) ; 89 for ( i =0 ; i < v1 - > s i z e && e g a u x ; i ++) { 90 if ( v1 - > tab [ i ] != v2 - > tab [ i ])
91 e g a u x = 0 ;
92 }
93 r e t u r n e g a u x ; 94 }
95
96 v o i d v e c t e u r _ a d d i t i o n ( v e c t e u r dst , v e c t e u r src1 ,
97 v e c t e u r s r c 2 ) {
98 int i ;
99 a s s e r t ( dst - > s i z e == src1 - > s i z e 100 && dst - > s i z e == src2 - > s i z e ) ; 101 for ( i =0 ; i < dst - > s i z e ; i ++)
102 dst - > tab [ i ] = src1 - > tab [ i ] + src2 - > tab [ i ] ; 103 }
104
105 f l o a t v e c t e u r _ p r o d u i t _ s c a l a i r e ( v e c t e u r v1 ,
106 v e c t e u r v2 ) {
107 int i ;
108 f l o a t res = 0. ;
109 a s s e r t ( v1 - > s i z e == v2 - > s i z e ) ; 110 for ( i =0 ; i < v1 - > s i z e ; i ++) 111 res += v1 - > tab [ i ] * v2 - > tab [ i ] ; 112 r e t u r n res ;
113 }
Le fichier interface du module Matrice sera :
4 # i f n d e f _ _ M A T R I C E _ H 5 # d e f i n e _ _ M A T R I C E _ H 6
7 /* S t r u c t u r e de d o n n e e */
8 t y p e d e f s t r u c t m a t r i c e {
9 int n , m ;
10 f l o a t ** mat ; 11 } * m a t r i c e ; 12
13 /* C r e a t i o n / D e s t r u c t i o n */
14 m a t r i c e m a t r i c e _ c r e e r ( int N , int M ) ; 15 v o i d m a t r i c e _ d e t r u i r e ( m a t r i c e T ) ; 16
17 /* A c c e s a la s t r u c t u r e */
18 f l o a t m a t r i c e _ g e t _ v a l ( m a t r i c e T , int i , int j ) ; 19 v o i d m a t r i c e _ s e t _ v a l ( m a t r i c e T , int i , int j ,
20 f l o a t val ) ;
21 int m a t r i c e _ l i g n e s ( m a t r i c e T ) ; 22 int m a t r i c e _ c o l o n n e s ( m a t r i c e T ) ; 23
24 /* F o n c t i o n s de m a n i p u l a t i o n */
25 v o i d m a t r i c e _ r e m p l i r ( m a t r i c e T , f l o a t val ) ; 26 v o i d m a t r i c e _ a f f i c h e r ( m a t r i c e T ) ;
27 v o i d m a t r i c e _ c o p i e r ( m a t r i c e dst , m a t r i c e src ) ; 28 m a t r i c e m a t r i c e _ d u p l i q u e r ( m a t r i c e T ) ;
29 v o i d m a t r i c e _ s c a l a i r e ( m a t r i c e T , f l o a t k ) ; 30 c h a r m a t r i c e _ e g a l ( m a t r i c e T1 , m a t r i c e T2 ) ; 31 v o i d m a t r i c e _ a d d i t i o n ( m a t r i c e C , m a t r i c e A ,
32 m a t r i c e B ) ;
33 v o i d m a t r i c e _ p r o d u i t ( m a t r i c e C , m a t r i c e A ,
34 m a t r i c e B ) ;
35 # e n d i f /* _ _ M A T R I C E _ H */
Et le d´ ebut du fichier implantation sera :
9 m a t r i c e m a t r i c e _ c r e e r ( int N , int M ) {
10 int i ;
11 m a t r i c e res ; 12
13 /* A l l o c a t i o n de la s t r u c t u r e */
14 res = m a l l o c ( s i z e o f ( s t r u c t m a t r i c e ) ) ; 15 a s s e r t ( res != N U L L ) ;
16
17 res - > n = N ; 18 res - > m = M ; 19
20 /* A l l o c a t o n du p r e m i e r t a b l e a u */
21 res - > mat = m a l l o c ( N * s i z e o f ( f l o a t *) ) ; 22 a s s e r t ( res - > mat != N U L L ) ;
23
24 /* A l l o c a t o n d e s t a b l e a u x de v a l e u r s */
25 for ( i =0 ; i < N ; i ++) {
26 res - > mat [ i ] = m a l l o c ( M * s i z e o f ( f l o a t ) ) ; 27 a s s e r t ( res - > mat != N U L L ) ;
28 }
29 r e t u r n res ; 30 }
31
32 v o i d m a t r i c e _ d e t r u i r e ( m a t r i c e T ) {
33 int i ;
34
35 /* L i b e r e r l e s t a b l e a u x de v a l e u r s */
36 for ( i =0 ; i < T - > n ; i ++) 37 f r e e ( T - > mat [ i ]) ; 38
39 /* L i b e r e r le p r e m i e r t a b l e a u */
40 f r e e ( T - > mat ) ; 41
42 /* L i b e r e r la s t r u c t u r e */
43 f r e e ( T ) ; 44 }
Guillaume Rivi`ere
