Calcul matricielle et allocation mémoire !?

Version imprimable

Bonsoir,

Je souhaite faire un petit "programme" pour automatise la somme, la soustraction, la multiplication, calculer le determinant de matrice dont on connait le nombre de colonnes et le nombre de lignes ( elles ne sont pas necessairement carrées à part pour les sommes et la soustration ).

Bref dans le code ci dessous, la compilation a lieu mais au final le programme n'arrive pas à la fin de l'execution i.e "la pause system" mais il plante en cour d'execution.

Je suppose que cela vient de l'allocation en mémoire des matrices mais je ne comprends pas pourquoi.

Merci d'avance.

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
 
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include"./../bibliotheque.h"
 
int  **Allouer_Matrice     ( int **Matrice, int Colonne, int Ligne);
int  **Sommer_Matrice      ( int **Matrice, int **MatriceA, int **MatriceB, int Taille);
int  **Initialiser_Matrice ( int **Matrice, int Colonne, int Ligne);
void   Afficher_Matrice    ( int **Matrice, int Colonne, int Ligne);
void   Desallouer_Matrice  ( int **Matrice, int Ligne );
 
int main (void)
{
    int **MatriceA;
    //int **MatriceB;
    //int **Matrice;
 
    Allouer_Matrice( MatriceA, 4, 4 );
    //Allouer_Matrice( MatriceB, 4, 4 );
    //Allouer_Matrice( Matrice, 4, 4 );
 
    Initialiser_Matrice( MatriceA, 4, 4 );
    //Initialiser_Matrice( MatriceB, 4, 4 );
 
    Afficher_Matrice( MatriceA, 4, 4 );
    //Afficher_Matrice( MatriceB, 4, 4 );
 
    //Sommer_Matrice( Matrice, MatriceA, MatriceB, 4 );
    //Afficher_Matrice( Matrice, 4, 4 );
 
//    int i, j;
//    for ( i=0 ; i<4 ; i++ )
//        {
//            for ( j=0 ; j<4 ; j++ )
//                {
//                    printf("Matrice[%d][%d]= %d + %d = %d\Ligne", (i+1), (j+1), MatriceA[i][j], MatriceB[i][j], Matrice[i][j]);
//                }
//        }
 
    Desallouer_Matrice( MatriceA, 4 );
    //Desallouer_Matrice( MatriceB, 4 );
    //Desallouer_Matrice( Matrice, 4 );
 
    system("pause");
 
}
 
int **Allouer_Matrice(int **Matrice, int Colonne, int Ligne)
{
      // Allouer les colonnes
      Matrice = malloc( Colonne*sizeof(int*) );
 
      int i;
 
      // Allouer les lignes
      for ( i=0 ; i<Ligne ; i++)
          {
             Matrice[i]=malloc( Ligne*sizeof(int) );
          }  
 
      return Matrice;
}
 
int **Initialiser_Matrice(int **Matrice, int Colonne, int Ligne)
{
     int i, j;
 
     for ( i=0 ; i<Colonne ; i++ )
         {
               for ( j=0 ; j<Ligne ; j++ )
                   {
                        Matrice[i][j]=rand()%10;
                   }   
         }
 
     return Matrice;
}
 
int **Sommer_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int Taille)
{
     int i,j;
 
     for ( i=0 ; i<Taille ; i++ )
         {
             for ( j=0 ; j<Taille ; j++ )
                 {
                     Matrice[i][j]=MatriceA[i][j]+MatriceB[i][j];
                 }
         }
 
     return Matrice;
}
 
void Afficher_Matrice(int **Matrice, int Colonne, int Ligne)
{
    int i, j;
 
    for ( i=0 ; i<Colonne ; i++ )
        {
              for ( j=0 ; j<Ligne ; j++)
                  {
                        printf("\nMatrice[%d][%d]=%d", i, j, Matrice[i][j]);
                  }
        }        
}                   
 
 
void Desallouer_Matrice( int **Matrice, int Ligne )
{
               int i;
 
               for ( i=1 ; i<Ligne ; i++ )
                   {
                         free(Matrice[i]);
                   }
 
               free(Matrice);
}

J'ai pas encore vu tout le code, mais d'emble, voici ce que je dit :
Code:

1 2 3 4 int **Allouer_Matrice ( int **Matrice, int Colonne, int Ligne); int **Sommer_Matrice ( int **Matrice, int **MatriceA, int **MatriceB, int Taille); int **Initialiser_Matrice ( int **Matrice, int Colonne, int Ligne);
Pourquoi ces fonction renvoi des int** sachant que tu passe la matrice par adresse ? Et surtout que tu ne recupere pas la valeur de retour.

Code:

1
2
3
4
5
 
      for ( i=0 ; i<Ligne ; i++)
          {
             Matrice[i]=malloc( Ligne*sizeof(int) );
          }

Attention, il y a mal donne !

Le parametre de condition d'arret du for est fausse. Il faut faire :

Code:

1
2
3
4
5
      for ( i=0 ; i<Colonne ; i++)
          {
             Matrice[i]=malloc( Ligne*sizeof(int) );
          }

Le code semble fonctionner, j'ai vérifier les résultats à la main, en effet dans l'allocation mémoire c'était archi faux ce que j'ai tapé !

Pour ce qui est du passage par adresse oui, je ne comprends pas non plus.
Comme je passe la matrice à retourner par adresse, je ne suis normalement pas censé avoir besoin de la récupérer, enfin je crois.

Voici le code avec des void qui compile mais ne fait rien et après le code sans les void qui compile et fonctionne, j'ai vérifier les calculs à la main.

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
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include"./../bibliotheque.h"
 
void Allouer_Matrice               ( int **Matrice, int Colonne, int Ligne                                                             );
void Sommer_Matrice                ( int **Matrice, int **MatriceA, int **MatriceB, int Colonne, int Ligne                             );
void Soustraire_Matrice            ( int **Matrice, int **MatriceA, int **MatriceB, int Taille                                         );
void Initialiser_Matrice           ( int **Matrice, int Colonne, int Ligne                                                             );
void Remplir_Matrice_Aleatoirement ( int **Matrice, int Colonne, int Ligne                                                             );
void Multiplier_Matrice            ( int **Matrice, int **MatriceA, int **MatriceB, int ColonneA, int LigneA, int ColonneB, int LigneB );
void Afficher_Matrice              ( int **Matrice, int Colonne, int Ligne                                                             );
void Desallouer_Matrice            ( int **Matrice, int Colonne                                                                        );
 
int main (void)
{
    int **MatriceA;
    int **MatriceB;
    int **Matrice ;
 
    Allouer_Matrice( MatriceA, 2, 3 );
    Allouer_Matrice( MatriceB, 4, 2 );
    Allouer_Matrice( Matrice , 4, 3 );
 
    Remplir_Matrice_Aleatoirement( MatriceA, 2, 3 );
    Remplir_Matrice_Aleatoirement( MatriceB, 4, 2 );
 
    Initialiser_Matrice( Matrice , 4, 3 );
 
    Afficher_Matrice( MatriceA, 2, 3 );
    printf("\n");
    Afficher_Matrice( MatriceB, 4, 2 );
 
    Multiplier_Matrice( Matrice, MatriceA, MatriceB, 2, 3, 4, 2 );
 
    printf("\n");
    Afficher_Matrice( Matrice, 4, 3 );
 
    Desallouer_Matrice( MatriceA, 2 );
    Desallouer_Matrice( MatriceB, 4 );
    Desallouer_Matrice( Matrice , 4 );
 
    getchar();
 
}
 
void Allouer_Matrice(int **Matrice, int Colonne, int Ligne)
{    
 
      int i=0; 
 
      // Allouer les colonnes
      Matrice = malloc( Ligne*sizeof(int*) );
 
      // Allouer les lignes
      for ( i=0 ; i<Ligne ; i++)
          {
             Matrice[i]=malloc( Colonne*sizeof(int) );
          }  
 
}
 
void Initialiser_Matrice(int **Matrice, int Colonne, int Ligne)
{
     int i, j;
 
     for ( i=0 ; i<Ligne ; i++ )
         {
               for ( j=0 ; j<Colonne ; j++ )
                   {
                        Matrice[i][j]=0;
                   }   
         }
 
}
 
void Remplir_Matrice_Aleatoirement(int **Matrice, int Colonne, int Ligne)
{
     int i, j;
 
     for ( i=0 ; i<Ligne ; i++ )
         {
               for ( j=0 ; j<Colonne ; j++ )
                   {
                        Matrice[i][j]=rand()%3;
                   }   
         }
 
}
 
void Sommer_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int Colonne, int Ligne)
{
     int i,j;
 
     for ( i=0 ; i<Ligne ; i++ )
         {
             for ( j=0 ; j<Colonne ; j++ )
                 {
                     Matrice[i][j]=MatriceA[i][j]+MatriceB[i][j];
                 }
         }
 
}
 
void Soustraire_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int Taille)
{
     int i,j;
 
     for ( i=0 ; i<Taille ; i++ )
         {
             for ( j=0 ; j<Taille ; j++ )
                 {
                     Matrice[i][j]=MatriceA[i][j]-MatriceB[i][j];
                 }
         }
 
}
 
void Afficher_Matrice(int **Matrice, int Colonne, int Ligne)
{
    int i, j;
 
    for ( i=0 ; i<Ligne ; i++ )
        {
              for ( j=0 ; j<Colonne ; j++)
                  {
                        printf("\nMatrice[%d][%d]=%d", i+1, j+1, Matrice[i][j]);
                  }
        }        
}                   
 
 
void Desallouer_Matrice( int **Matrice, int Colonne )
{
               int i;
 
               for ( i=1 ; i<Colonne ; i++ )
                   {
                         free(Matrice[i]);
                   }
 
               free(Matrice);
}                 
 
void Multiplier_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int ColonneA, int LigneA, int ColonneB, int LigneB )
{
     int i,j;
     int Repeter=0;
 
     for ( i=0 ; i<LigneA ; i++ )
         {
             for ( j=0 ; j<ColonneB ; j++ )
                 {
                     while ( Repeter != (ColonneA) )
                           {
                                     Matrice[i][j]=Matrice[i][j]+ MatriceA[i][Repeter]*MatriceB[Repeter][j];
                                     Repeter++;
                           }
                     Repeter=0;
                 }
         }
 
}

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
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include"./../bibliotheque.h"
 
int  **Allouer_Matrice               ( int **Matrice, int Colonne, int Ligne);
int  **Sommer_Matrice                ( int **Matrice, int **MatriceA, int **MatriceB, int Colonne, int Ligne);
int  **Soustraire_Matrice            ( int **Matrice, int **MatriceA, int **MatriceB, int Taille);
int  **Initialiser_Matrice           ( int **Matrice, int Colonne, int Ligne);
int  **Remplir_Matrice_Aleatoirement ( int **Matrice, int Colonne, int Ligne);
int  **Multiplier_Matrice            ( int **Matrice, int **MatriceA, int **MatriceB, int ColonneA, int LigneA, int ColonneB, int LigneB );
void   Afficher_Matrice              ( int **Matrice, int Colonne, int Ligne);
void   Desallouer_Matrice            ( int **Matrice, int Colonne );
 
int main (void)
{
    int **MatriceA;
    int **MatriceB;
    int **Matrice;
 
    MatriceA=Allouer_Matrice( MatriceA, 2, 3 );
    MatriceB=Allouer_Matrice( MatriceB, 4, 2 );
    Matrice=Allouer_Matrice ( Matrice , 4, 3 );
 
    MatriceA=Remplir_Matrice_Aleatoirement( MatriceA, 2, 3 );
    MatriceB=Remplir_Matrice_Aleatoirement( MatriceB, 4, 2 );
 
    Matrice =Initialiser_Matrice          ( Matrice , 4, 3 );
 
    Afficher_Matrice( MatriceA, 2, 3 );
    printf("\n");
    Afficher_Matrice( MatriceB, 4, 2 );
 
    Matrice=Multiplier_Matrice( Matrice, MatriceA, MatriceB, 2, 3, 4, 2 );
    printf("\n");
    Afficher_Matrice( Matrice, 4, 3 );
 
    Desallouer_Matrice( MatriceA, 2 );
    Desallouer_Matrice( MatriceB, 4 );
    Desallouer_Matrice( Matrice, 4 );
 
    getchar();
 
}
 
int **Allouer_Matrice(int **Matrice, int Colonne, int Ligne)
{    
 
      int i=0; 
 
      // Allouer les colonnes
      Matrice = malloc( Ligne*sizeof(int*) );
 
      // Allouer les lignes
      for ( i=0 ; i<Ligne ; i++)
          {
             Matrice[i]=malloc( Colonne*sizeof(int) );
          }  
 
      return Matrice;
}
 
int **Initialiser_Matrice(int **Matrice, int Colonne, int Ligne)
{
     int i, j;
 
     for ( i=0 ; i<Ligne ; i++ )
         {
               for ( j=0 ; j<Colonne ; j++ )
                   {
                        Matrice[i][j]=0;
                   }   
         }
 
     return Matrice;
}
 
int **Remplir_Matrice_Aleatoirement(int **Matrice, int Colonne, int Ligne)
{
     int i, j;
 
     for ( i=0 ; i<Ligne ; i++ )
         {
               for ( j=0 ; j<Colonne ; j++ )
                   {
                        Matrice[i][j]=rand()%3;
                   }   
         }
 
     return Matrice;
}
 
int **Sommer_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int Colonne, int Ligne)
{
     int i,j;
 
     for ( i=0 ; i<Ligne ; i++ )
         {
             for ( j=0 ; j<Colonne ; j++ )
                 {
                     Matrice[i][j]=MatriceA[i][j]+MatriceB[i][j];
                 }
         }
 
     return Matrice;
}
 
int **Soustraire_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int Taille)
{
     int i,j;
 
     for ( i=0 ; i<Taille ; i++ )
         {
             for ( j=0 ; j<Taille ; j++ )
                 {
                     Matrice[i][j]=MatriceA[i][j]-MatriceB[i][j];
                 }
         }
 
     return Matrice;
}
 
void Afficher_Matrice(int **Matrice, int Colonne, int Ligne)
{
    int i, j;
 
    for ( i=0 ; i<Ligne ; i++ )
        {
              for ( j=0 ; j<Colonne ; j++)
                  {
                        printf("\nMatrice[%d][%d]=%d", i+1, j+1, Matrice[i][j]);
                  }
        }        
}                   
 
 
void Desallouer_Matrice( int **Matrice, int Colonne )
{
               int i;
 
               for ( i=1 ; i<Colonne ; i++ )
                   {
                         free(Matrice[i]);
                   }
 
               free(Matrice);
}                 
 
int **Multiplier_Matrice( int **Matrice, int **MatriceA, int **MatriceB, int ColonneA, int LigneA, int ColonneB, int LigneB )
{
     int i,j;
     int Repeter=0;
 
     for ( i=0 ; i<LigneA ; i++ )
         {
             for ( j=0 ; j<ColonneB ; j++ )
                 {
                     while ( Repeter != (ColonneA) )
                           {
                                     Matrice[i][j]=Matrice[i][j]+ MatriceA[i][Repeter]*MatriceB[Repeter][j];
                                     Repeter++;
                           }
                     Repeter=0;
                 }
         }
 
     return Matrice;
}

Autant pour moi, je n'avais pas vu que dans ce que je t'avais dit il y avais Allouer_Matrice.

En fait, tu as un pointeur de type int**, pointeur qui pointe sur un tableau 2D.
Si tu envoi le tableau a une fonction qui va se charger de modifier son contenue, alors :
Code:

1 2 void ModifierCase(int **Tableau);
est correcte, il n'y a pas besoins de recuperer sa valeur par un return.

Par contre, si tu veux faire une fonction qui modifie le tableau en lui-meme, on ne peut plus faire comme ci dessus.
On peut faire de deux manieres :
Code:

1 2 3 4 5 6 void ChangerMatrice (int ***Tableau) { /* Desallocation du tableau */ /* Reallocation du tableau */ }
Ou bien :
Code:

1 2 3 4 5 6 7 int** ChangerMatrice (int **Tableau) { /* Desallocation du tableau */ /* Reallocation du tableau */ return NouveauTableau; }
C'est pour cette raison que le premier code ne fonctionne pas alors que le deuxieme fonctionne.

si on fait comme ceci, cela veut dire que la matrice resultat est passer par adresse ( ce que tu fais je pense ).
Code:

1 2 3 4 5 6 7 8 9 int **Allouer_Matrice ( int **Matrice, int Colonne, int Ligne); void Sommer_Matrice ( int **Matrice, int **MatriceA, int **MatriceB, int Colonne, int Ligne); void Soustraire_Matrice ( int **Matrice, int **MatriceA, int **MatriceB, int Taille); void Initialiser_Matrice ( int **Matrice, int Colonne, int Ligne); void Remplir_Matrice_Aleatoirement ( int **Matrice, int Colonne, int Ligne); void Multiplier_Matrice ( int **Matrice, int **MatriceA, int **MatriceB, int ColonneA, int LigneA, int ColonneB, int LigneB ); void Afficher_Matrice ( int **Matrice, int Colonne, int Ligne); void Desallouer_Matrice ( int **Matrice, int Colonne );