Discussion :

[panda31]

Bonjour, cette fois mon problème est digne de ce nom...

Le contexte est un test du module "Creux". Je crée une matrice simple de nc colonnes et nl lignes. Je la remplis de 0.000 et de 2.000 (des double). Je veux la faire afficher par une fonction contenue dans un module annexe (en version inline cela marche mais je teste le passage des paramètres pour un tableau à deux dimensions...) qui se nomme AffMatSimple. Dans un second temps, je veux faire construire une matrice creuse à partir de cette matrice simple mais le programme stoppe dès que j'entre dans une fonction gérant des tableaux à deux dimensions...

EN-TÊTE DE AffMatSimple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#include <stdlib.h>
#include <stdio.h>
 
int AffMatSimple(double **, int, int);

CORPS :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <stdio.h>
#include <stdlib.h>
#include "AffMatSimple.h"
 
int AffMatSimple(double ** mat, int nl, int nc){
    int i, j;
 
    for (i=0; i<nl; i++){
 
        printf("\nLigne %d :",i);
        for (j=0; j<nc; j++){
            printf("%lf | ", mat[i][j]);
        }
    }
    printf("\n\n") ;
    return 0;
}

Moi je pensais que cela irait mais dès que je rentre dans cette fonction , le programme s'arrête... Et pourtant ça compile ! Mais ce n'est pas une fin en soit je sais. Le problème semble se situer dans le passage en paramètres de la matrice. Je vous envoie tous les fichiers relatifs pour vous faire une idée.

Merci d'avance pour vos avis et conseils.

[fearyourself]

Logique, tu déclares ton tableau comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 	double MatSimple[TAILLE_L][TAILLE_C]; /*Matrice simple à traiter*/

Mais ta fonction est déclarée comme étant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int AffMatSimple(double **, int, int);

Les deux écritures n'ont rien à voir (le calcul de la case contenant l'information qui te faut n'est pas du tout pareil)...

C'est logique que ton programme plante...

Jc

[panda31]

Logique, tu déclares ton tableau comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

     double MatSimple[TAILLE_L][TAILLE_C]; /*Matrice simple à traiter*/

Mais ta fonction est déclarée comme étant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int AffMatSimple(double **, int, int);

Les deux écritures n'ont rien à voir (le calcul de la case contenant l'information qui te faut n'est pas du tout pareil)...

C'est logique que ton programme plante...

Jc

Tu peux développer stp ? Je croyais profondément que j'avais le droit de procéder ainsi...

[Emmanuel Delahaye]

Tu peux développer stp ? Je croyais profondément que j'avais le droit de procéder ainsi...

Tu confonds "pointeur de pointeur" et "tableau à 2 dimensions". Absolument rien à voir.

http://emmanuel-delahaye.developpez.....htm#param_tab

[panda31]

f (int p[])
f (int p[12])
f (int p[][34])
f (int p[56][78])
etc.

Ok... Mais cela veut dire que pour mon en-tête, je mets quoi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

AffMatSimpe(double);

c'est ça ???


Merci pour l'éclaircissement ! J'ai l'air con mais pas con !

[fearyourself]

La première écriture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 	double MatSimple[TAILLE_L][TAILLE_C]; /*Matrice simple à traiter*/

est une zone contigüe en mémoire, l'adresse de chaque case pouvant être calculé comme étant un tableau à une dimension :

MatSimple[i][j] == MatSimple1D[i*TAILLE_C + j]

C'est donc un calcul arithmétique qui permet d'obtenir la bonne case...

La 2ème écriture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int AffMatSimple(double **, int, int);

Dit qu'on a un pointeur de pointeurs... Donc pas forcément une zone contigüe. La première dimension étant un pointeur qui va nous donner l'adresse de la ligne de la 2ème dimension.

Pour obtenir l'adresse de la case (i,j), on doit donc obtenir l'adresse contenu dans la case MatSimple[i]. Ceci nous donne le début de la i-ème ligne et on ira à la j-ème case pour obtenir la case voulue.

Pour obtenir la valeur de la case, on doit donc faire une indirection en mémorie...

C'est donc vraiment différent comme approche et en se mélangeant les deux, le compilateur va faire les mauvais calculs, ce qui provoquera une erreur...

Jc

[panda31]

La première écriture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

     double MatSimple[TAILLE_L][TAILLE_C]; /*Matrice simple à traiter*/

est une zone contigüe en mémoire, l'adresse de chaque case pouvant être calculé comme étant un tableau à une dimension :

MatSimple[i][j] == MatSimple1D[i*TAILLE_C + j]

C'est donc un calcul arithmétique qui permet d'obtenir la bonne case...

c'est pas plutôt MatSimple1D[i*TAILLE_L + j] (L pour ligne) ?

Merci à tous en tout cas... Je me coucherai bien moins bête...

[fearyourself]

c'est pas plutôt MatSimple1D[i*TAILLE_L + j] (L pour ligne) ?

Merci à tous en tout cas... Je me coucherai bien moins bête...

Non, fait un dessin, tu verras que c'est bien i*TAILLE_C
Jc

[Emmanuel Delahaye]

Ok... Mais cela veut dire que pour mon en-tête, je mets quoi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

AffMatSimpe(double);

c'est ça ???

Le prototype de la fonction doit être ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void AffMatSimpe(double MatSimple[TAILLE_L][TAILLE_C]);

[panda31]

Donc si j'ai bien compris, lorsque j'ai une matrice comme :
________________
| x | x | x | x |
________________
| x | Y | x | x |
________________
| x | x | x | x |
________________
| x | x | x | x |
________________
| x | x | x | x |


Pou accéder à l'élément de valeur Y, je dois faire : mat[i*nc+j] avec i=1, nc=4, j=1 => mat[5] ?

[fearyourself]

Donc si j'ai bien compris, lorsque j'ai une matrice comme :
________________
| | | | |
________________
| | X | | |
________________
| | | | |
________________
| | | | |
________________
| | | | |
_________________


Pou accéder à l'élément de valeur X, je dois faire : mat[i*nc+j] avec i=1, nc=4, j=1 => mat[5] ?

Non, si c'est un tableau à 2 dimensions, tu fais mat[i][j] mais le compilateur traite le tableau comme une dimension et donc modifie ton code comme tu l'as fait.

Jc

[panda31]

COMPILATION :

--------------------Configuration: TEST_Flexible_MinGW - Debug--------------------
Compiling source file(s)...
test.c
In file included from test.c:12:
AffMAtSimple.h:4: error: `TAILLE_L' undeclared here (not in a function)
AffMAtSimple.h:4: error: `TAILLE_C' undeclared here (not in a function)
In file included from test.c:12:
AffMAtSimple.h:4:56: warning: no newline at end of file
test.c: In function `main':
test.c:35: warning: implicit declaration of function `AffMatSimple'
test.c:59: warning: passing arg 1 of `matrice_creuse' from incompatible pointer type

TEST_Flexible_MinGW.exe - 2 error(s), 3 warning(s)

J'avoue que je patoge un peu bcp dans l'adaptation de mon code...

[Emmanuel Delahaye]

J'avoue que je patoge un peu bcp dans l'adaptation de mon code

patauge...

Il est clair que la définition des 2 constantes doit être déplacée dans le .h qui contient le prototype qui les utilise. C'est la seule façon qu'elles soient connues de tous... C'est du simple bon sens, non ?

D'une manière générale, un header contient des prototypes de fonctions et tout ce qui est nécessaire à la définition de ceux-ci (headers, constantes, types, structures...) Ni plus, ni moins.

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

Par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
#include <stdlib.h>
#include <stdio.h>
 
int AffMatSimpe(double MatSimple[TAILLE_L][TAILLE_C]);

Ben c'est pas terrible.

• Les deux includes ne servent à rien
• Il manque la définition des deux constantes
• Il n'y a pas de protection contre les inclusions multiples.

Je préconise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
/* xxx.h */
#ifndef H_XXX
#define H_XXX
 
#define TAILLE_L xx
#define TAILLE_C yy
 
int AffMatSimpe(double MatSimple[TAILLE_L][TAILLE_C]); 
 
#endif /* guard */

A toi de mettre les bonnes valeurs pour xxx, XXX, xx et yy...

[panda31]

patauge...

Il est clair que la définition des 2 constantes doit être déplacée dans le .h qui contient le prototype qui les utilise. C'est la seule façon qu'elles soient connues de tous... C'est du simple bon sens, non ?

D'une manière générale, un header contient des prototypes de fonctions et tout ce qui est nécessaire à la définition de ceux-ci (headers, constantes, types, structures...)

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

Oui patauge pardon !

Oui mais, si j'utilise plusieurs fois la fonction avec des matrices de tailles différentes, je suis dans la caca non ?

[Emmanuel Delahaye]

Oui patauge pardon !

Oui mais, si j'utilise plusieurs fois la fonction avec des matrices de tailles différentes, je suis dans la caca non ?

C'est toi qui a défini une matrice de taille fixe. Il faut assumer. Si tu veux du code souple, c'est une autre approche.

http://emmanuel-delahaye.developpez.com/tad.htm

[panda31]

patauge...

Il est clair que la définition des 2 constantes doit être déplacée dans le .h qui contient le prototype qui les utilise. C'est la seule façon qu'elles soient connues de tous... C'est du simple bon sens, non ?

D'une manière générale, un header contient des prototypes de fonctions et tout ce qui est nécessaire à la définition de ceux-ci (headers, constantes, types, structures...) Ni plus, ni moins.

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

Par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
#include <stdlib.h>
#include <stdio.h>
 
int AffMatSimpe(double MatSimple[TAILLE_L][TAILLE_C]);

Ben c'est pas terrible.

• Les deux includes ne servent à rien
• Il manque la définition des deux constantes
• Il n'y a pas de protection contre les inclusions multiples.

Je préconise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
/* xxx.h */
#ifndef H_XXX
#define H_XXX
 
#define TAILLE_L xx
#define TAILLE_C yy
 
int AffMatSimpe(double MatSimple[TAILLE_L][TAILLE_C]); 
 
#endif /* guard */

A toi de mettre les bonnes valeurs pour xxx, XXX, xx et yy...

Pour la syntaxe à la rache => c'est du test pas de l'art dans ce cas... Tous mes modules sont habituellement structurés comme vous dites !

[panda31]

Avec toutes ces remarques constructives, je vais m'employer tout de suite à faire un TAD GestionMatrice avec les constructeurs primaires/secondaires, destructeurs et observateurs.

Pour la généricité en C, suffit-il de changer un #define ELEMENT double par exemple ?

Merci pour tout.

[Emmanuel Delahaye]

Avec toutes ces remarques constructives, je vais m'employer tout de suite à faire un TAD GestionMatrice avec les constructeurs primaires/secondaires, destructeurs et observateurs.

Pour la généricité en C, suffit-il de changer un #define ELEMENT double par exemple ?

Pour avoir un type générique ? Oui, mais il faut recompiler... Pour être complètement souple, c'est plus compliqué, mais c'est faisable.

Pas trop le temps, là, c'est bientôt le foot... Faut pas rigoler avec ça...

[panda31]

Bon, la nuit est passée, le 0-0 de la France digéré... J'espère que mes idées sont un peu plus claires qu'hier où j'étais réellement à la masse !

Donc, OUI, je veux faire une approche SANS taille fixe !
Je me base donc sur le module matd que Emmanuel Delahaye m'a indiqué sur sa page (fort intéressante au passage !).

Pour passer une matrice de double en paramètre d'une fonction, je procède par un passage d'une structure c'est ça ?

size_t est défini comment ? C'est un type inclus par défaut dans le C ? ou alors le définit-t-on dans le code (je le vois pas...) ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
struct matd
{
   size_t nb_colonnes;
   size_t nb_lignes;
   double *tab;
};

double *tab contient une seule ligne je me trompe ? Comment on parcourt les différents éléments...?

Merci pour tout

[fearyourself]

Pour passer une matrice de double en paramètre d'une fonction, je procède par un passage d'une structure c'est ça ?

Pas forcément, tu peux passer le tableau et les tailles du tableau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
void Tab(double **Mat, int l, int c);

Vu que tu veux une taille dynamique, c'est ce qu'il y a de mieux (ou la structure)

size_t est défini comment ? C'est un type inclus par défaut dans le C ? ou alors le définit-t-on dans le code (je le vois pas...) ?

Il suffit d'avoir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <stdlib.h>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
struct matd
{
   size_t nb_colonnes;
   size_t nb_lignes;
   double *tab;
};

Pour une matrice, ce serait plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
struct matd
{
   size_t nb_colonnes;
   size_t nb_lignes;
   double **tab;
};

double *tab contient une seule ligne je me trompe ? Comment on parcourt les différents éléments...?

Si tu veux garder ce système d'une ligne, tu fais le calcul que j'ai montré plus haut...

Jc