Manipulation de matrices.

Version imprimable

Hello les gens!
Je viens quemander de l'aide afin de me sortir de ce programme qui me prend la tete.
But de l'exericice: creer un programme qui manipule des matrices. Je vous poste ici la partie principale qui s'occupe de l'allocation de la memoire, de lire un fichier contenant une matrice sous la forme
2 3 //nbre de lignes et de colonnes
1 2 3
4 5 6
D'ecrire dans le meme fichier...
Le probleme vient de l'allocation (quelques warnings a la compilation avec gcc mais rien vis a vis de l'alloc), et j'ai le droit a un beaux segfault! :D
Bref, je remercie quiconque tentera de jeter un oeil au programme et me permettra de corriger mon erreur.

Voila le source:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
int **matrix;
int nb_lignes;
int nb_colonnes;
} matrix;
 
void write_matrix(FILE *p,matrix *m) {
int i;
int j;
if (p==NULL) return; //ouverture du fichier matrice.txt impossible
fprintf(p,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes);
for (i=0; i<m->nb_lignes; i++) {
for (j=0; j<m->nb_colonnes; j++) {
fprintf(p,"%i%s",m->matrix[j]," ");
}
fprintf(p,"\n");
}
}
 
matrix * read_matrix(FILE *p) {
int i,j;
matrix *m;
m=(matrix *)malloc(sizeof(matrix));
if (p==NULL) return; //ouverture en lecture impossible
fscanf(p,"%i%i",&m->nb_lignes,&m->nb_colonnes);
m->matrix=(int**)calloc(m->nb_lignes,sizeof(int**));
for (i=0; i<m->nb_lignes; i++) {
m->matrix=(int*)calloc(m->nb_colonnes,sizeof(int*));
}
for (i=0; i<m->nb_lignes; i++) {
for (j=0; j<m->nb_colonnes; j++) {
fscanf(p,"%i",&m->matrix[j]);
printf("%i%s",m->matrix[j]," ");
}
printf("\n");
}
return &m;
}
 
void affic_matrix(matrix *m) {
int i,j;
printf("Matrice de taille : %i * %i\n",m->nb_lignes,m->nb_colonnes);
for (i=0; i<m->nb_lignes; i++) {
for (j=0; i<m->nb_colonnes; j++){
printf("%i%s",m->matrix[j]," ");
}
printf("\n");
}
}
 
 
matrix * allouer_matrice(int nbli, int nbcol) {
matrix *m;
int i;
m->nb_lignes=nbli;
m->nb_colonnes=nbcol;
m->matrix=(int**)calloc(nbli,sizeof(int**));
for (i=0; i<nbcol; i++) {
m->matrix=(int*)calloc(nbcol,sizeof(int*));
}
return &m;
}
 
void remplir_matrice(matrix *m){
int i,j;
printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes);
for(i=0;i<m->nb_lignes;i++){
for(j=0;j<m->nb_colonnes;j++){
printf("element (%d,%d)?",i,j);
scanf("%i",&(m->matrix[j]));
}
}
}
 
int main() {
matrix * m;
int i, nbli, nbcol;
FILE *fic;
fic=fopen("matrix.txt","w");
if (fic!=NULL){
printf("Nombre de lignes : ");
scanf("%i",&nbli);
printf("Nombre de colonnes : ");
scanf("%i",&nbcol);
printf("huhu\n");
m=allouer_matrice(nbli, nbcol);
//remplir_matrice(m);
//printf("%i %i %i\n",m->nb_lignes, m->nb_colonnes, m->matrix[1][1]);
//write_matrix(fic,m);
//m=read_matrix(fic);
//affic_matrix(m);
}
}

Salut

Au moins une erreur ici

Code:

1
2
3
4
5
6
7
8
9
10
11
matrix * allouer_matrice(int nbli, int nbcol) {
matrix *m;
int i;
m->nb_lignes=nbli; // seg fault, m est un pointeur non initialisé.
m->nb_colonnes=nbcol;
m->matrix=(int**)calloc(nbli,sizeof(int**));
for (i=0; i<nbcol; i++) {
m->matrix=(int*)calloc(nbcol,sizeof(int*));
}
return &m;
}

Je viens de voir ça aussi

Code:

1
2
3
4
5
typedef struct {
int **matrix; // pour chercher (et trouver) les ennuis, y'a pas mieux que cette réutilisation du même nom matrix
int nb_lignes;
int nb_colonnes;
} matrix;

Citation:
Envoyé par Trap D
Salut

Au moins une erreur ici
Code:

1 2 3 4 5 6 7 8 9 10 11 matrix * allouer_matrice(int nbli, int nbcol) { matrix *m; int i; m->nb_lignes=nbli; // seg fault, m est un pointeur non initialisé. m->nb_colonnes=nbcol; m->matrix=(int**)calloc(nbli,sizeof(int**)); for (i=0; i<nbcol; i++) { m->matrix=(int*)calloc(nbcol,sizeof(int*)); } return &m; }
A l'aide de printf judicieusement places j'avais vu que le probleme venait de la aussi... Malheureusement je ne comprends pas l'erreur. :/
Citation:
Envoyé par Trap D
Je viens de voir ça aussi
Code:

1 2 3 4 5 typedef struct { int **matrix; // pour chercher (et trouver) les ennuis, y'a pas mieux que cette réutilisation du même nom matrix int nb_lignes; int nb_colonnes; } matrix;
Yep, je note ca, et je le modifie.

Merci de ton aide. ;)

ton pointeur m n'est pas initialisé, celà veut dire en fait qu'il pointe vers n'importe quoi.
Tu dois faire d'abord

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
matrix * allouer_matrice(int nbli, int nbcol) {
matrix *m = malloc(sizeof(*m));
int i;
if (m != NULL)
{
  m->nb_lignes=nbli; // seg fault, m est un pointeur non initialisé.
  m->nb_colonnes=nbcol;
  m->matrix=(int**)calloc(nbli,sizeof(int**));
  if (m->matrix != NULL)
  {
    for (i=0; i<nbcol; i++) 
   {
      m->matrix=(int*)calloc(nbcol,sizeof(int*));
   }
  }
}
return m; // erreur ici, le compilateur aurait du la signaler
}

02/11/2005, 14h08
TeKa

Merci beaucoup! ;)
02/11/2005, 15h03
Trap D

Attention quand même, la gestion des erreurs de malloc (retour NULL) n'est pas faite.
Il y a encore beaucoup à faire pour avoir un code solide.
03/11/2005, 00h58
David.Schris

Citation:

Envoyé par Trap D

Il y a encore beaucoup à faire pour avoir un code solide.

Et lisible !

Ca peut aider d'indenter...(enfin, c'est peut-être seulement sur le forum)

Citation:

Envoyé par TeKa

quelques warnings a la compilation avec gcc mais rien vis a vis de l'alloc

1) il ne devrait pas y avoir de warning si le code est correct
2) essaye avec ces options

Code:

gcc -Wall -Wimplicit -Wreturn-type -Wunused -Wswitch -Wcomment -Wuninitialized -Wparentheses -Wtraditional -Wshadow -Wpointer-arith -Wmissing-prototypes -o reloaded matrix.c

Et avant que la question ne soit posée : non, -Wall n'affiche pas tous les avertissements (avec gcc).
03/11/2005, 02h35
Médinoc

... Ce qui est stupide pour une option avec un nom pareil

Et avec -Wall -Wextra sur un GCC récent? il les affiche tous?
03/11/2005, 08h37
Emmanuel Delahaye

Citation:

Envoyé par Médinoc

Et avec -Wall -Wextra sur un GCC récent? il les affiche tous?

Presque, dont certains qui me gènent, comme

Code:

int x[10] = {0};

Citation:

"Missing initializers".

Citation:

Envoyé par David.Schris

Citation:

Envoyé par Trap D

Il y a encore beaucoup à faire pour avoir un code solide.

Et lisible !

Ca peut aider d'indenter...(enfin, c'est peut-être seulement sur le forum)

Citation:

Envoyé par TeKa

quelques warnings a la compilation avec gcc mais rien vis a vis de l'alloc

1) il ne devrait pas y avoir de warning si le code est correct
2) essaye avec ces options

Code:

gcc -Wall -Wimplicit -Wreturn-type -Wunused -Wswitch -Wcomment -Wuninitialized -Wparentheses -Wtraditional -Wshadow -Wpointer-arith -Wmissing-prototypes -o reloaded matrix.c

Et avant que la question ne soit posée : non, -Wall n'affiche pas tous les avertissements (avec gcc).

J'indentes, mais sur le copier coller a tout casse... :/
J'apprends quelque chose pour -Wall, mais je n'arrive pas a virer tous le warnings (je n'avais jamais fait de C avant la rentree, donc il me faut le temps encore de tout bien apprendre a analyser)

Je vous reposte ici mon programme quelque peu modifie: j'ai reussi a allouer ma matrice sans probleme, je peux ecrire dans mon fichier matrice.txt. Malheureusement, je n'arrive pas a creer une matrice avec les elements du fichier matrix.txt
Je rappelle que le fichier matrix.txt a cette forme:
3 4
1 2 3 4
5 6 7 8
9 0 1 2

Voila le code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 #include <stdio.h> #include <stdlib.h> typedef struct { int **element; int nb_lignes; int nb_colonnes; } matrix; void write_matrix(FILE *p,matrix *m) { int i; int j; if (p==NULL) return; //ouverture du fichier matrice.txt impossible fprintf(p,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes); for (i=0; i<m->nb_lignes; i++) { for (j=0; j<m->nb_colonnes; j++) { fprintf(p,"%i%s",m->element[i][j]," "); } fprintf(p,"\n"); } } matrix * read_matrix(FILE *p) { int i,j; matrix *m; m=(matrix *)malloc(sizeof(matrix)); printf("haha\n"); if (p==NULL) return; //ouverture en lecture impossible fscanf(p,"%i%i",&m->nb_lignes,&m->nb_colonnes); printf("%i\n",m->nb_lignes); printf("%i\n",m->nb_colonnes); m=allouer_matrice(m->nb_lignes,m->nb_colonnes); printf("hehe\n"); for (i=0; i<m->nb_lignes; i++) { for (j=0; j<m->nb_colonnes; j++) { fscanf(p,"%i",m->element[i][j]); } } printf("%i %i %i\n", m->nb_lignes, m->nb_colonnes, m->element[1][1]); return m; } void affic_matrix(matrix *m) { int i,j; printf("Matrice de taille : %i * %i\n",m->nb_lignes,m->nb_colonnes); for (i=0; i<m->nb_lignes; i++) { for (j=0; i<m->nb_colonnes; j++){ printf("%i%s",m->element[i][j]," "); } printf("\n"); } } matrix * allouer_matrice(int nbli, int nbcol) { matrix *m; int i; m=(matrix *)malloc(sizeof(matrix)); m->element=(int**)calloc(nbli,sizeof(int**)); for (i=0; i<nbcol; i++) { m->element[i]=(int*)calloc(nbcol,sizeof(int*)); } return m; } void remplir_matrice(matrix *m){ int i,j; printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes); for(i=0;i<m->nb_lignes;i++){ for(j=0;j<m->nb_colonnes;j++){ printf("element (%d,%d)?",i,j); scanf("%i",&(m->element[i][j])); } } } int main() { matrix * m1; FILE *fic; m1=(matrix *)malloc(sizeof(matrix)); fic=fopen("matrix.txt","r"); if (fic!=NULL){ //printf("Nombre de lignes : "); //scanf("%i",&m1->nb_lignes); //printf("%i\n",m1->nb_lignes); //printf("Nombre de colonnes : "); //scanf("%i",&m1->nb_colonnes); //printf("%i\n",m1->nb_colonnes); //m1=allouer_matrice(m1->nb_lignes, m1->nb_colonnes); //printf("%i\n",m1->nb_lignes); //remplir_matrice(m1); printf("huhu\n"); m1=read_matrix(fic); printf("hoho\n"); printf("%i %i %i\n",m1->nb_lignes, m1->nb_colonnes, m1->element[1][1]); //write_matrix(fic,m1); //m=read_matrix(fic); //affic_matrix(m); return 0; } }
Encore merci pour votre aide. ;)
Vous inquietez pas si je met pleins de printf() plus ou moins bidons, mais il n'y a que comme ca que je vois mes erreurs.

Citation:

Envoyé par TeKa

J'indentes, mais sur le copier coller a tout casse... :/

Si tu utilises les balises code, aucun problème. La preuve...

Citation:

Code:

<...>

Des corrections et des remarques...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
/* -ed-
   - reindentation
   - ajoute 'static' aux fonctions privees.
   - modifie' implantation pour respecter le principe :
 
   definir avant d'utiliser"
 
 */
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
   int **element;
   int nb_lignes;
   int nb_colonnes;
}
matrix;
 
#define TRACE()\
   printf ("%s:%d\n", __FILE__, __LINE__);
 
static matrix *allouer_matrice (int nbli, int nbcol)
{
   /* -ed-
      matrix *m;
      m = (matrix *) malloc (sizeof (matrix));
 
      malloc() peut echouer...
      cast inutile.
 
      <a href="http://emmanuel-delahaye.developpez.com/notes.htm" target="_blank">http://emmanuel-delahaye.developpez.com/notes.htm</a>
 
    */
   matrix *m = malloc (sizeof *m);
 
   if (m != NULL)
   {
      /* -ed- enregistrer les tailles */
      m->nb_lignes = nbli;
      m->nb_colonnes = nbcol;
 
      /* -ed-
         m->element = (int **) calloc (nbli, sizeof (int **));
 
         calloc() peut echouer...
         fonction deconseillee (effet non portable)
         utiliser malloc()
       */
 
      m->element = malloc (nbli * sizeof *m->element);
 
      if (m->element)
      {
/* -ed- deplace au titre de la reduction de la portee des objets */
         int i;
         for (i = 0; i < nbcol; i++)
         {
            /* -ed- pour l'initialisation */
            int j;
/* -ed-
   m->element[i] = (int *) calloc (nbcol, sizeof (int *));
 */
            m->element[i] = malloc (nbcol * sizeof *m->element[i]);
 
 
            for (j = 0; j < m->nb_colonnes; j++)
            {
               if (m->element[i] != NULL)
               {
                  m->element[i][j] = 0;
               }
            }
         }
 
      }
   }
   return m;
}
 
/* -ed- 'fp' est un nom usuel de pointeur FILE */
static matrix *read_matrix (FILE * fp)
{
/* -ed-
   matrix *m;
   m = (matrix *) malloc (sizeof (matrix));
 
   NON! C'est 'allouer_matrice()' qui s'en charge...
 */
   matrix *m = NULL;
 
   if (fp != NULL)
   {
      /* -ed-
         printf ("haha\n");
 
         il y a plus efficace que ces traces debiles...
 
       */
      TRACE ();
 
/* -ed-
   if (p == NULL)
   {
   return;                   //ouverture en lecture impossible
 
   le retour de la fonction est type'.
   Il faut donc retourner une valeur coherente.
   Disons NULL...
 
   Refonte du test. Passe en 'test sanitaire prealable'
 */
      int nb_lignes;
      int nb_colonnes;
/* -ed-
   fscanf (p, "%i%i", &m->nb_lignes, &m->nb_colonnes);
 
   en principe on utilise pas fscanf(). Mais si tu le fais, fait le bien.
 
   suppression des refernces a m qui n'existe pas encore.
 */
      if (fscanf (fp, "%i%i", &nb_lignes, &nb_colonnes) == 2)
      {
 
         printf ("%i\n", nb_lignes);
         printf ("%i\n", nb_colonnes);
         {
            /* -ed- deplace la defintion de m... */
            m = allouer_matrice (nb_lignes, nb_colonnes);
 
            if (m != NULL)
            {
               TRACE ();
#if 1
               int i;
               for (i = 0; i < m->nb_lignes; i++)
               {
                  int j;
                  for (j = 0; j < m->nb_colonnes; j++)
                  {
                     /* -ed- ajoute controle de lecture... */
                     int n = fscanf (fp, "%i", &m->element[i][j]);
 
                     if (n != 1)
                     {
                        printf ("read error\n");
                        break;
                     }
                  }
               }
               TRACE ();
               printf ("%i %i %i\n", m->nb_lignes, m->nb_colonnes, m->element[1][1]);
#endif
            }
         }
      }
   }
   return m;
}
 
static void affic_matrix (matrix * m)
{
   int i, j;
   printf ("Matrice de taille : %i * %i\n", m->nb_lignes, m->nb_colonnes);
   for (i = 0; i < m->nb_lignes; i++)
   {
      /* -ed- j et non i... */
      for (j = 0; j < m->nb_colonnes; j++)
      {
         printf ("%i%s", m->element[i][j], " ");
      }
      printf ("\n");
   }
}
 
int main (void)
{
/* -ed-
   matrix *m1;
   m1 = (matrix *) malloc (sizeof (matrix));
 
   deja fait par read_matrix()
 */
 
   FILE *fic = fopen ("../../data/matrix.txt", "r");
 
   if (fic != NULL)
   {
      TRACE ();
      {
         matrix *m1 = read_matrix (fic);
 
         if (m1 != NULL)
         {
            TRACE ();
            printf ("%i %i\n", m1->nb_lignes, m1->nb_colonnes);
            affic_matrix (m1);
         }
      }
      /* -ed- tout fichier ouvert correctement doit etre referme */
 
      fclose (fic);
   }
   return 0;
}

Je te laisse ecrire le code de liberation...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
../main.c:204
../main.c:115
3
4
../main.c:148
../main.c:166
3 4 6
../main.c:210
3 4
Matrice de taille : 3 * 4
1 2 3 4
5 6 7 8
9 0 1 2
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 008F0690 (12 bytes) malloc'ed at line 50 of '../main.c' not freed
SYSALLOC Bloc 008F06A0 (12 bytes) malloc'ed at line 66 of '../main.c' not freed
SYSALLOC Bloc 008F06B0 (16 bytes) malloc'ed at line 79 of '../main.c' not freed
SYSALLOC Bloc 008F06C0 (16 bytes) malloc'ed at line 79 of '../main.c' not freed
SYSALLOC Bloc 008F06D0 (16 bytes) malloc'ed at line 79 of '../main.c' not freed
SYSALLOC Bloc 008F06E0 (16 bytes) malloc'ed at line 79 of '../main.c' not freed
SYSALLOC Released Memory

03/11/2005, 15h33
TeKa
Citation:
Envoyé par Emmanuel Delahaye

Citation:

Envoyé par TeKa

J'indentes, mais sur le copier coller a tout casse... :/

Si tu utilises les balises code, aucun problème. La preuve...

Citation:

Code:

<...>

Des corrections et des remarques...

Code:

1 2 [...]
Merci pour tout. Je vais repotasser ca et je vous tiens au courant pour la suite. ;)

C'est encore moi.
Emmanuel --> Bon, j'ai bien etudie le code que tu m'as fourni, et j'ai ete oblige de virer quelques trucs, notamment ceux que je ne connais pas du tout!
Bref, j'ai continue mon exercice et je me retrouve avec un joli fichier .h desormais qui servira de librairie pour un autre fichier .c
Et bien la encore la compilation ne marche pas! :/
Je reposte les nouveaux fichiers...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
//matrix_io.h
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
   int **element;
   int nb_lignes;
   int nb_colonnes;
} matrix;
 
static matrix *allouer_matrice (int nbli, int nbcol) {
   matrix *m = malloc (sizeof *m);
 
   if (m != NULL) {
      m->nb_lignes = nbli;
      m->nb_colonnes = nbcol;
      m->element = malloc (nbli * sizeof *m->element);
      if (m->element) {
         int i;
         for (i = 0; i < nbcol; i++) {
            int j;
            m->element[i] = malloc (nbcol * sizeof *m->element[i]);
            for (j = 0; j < m->nb_colonnes; j++) {
               if (m->element[i] != NULL) {
                  m->element[i][j] = 0;
               }
            }
         }
 
      }
   }
   return m;
}
 
static matrix *read_matrix (FILE *fp) {
   matrix *m = NULL;
 
   if (fp != NULL) {
      int nb_lignes;
      int nb_colonnes;
      if (fscanf (fp, "%i%i", &nb_lignes, &nb_colonnes) == 2) {
         {
            m = allouer_matrice (nb_lignes, nb_colonnes);
            if (m != NULL) {
               int i;
               for (i = 0; i < m->nb_lignes; i++) {
                  int j;
                  for (j = 0; j < m->nb_colonnes; j++) {
                     int n = fscanf (fp, "%i", &m->element[i][j]);
                     if (n != 1) {
                        printf ("erreur de lecture\n");
                        break;
                     }
                  }
               }
            }
         }
      }
   }
   return m;
}
 
static void affic_matrix (matrix * m) {
   int i, j;
   printf ("Matrice de taille : %i * %i\n", m->nb_lignes, m->nb_colonnes);
   for (i = 0; i < m->nb_lignes; i++) {
      for (j = 0; j < m->nb_colonnes; j++) {
         printf ("%i%s", m->element[i][j], " ");
      }
      printf ("\n");
   }
}
 
static void write_matrix(FILE *fp,matrix *m) {
	int i, j;
	if (fp!=NULL){
		fprintf(fp,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes);
		for (i=0; i<m->nb_lignes; i++) {
			for (j=0; j<m->nb_colonnes; j++) {
				fprintf(fp,"%i%s",m->element[i][j]," ");
			}
			fprintf(fp,"\n");
		}
	}
}
 
void remplir_matrice(matrix *m){
	int i,j;
	printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes);
	for(i=0;i<m->nb_lignes;i++){
		for(j=0;j<m->nb_colonnes;j++){
			printf("element (%d,%d)? ",i,j);
			scanf("%i",&(m->element[i][j]));
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
//main.c
#include <stdio.h>
#include <stdlib.h>
#include "matrix_io.h"
 
int main(void) {
	int choix;
	printf("Que voulez-vous faire?\n");
	printf("1 - Ecrire une matrice dans un fichier.\n");
	printf("2 - Lire une matrice depuis un fichier.\n");
	int n = scanf("%i",choix);
	if (n == 1) {
		if (choix==1) {
			FILE *fp = fopen ("matrix.txt", "w");
			if (fp != NULL) {
				matrix *m1 = remplir_matrice(m1);
				write_matrix(fp, m1);
			}
			fclose (fp);
		}
		else if (choix == 2) {
			FILE *fp = fopen ("matrix.txt", "r");
			if (fp != NULL) {
				matrix *m1 = read_matrix (fp);
				if (m1 != NULL) {
					affic_matrix (m1);
				}
			}
			fclose (fp);
		}
		else {
			printf("Choisir 1 ou 2.\n");
		}
	}
	return 0;
}

Je me suis bien inspire de ta correction pour eviter de faire des erreurs dans mon main.c.

Encore merci pour votre aide a tous.

04/11/2005, 11h38
Emmanuel Delahaye

Citation:

Envoyé par TeKa

Bref, j'ai continue mon exercice et je me retrouve avec un joli fichier .h
desormais qui servira de librairie pour un autre fichier .c

Eeek! Non!

A lire et à assimiler avant d'aller plus loin :

http://emmanuel-delahaye.developpez....m#bibliotheque
http://emmanuel-delahaye.developpez....ganiser_source
http://emmanuel-delahaye.developpez.....htm#organiser

Maintenant, je veux voir 3 fichiers.
04/11/2005, 11h43
TeKa

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par TeKa

Bref, j'ai continue mon exercice et je me retrouve avec un joli fichier .h
desormais qui servira de librairie pour un autre fichier .c

Eeek! Non!
A lire et à assimiler avant d'aller plus loin.

http://emmanuel-delahaye.developpez....m#bibliotheque
http://emmanuel-delahaye.developpez....ganiser_source
http://emmanuel-delahaye.developpez.....htm#organiser

Maintenant, je veux voir 3 fichiers.

Euh... On oublie le .h alors. Dans mon enonce en fait il fallait faire un matrix_io.c et le compiler avec le main.c, mais des potes avaient choisis de faire un .h, soi disant plus simple...
On va dire que le .h est un .c en fait! :D
04/11/2005, 12h23
Emmanuel Delahaye

Citation:

Envoyé par TeKa

Euh... On oublie le .h alors. Dans mon enonce en fait il fallait faire un matrix_io.c et le compiler avec le main.c, mais des potes avaient choisis de faire un .h, soi disant plus simple...
On va dire que le .h est un .c en fait! :D

Ben non, On n'inclus pas un .c dans un .c. Apprends à coder correctement tout de suite. Ca mord pas.

Un .h (interface)
Un .c (implementation)
Un .c (application)

C'est pas compliqué et ça permet d'organiser son code de manière efficace immédiatement.
04/11/2005, 12h48
TeKa

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par TeKa

Euh... On oublie le .h alors. Dans mon enonce en fait il fallait faire un matrix_io.c et le compiler avec le main.c, mais des potes avaient choisis de faire un .h, soi disant plus simple...
On va dire que le .h est un .c en fait! :D

Ben non, On n'inclus pas un .c dans un .c. Apprends à coder correctement tout de suite. Ca mord pas.

Un .h (interface)
Un .c (implementation)
Un .c (application)

C'est pas compliqué et ça permet d'organiser son code de manière efficace immédiatement.

J'ai pas dit qu'on incluait! On vire la ligne fautive du main.c (#include "matrix_io.h") et on compile les 2 fichiers ensemble... ;)
04/11/2005, 12h54
Emmanuel Delahaye

Citation:

Envoyé par TeKa

J'ai pas dit qu'on incluait! On vire la ligne fautive du main.c (#include "matrix_io.h") et on compile les 2 fichiers ensemble... ;)

Ensemble ? Un seul fichier (fusion des deux) ou 2 fichiers séparés ? Dans le deuxième cas, il faut ,un .h pour fournir les interfaces...

Dans le premier cas, c'est reculer pour mieux sauter. un jour ou l'autre tu devras apprendre à utiliser la compilation séparée, seule façon d'écrire du code réutuilisable, maintenable, testable unitairement, bref, professionel...
04/11/2005, 13h06
TeKa

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par TeKa

J'ai pas dit qu'on incluait! On vire la ligne fautive du main.c (#include "matrix_io.h") et on compile les 2 fichiers ensemble... ;)

Ensemble ? Un seul fichier (fusion des deux) ou 2 fichiers séparés ? Dans le deuxième cas, il faut ,un .h pour fournir les interfaces...

Dans le premier cas, c'est reculer pour mieux sauter. un jour ou l'autre tu devras apprendre à utiliser la compilation séparée, seule façon d'écrire du code réutuilisable, maintenable, testable unitairement, bref, professionel...

Je veux faire un 'gcc -o prog matrix_io.c main.c'.
Et pour le reste, je m'en tiens a ce que le prof m'apprend et ce qu'il me demande... Pas la peine de vouloir aller trop vite. ;)

Une petite erreur

Bonjour
Au fait le code et toutes les corrections sont trés bien.
j'ai repris le code et je me suis amusé à le déboguer, j'ai trouvé une petite erreur qui plante tout et c'est à ce niveau :
Code:

1 2 3 4 5 6 7 8 9 10 11 void affic_matrix(matrix *m) { int i,j; printf("Matrice de taille : %i * %i\n",m->nb_lignes,m->nb_colonnes); for (i=0; i<m->nb_lignes; i++) { for (j=0; i<m->nb_colonnes; j++){ printf("%i%s",m->element[i][j]," "); } printf("\n"); } }
au lieu de mettre j ds la boucle de i vous avez mis i, tout simplement !
Essayez de corriger ça !
je crois que ça marchera

ANIBAL

Re: Une petite erreur

Citation:
Envoyé par anibal
Bonjour
Au fait le code et toutes les corrections sont trés bien.
j'ai repris le code et je me suis amusé à le déboguer, j'ai trouvé une petite erreur qui plante tout et c'est à ce niveau :
Code:

1 2 3 4 5 6 7 8 9 10 11 void affic_matrix(matrix *m) { int i,j; printf("Matrice de taille : %i * %i\n",m->nb_lignes,m->nb_colonnes); for (i=0; i<m->nb_lignes; i++) { for (j=0; i<m->nb_colonnes; j++){ printf("%i%s",m->element[i][j]," "); } printf("\n"); } }
au lieu de mettre j ds la boucle de i vous avez mis i, tout simplement !
Essayez de corriger ça !
je crois que ça marchera

ANIBAL
Emmanuel avait deja corrige ca. Regarde dans le post ou j'ai mis le programme pour la derniere fois. ;)

04/11/2005, 16h57
Emmanuel Delahaye

Re: Une petite erreur
Citation:

Envoyé par anibal

au lieu de mettre j ds la boucle de i vous avez mis i, tout simplement !
Essayez de corriger ça !
Citation:
Envoyé par Emmanuel Delahaye

Code:

1 2 3 /* -ed- j et non i... */ for (j = 0; j < m->nb_colonnes; j++)

Voial ou j'en suis:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
   int **element;
   int nb_lignes;
   int nb_colonnes;
} matrix;
 
static matrix *allouer_matrice (int nbli, int nbcol) {
   matrix *m = malloc (sizeof *m);
   if (m != NULL) {
      m->nb_lignes = nbli;
      m->nb_colonnes = nbcol;
      m->element = malloc (nbli * sizeof *m->element);
      if (m->element) {
         int i;
         for (i = 0; i < nbcol; i++) {
            int j;
            m->element[i] = malloc (nbcol * sizeof *m->element[i]);
            for (j = 0; j < m->nb_colonnes; j++) {
               if (m->element[i] != NULL) {
                  m->element[i][j] = 0;
               }
            }
         }
 
      }
   }
   return m;
}
 
static matrix *read_matrix (FILE *fp) {
   matrix *m = NULL;
   if (fp != NULL) {
      int nb_lignes;
      int nb_colonnes;
      if (fscanf (fp, "%i%i", &nb_lignes, &nb_colonnes) == 2) {
         {
            m = allouer_matrice (nb_lignes, nb_colonnes);
            if (m != NULL) {
               int i;
               for (i = 0; i < m->nb_lignes; i++) {
                  int j;
                  for (j = 0; j < m->nb_colonnes; j++) {
                     int n = fscanf (fp, "%i", &m->element[i][j]);
                     if (n != 1) {
                        printf ("erreur de lecture\n");
                        break;
                     }
                  }
               }
            }
         }
      }
   }
   return m;
}
 
static void affic_matrix (matrix * m) {
   int i, j;
   printf ("Matrice de taille : %i * %i\n", m->nb_lignes, m->nb_colonnes);
   for (i = 0; i < m->nb_lignes; i++) {
      for (j = 0; j < m->nb_colonnes; j++) {
         printf ("%i%s", m->element[i][j], " ");
      }
      printf ("\n");
   }
}
 
static void write_matrix(FILE *fp,matrix *m) {
	int i, j;
	if (fp!=NULL){
		fprintf(fp,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes);
		for (i=0; i<m->nb_lignes; i++) {
			for (j=0; j<m->nb_colonnes; j++) {
				fprintf(fp,"%i%s",m->element[i][j]," ");
			}
			fprintf(fp,"\n");
		}
	}
}
 
static void remplir_matrice(matrix *m){
	int i,j;
	printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes);
	for(i=0;i<m->nb_lignes;i++){
		for(j=0;j<m->nb_colonnes;j++){
			printf("element (%d,%d)? ",i,j);
			scanf("%i",&(m->element[i][j]));
		}
	}
}
 
matrix *add_matrix(matrix *m1, matrix *m2){
	int i,j;
	matrix *madd = NULL;
	if(m1->nb_lignes == m2->nb_lignes && m1->nb_colonnes == m2->nb_colonnes){
		madd=allouer_matrice(m1->nb_lignes,m1->nb_colonnes);
		for(i=0;i<m1->nb_lignes;i++){
			for(j=0;j<m1->nb_colonnes;j++){
				madd->element[i][j]=m1->element[i][j]+m2->element[i][j];
			}
		}
		return madd;
	}
	else {
		printf("Attention! Les matrices ne sont pas de la meme taille.\n");
	}
	return NULL;
}
 
matrix *multiply_matrix(matrix *m1, matrix *m2){
	int i,j,k;
	matrix *mmul;
	if(m1->nb_colonnes == m2->nb_lignes){
		mmul=allouer_matrice(m1->nb_lignes,m2->nb_colonnes);
		for(i=0;i<mmul->nb_lignes;i++){
			for(j=0;j<mmul->nb_colonnes;j++){
				for(k=0;k<m1->nb_colonnes;k++){
					mmul->element[i][j]+= m1->element[i][k]*m2->element[k][j];
				}
			}
		}
		return mmul;
	}
	else{
		printf("Attention! Les matrices ne peuvent pas etre multipliees. Rectifiez les dimensions.\n");
	}
	return NULL;
}
 
int main(void) {
	int choix;
	int n;
	printf("Que voulez-vous faire?\n");
	printf("1 - Ecrire une matrice dans un fichier.\n");
	printf("2 - Lire une matrice depuis un fichier.\n");
	printf("Choix : ");
	n = scanf("%i",choix);
	if (n == 1) {
		if (choix==1) {
			FILE *fp = fopen ("matrix.txt", "w");
			if (fp != NULL) {
				matrix *m1 = remplir_matrice(m1);
				write_matrix(fp, m1);
			}
		fclose (fp);
		}
		else if (choix == 2) {
			FILE *fp = fopen ("matrix.txt", "r");
			if (fp != NULL) {
				matrix *m1 = read_matrix (fp);
				if (m1 != NULL) {
					affic_matrix (m1);
				}
			}
			fclose (fp);
		}
		else {
			printf("Choisir 1 ou 2.\n");
		}
	}
	return 0;
}

Logiquement, mon programme a toutes les fonctions necessaires, et le main devrait contenir un 3 eme choix lancant une "demo" qui fait quelques operatiosn sur 2 matrices lues depuis 2 fichiers differents, puis afficher la nouvelle matrice et l'ecrire dans un nouveau fichier. Mais si ce que j'ai deja fait est bon, ca ne devrait pas poser de problemes.
Je commence a voir mes erreurs, et maintenant je ne compile plus qu'avec Wall. Mais la j'ai beau faire, il me reste un warning et une erreur. Et l'erreur je vois pas du tout ce qui la cause. :/
Merci pour les eclaircissements. ;)

05/11/2005, 12h36
Trap D

Le code ne compile pas :

Code:

matrix *m1 = remplir_matrice(m1);

car

Code:

static void remplir_matrice(matrix *m){

Il faut que remplir_matrice renvoie une adresse de matrix !
05/11/2005, 12h39
Emmanuel Delahaye
Citation:

Envoyé par TeKa

Je commence a voir mes erreurs, et maintenant je ne compile plus qu'avec Wall.

Insuffisant. Au minimum :

Code:

-Wall -Wextra -O2

Citation:

Mais la j'ai beau faire, il me reste un warning et une erreur. Et l'erreur je vois pas du tout ce qui la cause. :/
Merci pour les eclaircissements. ;)
Code:

1 2 3 4 5 Compiling: main.c main.c: In function `main_': main.c:141: warning: format argument is not a pointer (arg 2) main.c:146: error: void value not ignored as it ought to be
Ligne 141

Code:

n = scanf("%i",choix);

"%i" attend l'adresse d'un int et non un int.

Code:

n = scanf("%i", &choix);

Ligne 146
La fonction remplir_matrice() ne retourne rien (void)

Code:

static void remplir_matrice(matrix *m){

il est donc incohérent d'écrire:

Code:

matrix *m1 = remplir_matrice(m1);
05/11/2005, 12h43
TeKa

Alors la... J'ai vraiment honte d'avoir fait des erreurs pareilles... :/
Merci encore une fois de tes lumieres. ;)

g repris qques fonctions, en fait les codes déja posté sont trés bien écrit mais je crois qu'il ya une manière plus simple d'allouer la matrice, notez que g supposé que je connaissais les lignes et les colonnes de ma matrice, ce qui serait plus onteressatn serait de pouvoir dégagé d'une manière automatique combien de lignes et de colonnes on a ?
Qqu'un aurait une idée ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include <stdio.h> 
#include <stdlib.h>
 
/***********************************************************/
/****************        READ MATRIX       *****************/
/***********************************************************/
 
int ** readmatrix(char *name,int lines, int columns){
 
  FILE *F ;
  int ** matrix;
  int i,j;
 
 
  F= fopen(name,"r");
  matrix=(int**)malloc(columns*sizeof(int*));
  for (i=0;i<columns;i++){
    matrix[i]=(int*)malloc(lines*sizeof(int));
  }
  /* Parse external matrix file per line than per column */
  for(j=0;j<lines;j++){
    for(i=0;i<columns;i++){
      fscanf(F,"%d",&matrix[i][j]);
    }
  }
  fclose(F);
  return matrix;
}
 
 
/***********************************************************/
/****************        PRINT MATRIX      *****************/
/***********************************************************/
 
 
void print_matrix(int **matrix,int lines,int columns) { 
 
  int i,j;
 
    for (j=0; j<lines; j++){
      for (i=0; i<columns; i++) { 
      printf("%d ",matrix[i][j]); 
    } 
    printf("\n"); 
    }
} 
 
 
/***********************************************************/
/****************        MAIN PROGRAM      *****************/
/***********************************************************/
 
 
 
 
int main(int argc,char **argv){
  int **m;
  m = readmatrix(argv[1],4,4);
  print_matrix(m,4,4);
  return 0;
}

Hello.
Je uppe ce thread pour y mettre fin.
Voici le code que j'ai rendu:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
   int **element;
   int nb_lignes;
   int nb_colonnes;
} matrix;
 
static matrix *allouer_matrice (int nbli, int nbcol) {
   matrix *m = malloc (sizeof *m);
   if (m != NULL) {
      m->nb_lignes = nbli;
      m->nb_colonnes = nbcol;
      m->element = malloc (nbli * sizeof *m->element);
      if (m->element) {
         int i;
         for (i = 0; i < nbcol; i++) {
            int j;
            m->element[i] = malloc (nbcol * sizeof *m->element[i]);
            for (j = 0; j < m->nb_colonnes; j++) {
               if (m->element[i] != NULL) {
                  m->element[i][j] = 0;
               }
            }
         }
 
      }
   }
   return m;
}
 
static void liberer_matrice(matrix *m){
	int i;
	for(i=0;i<m->nb_colonnes;i++){
		free(m->element[i]);
	}
	free(m->element);
}
 
static matrix *read_matrix (FILE *fp) {
   matrix *m = NULL;
   if (fp != NULL) {
      int nb_lignes;
      int nb_colonnes;
      if (fscanf (fp, "%i%i", &nb_lignes, &nb_colonnes) == 2) {
         {
            m = allouer_matrice (nb_lignes, nb_colonnes);
            if (m != NULL) {
               int i;
               for (i = 0; i < m->nb_lignes; i++) {
                  int j;
                  for (j = 0; j < m->nb_colonnes; j++) {
                     int n = fscanf (fp, "%i", &m->element[i][j]);
                     if (n != 1) {
                        printf ("erreur de lecture\n");
                        break;
                     }
                  }
               }
            }
         }
      }
   }
   return m;
}
 
static void affic_matrix (matrix * m) {
   int i, j;
   printf ("Matrice de taille : %i * %i\n", m->nb_lignes, m->nb_colonnes);
   for (i = 0; i < m->nb_lignes; i++) {
      for (j = 0; j < m->nb_colonnes; j++) {
         printf ("%i%s", m->element[i][j], " ");
      }
      printf ("\n");
   }
}
 
static void write_matrix(FILE *fp,matrix *m) {
	int i, j;
	if (fp!=NULL){
		fprintf(fp,"%i%s%i\n",m->nb_lignes," ",m->nb_colonnes);
		for (i=0; i<m->nb_lignes; i++) {
			for (j=0; j<m->nb_colonnes; j++) {
				fprintf(fp,"%i%s",m->element[i][j]," ");
			}
			fprintf(fp,"\n");
		}
	}
}
 
static void remplir_matrice(matrix *m){
	int i,j;
	printf("Remplissage de matrice %dx%d\n",m->nb_lignes,m->nb_colonnes);
	for(i=0;i<m->nb_lignes;i++){
		for(j=0;j<m->nb_colonnes;j++){
			printf("element (%d,%d)? ",i,j);
			scanf("%i",&(m->element[i][j]));
		}
	}
}
 
matrix *add_matrix(matrix *m1, matrix *m2){
	int i,j;
	matrix *madd = NULL;
	if(m1->nb_lignes == m2->nb_lignes && m1->nb_colonnes == m2->nb_colonnes){
		madd=allouer_matrice(m1->nb_lignes,m1->nb_colonnes);
		for(i=0;i<m1->nb_lignes;i++){
			for(j=0;j<m1->nb_colonnes;j++){
				madd->element[i][j]=m1->element[i][j]+m2->element[i][j];
			}
		}
		return madd;
	}
	else {
		printf("Attention! Les matrices ne sont pas de la meme taille.\n");
	}
	return NULL;
}
 
matrix *multiply_matrix(matrix *m1, matrix *m2){
	int i,j,k;
	matrix *mmul;
	if(m1->nb_colonnes == m2->nb_lignes){
		mmul=allouer_matrice(m1->nb_lignes,m2->nb_colonnes);
		for(i=0;i<mmul->nb_lignes;i++){
			for(j=0;j<mmul->nb_colonnes;j++){
				for(k=0;k<m1->nb_colonnes;k++){
					mmul->element[i][j]+= m1->element[i][k]*m2->element[k][j];
				}
			}
		}
		return mmul;
	}
	else{
		printf("Attention! Les matrices ne peuvent pas etre multipliees. Rectifiez les dimensions.\n");
	}
	return NULL;
}
 
int main(void) {
	int choix;
	int n;
	printf("Que voulez-vous faire?\n");
	printf("1 - Ecrire une matrice dans un fichier.\n");
	printf("2 - Lire une matrice depuis un fichier.\n");
	printf("3 - Lancer la Demo.\n");
	printf("Choix : ");
	n = scanf("%i",&choix);
	if (n == 1) {
		if (choix==1) {
			FILE *fp = fopen ("matrix.txt", "w");
			if (fp != NULL) {
				matrix *m1;
				int nbli, nbcol, p, q;
				printf("Nombre de lignes : ");
				p = scanf("%i", &nbli);
				printf("Nombre de colonnes : ");
				q = scanf("%i", &nbcol);
				if (p == 1 && q == 1){
					m1 = allouer_matrice(nbli, nbcol);
					remplir_matrice(m1);
					write_matrix(fp, m1);
				}
				liberer_matrice(m1);
			}
			fclose (fp);
		}
		else if (choix == 2) {
			FILE *fp = fopen ("matrix.txt", "r");
			if (fp != NULL) {
				matrix *m1 = read_matrix (fp);
				if (m1 != NULL) {
					affic_matrix (m1);
				}
				liberer_matrice(m1);
			}
			fclose (fp);
		}
		else if (choix==3) {
			FILE *fp1 = fopen("matrix1.txt","r");
			FILE *fp2 = fopen("matrix2.txt","r");
			FILE *fp3 = fopen("matrix3.txt","w");
			if (fp1 != NULL && fp2 != NULL && fp3 != NULL) {
				matrix *m1 = read_matrix (fp1);
				matrix *m2 = read_matrix (fp2);
				if (m1 != NULL && m2 != NULL) {
					affic_matrix (m1);
					affic_matrix (m2);
					printf("Additionnons la matrice M1 et la matrice M1xM2...\n");
					matrix *m3 = add_matrix(m1, multiply_matrix(m1, m2));
					affic_matrix(m3);
					printf("Stockons le resultat dans un fichier...\n");
					write_matrix(fp3, m3);
					liberer_matrice(m3);
				}
				liberer_matrice(m1);
				liberer_matrice(m2);
			}
			fclose(fp1);
			fclose(fp2);
			fclose(fp3);
		}
		else {
			printf("Choisir 1, 2 ou 3.\n");
		}
	}
	return 0;
}

Merci pour votre aide a tous. Je reviendrais certainement. ;)