Discussion :

[Zoulou974]

Salut à tous, n'ayant pas trouvé de réponse dans la FAQ je lance ma question en discussion.

Pour mes besoins personnels, à savoir de la manipulation de matrices, je tente de me créer des fonctions qui simplifient la vie (genre initmatrix pour initialiser, printmatrix pour afficher...).
Vu que ces fonction prennent une matrice en argument, je leur déclare comme 1r argument du (int** matrice, ...).

1)Dans mon main, je déclarais au début naïvement

Code :

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

1
2
3
 
int matrice[5][6] ;  /*par exemple...*/
initmatrix (matrice,5,6,0); /*le 0 c'est ce qu'affecte la fonction partout*/

Sauf que là je me fais insulter par le compilateur. Je ne vois toujours pas bien pourquoi. Surtout que pour des tableaux "simples", d'entiers quoi, ca se passait bien.

2)Je ruse et je déclare dans le main

Code :

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

int** matrice ;

que je fais suivre par une allocation manuelle classique. J'appelle alors initmatrix(matrice,taille1,taille2,valeurdebase) ou printmatrix et tout se passe bien.
Par flemme et par souci de lisibilité je me dis que c'est moche de faire tout ça dans le main, j'écris une fonction allocmatrix, de façon à n'avoir qu'à écrire dans le main

Code :

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

1
2
3
4
5
 
int** matrice;
allocmatrix(matrice,taille1,taille2);  /*en supposant les entiers taillei définis avant*/
 
initmatrix(...)

Il va de soi que ca plante ... Grosso modo à ce stade le problème c'est que allocmatrix fait son job sans histoires mais à la sortie elle n'a rien fait sur matrice ... Je met ici le code de tout ca pour que vous y voyiez plus clair :

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
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
 
/*
***La fonction allocmatrix***
allocmatrix(matrix,p,q) donne une taille p,q à la matrice
*/
void allocmatrix (int** matrix, int taille1 , int taille2)
{
 matrix = (int**)malloc(taille1 * sizeof(int*)) ; 
 int k ;
 for(k=0; k<=(taille1-1);k++)
   {
    *(matrix + k)=(int*)malloc(taille2 * sizeof(int));
    printf("Valeur matrix[%d][0]= %d \n",k,matrix[k][0]);
    system("PAUSE");
   }
}
 
int main ()
{
 /*Prototypage*/
 void initmatrix (int**,int,int,int);
 void printmatrix (int**,int,int);
 void allocmatrix (int**,int,int) ;
 /*Fin prototypage*/
 
 
 int taille1 = 5 ; 
 int taille2 = 4 ;
 printf("ok ca va \n");
 system("PAUSE");
 
 /*Creation d'une matrice*/
 int** matrix;        
 allocmatrix(matrix,taille1,taille2) ;
 
 /*
 matrix = (int**)malloc(taille1 * sizeof(int*)) ; 
 int k ;
 for(k=0; k<=(taille1-1);k++)
   {
    matrix[k]=(int*)malloc(taille2 * sizeof(int));
   }
 */
 
 printf("je vais essayer d'acceder a matrix[1][0]\n");
 system("PAUSE");
 printf("matrix[1][1]=%d\n",matrix[1][0]);
/*C'est LA que ca plante, because je suis hors matrice semble t-il*/
 printf("j'aimerais bien etre affiche un jour, si ca pouvait ne pas bugger...\n");
 system("PAUSE");
 
 /*En fait ce qui est problématique c'est qu'en fait au sortir de la fonction allocmatrix, qui s'execute sans histoires, matrix n'a pas grandi ...
 qqch se fait en local chez allocmatrix mais pas sur l'argument... c zarb qd on regarde ma fonction initmatrix construite sur le 
 même modèle et qui pourtant marche
 Si je fais moi même les choses dans le main, cad si je fais executer le bloc de code mis en commentaire et que je n'appelle pas allocmatrix
 et ben là ca marche.*/
 
 
 initmatrix (matrix,taille1,taille2,0);
 printmatrix (matrix,taille1,taille2) ; 
 
system("PAUSE"); 
return(0);
}

Voilà l'endroit où ca plante est indiqué.

Evidemment ca ressemble fort aux ennuis qu'on a quand on passe par valeur un param qui doit être modifié.
Sauf que initmatrix lui n'a aucun problème pourvu que la matrice soit allouée dans le main avec les lignes que j'ai mises de coté par commentaire.
Sauf que si j'ai bien compris, un tableau EST un pointeur donc je ne vois pas pourquoi ca ne se passe pas bien avec les matrices.
Sauf qu'en essayant de passer en param &matrix , en ayant bien sûr déclaré le premier argument de alllocmatrix comme un int***, et en ayant remplacé toutes les occurences de matrix par *matrix dans le code de allocmatrix. Eh ben pout tout vous dire ca plante encore plus tôt. Au moment d'allouer matrix[1] en fait. Ca c'est une autre histoire ...




Alors si quelqu'un peut répondre à mes 2 problèmes (le 2 surtout ... histoire d'avoir enfin cette satanée fonction d'alloc) je lui en serais très reconnaissant.

Si vous voulez le code de initmatrix ou printmatrix pour voir, ou toute autre précision pas de problème.
Pour info, niveau compilateurs, j'utilise DevC++ sur mon ordi sous Windows et gcc sur les linux de mon école.

[Emmanuel Delahaye]

Pour mes besoins personnels, à savoir de la manipulation de matrices, je tente de me créer des fonctions qui simplifient la vie (genre initmatrix pour initialiser, printmatrix pour afficher...).
Vu que ces fonction prennent une matrice en argument, je leur déclare comme 1r argument du (int** matrice, ...).

Pourquoi ? Tu as appris ça où ? Tu peux citer un cours ou un prof qui t'a expliqué ça ou c'est de l'invention pure ? La programmation, c'est pas du hasard. Il y a des règles bien précises et il faut les suivre. Pour le C, comme l'indique ton livre de C, ça se passe comme ça :

Tableaux statiques :

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

Tableaux dynamiques :

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

[Melem]

Peut être trouveras-tu ce que tu cherches ici. Ou du moins quelques pistes.

[soria_t]

Bonjour, Melem

Une question de débutant encore. Dans le code que tu as donnée que signifie
for(i = 0; i < 4; printf("\n"), i++)

En fait c'est le printf que je ne comprends pas.

Merci

[stephl]

Dans le code que tu as donnée que signifie
for(i = 0; i < 4; printf("\n"), i++)

En fait c'est le printf que je ne comprends pas.

Il s'agit d'une utilisation de l'opérateur ','. La troisième partie d'un for peut être n'importe quoi et sera exécutée à la fin de chaque itération. Donc, ici, à chaque itération, on va à la ligne et on incrémente i.

[soria_t]

Merci beaucoup.

[souviron34]

Il s'agit d'une utilisation de l'opérateur ','. La troisième partie d'un for peut être n'importe quoi et sera exécutée à la fin de chaque itération. Donc, ici, à chaque itération, on va à la ligne et on incrémente i.

Mais c'est pas propre et peu lisible..... Donc à éviter...

Qu'est-ce que ça coûte de le mettre en tête de la boucle ???

[Melem]

que signifie
for(i = 0; i < 4; printf("\n"), i++)

En fait c'est le printf que je ne comprends pas.

Non c'est pas le printf() que tu ne comprends pas mais l'opérateur virgule. Alors un petit rappel de C : l'expression a, b, c, d, e, ... z vaut z. Exemple:

Code :

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

1
2
int a, b, c;
c = (a = 1, b = a-2, a != b);

On aura :
a = 1
b = -1
et c = VRAI (c'est-à-dire non nul) car a est en effet différent de b.

[Zoulou974]

La programmation, c'est pas du hasard. Il y a des règles bien précises et il faut les suivre

Je peux difficilement être plus d'accord.
D'ailleurs ça me chiffone, plus je sais de trucs en C plus j'ai l'impression qu'on peut écrire la même de 36 façons différentes ...

Pour le C, comme l'indique ton livre de C, ça se passe comme ça

je n'ai absolument aucun bouquin (physique) de C, même pas de cours privilégié sur internet, et pas particulièrement ces pages noos/emdel...

Pourquoi ? Tu as appris ça où ? Tu peux citer un cours ou un prof qui t'a expliqué ça ou c'est de l'invention pure ?

Euh, je ne sais pas trop à quoi fait référence le "ça", je suppose qu'il ne s'agit pas de ma phrase sur la simplification de la vie, mais plutôt qur le type d'une matrice et comment je la passe en argument.
Alors,
1)oui je peux citer les profs de mon école qui n'ont pas bondi au plafond quand je leur ai dit que mes matrices sont de type int** . Il y a aussi ce cours (en même temps c'est surement des gens qui se conaissent tout ça donc ...) http://snovae.in2p3.fr/ycopin/enseig.../info_DEA.html
Donc oui (dois rajouter hélas ??). Je t'avouerais qu'il m'ont l'air de s'y connaître un peu plus que moi par l'expérience et la largeur de leurs connaissances, mais je ne m'avancerai pas sur la profondeur.

2) Pour ce qui est du type d'un tableau de dim2 à valeurs entières, je continue de penser que c'est int**.
Si une fonction doit prendre en argument un entier :

Code :

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

1
2
3
4
5
6
 
type fonction (int argument) {...}
int main() 
{ int a=3; /*par expl*/
  type b = fonction(a) ; 
return0;}

Là on est d'accord. Bon et une matrice selon moi ca se déclare
int** matrice;
donc c'est de type int** (cad pointeur vers pointeur sur entier). Ensuite ma fonction initmatrix utilise cette logique et se porte à merveille.

___________________________


Sinon j'ai lu les liens indiqués, j'ai appris qu'on a pas besoin de caster les malloc.
Mais je reste sur ma faim concernant les pb.

1)Pour le pemier je ne vois toujours pas. Pas plus tard que dans la page http://emmanuel-delahaye.developpez.....htm#param_tab on fait pourtant quelque chose de très très similaire et ca passe. (avec clear(tab))

2)Ici vraiment je ne vois pas non plus.
Je pense pour une raison qui m'échappe, après allocmatrix ma matrice matrix n'a pas eu de memoire allouée.
J'ai un pote qui a évité le problème en écrivant ca :
avant le main

Code :

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

1
2
3
4
5
6
7
 
int ** new_matrix (int n, int m)
{  int **tab;
    int i;
    tab = (int **)calloc(n,sizeof(int *));
    for (i =0;i<n;i++) {tab[i] =(int *)calloc(m,sizeof(int));}  
    return (tab);}

et dans le main :

Code :

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

1
2
3
 
int **tab;
tab = new_matrix(5,6);

Là ca marche. Le principe est différent, ici new_matrix rend effectivement une matrice qu'on affecte dans le main à matrix ; au lieu de créer un matrice dans le main et que ce soit la fonction allocmatrix qui doive se charger de lui donner de la place.
Donc d'un point de vue pratique je peux continuer à avancer, mais le fait de ne pas comprendre qu'est ce qui ne marche pas ici c'est peu satisfaisant pour l'esprit...

[Emmanuel Delahaye]

D'ailleurs ça me chiffone, plus je sais de trucs en C plus j'ai l'impression qu'on peut écrire la même de 36 façons différentes ...

Il y a un peu de ça. C'est pourquoi il est indispensable d'avoir un livre de référence comme le K&R édition 2. Le C n'est pas un langage de débutant. Il faut 6 à 12 mois de formation sérieuse et de pratique intense pour le maitriser.

je n'ai absolument aucun bouquin (physique) de C, même pas de cours privilégié sur internet, et pas particulièrement ces pages noos/emdel...

C'est un tord. Maintenant, tu sais quoi faire, alors affaire réglée...

Euh, je ne sais pas trop à quoi fait référence le "ça", je suppose qu'il ne s'agit pas de ma phrase sur la simplification de la vie, mais plutôt qur le type d'une matrice et comment je la passe en argument.

Oui.

Alors,
1)oui je peux citer les profs de mon école qui n'ont pas bondi au plafond quand je leur ai dit que mes matrices sont de type int** .

Tu leur as dit que la matrice en question était statique ? Si c'est le cas, change d'école, et vite (je donne des cours si besoin est...)

Il y a aussi ce cours (en même temps c'est surement des gens qui se conaissent tout ça donc ...)

http://snovae.in2p3.fr/ycopin/enseig.../info_DEA.html

Tu parles du PDF 'Cours de langage C' de A. Pécontal ?

Ce que je lis sur le sujet est tout à fait correct (page 20). Je t'invite à le relire...

Donc oui (dois rajouter hélas ??). Je t'avouerais qu'il m'ont l'air de s'y connaître un peu plus que moi par l'expérience et la largeur de leurs connaissances, mais je ne m'avancerai pas sur la profondeur.

En tout cas, ce PDF me semble correct. Mais il n'explique pas comment passer un tableau à 2 dimensions. C'est pourquoi ce genre de complément est sur mon site... (adresse de l'article déjà indiquée)

2) Pour ce qui est du type d'un tableau de dim2 à valeurs entières, je continue de penser que c'est int**.

Si le tableau est statique, tu te trompes. Si il est dynamique, selon la méthode du tableau de pointeurs (page 20 du PDF), oui.

Si une fonction doit prendre en argument un entier :

Code :

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

1
2
3
4
5
6
 
type fonction (int argument) {...}
int main() 
{ int a=3; /*par expl*/
  type b = fonction(a) ; 
return0;}

Là on est d'accord.

OK.

Bon et une matrice selon moi ca se déclare
int** matrice;

Si c'est une matrice dynamique selon la méthode du tableau de pointeurs, oui.

Saurais-tu créer une telle matrice ?

1)Pour le pemier je ne vois toujours pas. Pas plus tard que dans la page http://emmanuel-delahaye.developpez.....htm#param_tab on fait pourtant quelque chose de très très similaire et ca passe. (avec clear(tab))

Cet article concerne les matrices statiques telle que tu en parlais au débit de ton post :

Code :

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

1
2
3
 
int matrice[5][6] ;  /*par exemple...*/
initmatrix (matrice,5,6,0); /*le 0 c'est ce qu'affecte la fonction partout*/

2)Ici vraiment je ne vois pas non plus.
Je pense pour une raison qui m'échappe, après allocmatrix ma matrice matrix n'a pas eu de memoire allouée.

C'est bien là tout le problème.

J'ai un pote qui a évité le problème en écrivant ca :
avant le main

Code :

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

1
2
3
4
5
6
7
 
int ** new_matrix (int n, int m)
{  int **tab;
    int i;
    tab = (int **)calloc(n,sizeof(int *));
    for (i =0;i<n;i++) {tab[i] =(int *)calloc(m,sizeof(int));}  
    return (tab);}

et dans le main :

Code :

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

1
2
3
 
int **tab;
tab = new_matrix(5,6);

Là ca marche. Le principe est différent, ici new_matrix rend effectivement une matrice qu'on affecte dans le main à matrix ; au lieu de créer un matrice dans le main et que ce soit la fonction allocmatrix qui doive se charger de lui donner de la place.

Cette méthode est tout à fait correcte dans le principe (mais mal codée, comme souvent, malheureusement...).

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
int ** new_matrix (size_t n, size_t m)
{  
   /* allocation du tableau de pointeurs */
   int ** tab = malloc (n * sizeof *tab);
   if (tab != NULL)
   {
      int err = 0;
      size_t i;
      for (i  = 0; i < n; i++) 
      {
         /* allocation des tableaux d'int */
         tab[i] = malloc (m * sizeof *tab[i]);
 
         /* verification */
         err |= tab[i] == NULL;
         if (!err)
         {
            /* OK : mise a 0 du tableau d'entier */
            size_t j;
            for (j = 0; j < m; j++)
            {
               tab[i][j] = 0;
            }
         }  
      }  
 
      if (err)
      {
         /* erreur d'allocation : liberation de tout ce qui a ete alloue' 
             EDIT : mise au point (non compilé)...
          */
         size_t i;
         for (i  = 0; i < n; i++) 
         {
            free(tab[i]), tab[i] = NULL;
         }
         free (tab), tab = NULL;
      }
   }
   return tab;
}

http://emmanuel-delahaye.developpez....tes.htm#size_t

Elle créée un espace mémoire organisé de telle façon qu'il soit accessible avec la notation [][]. Mais c'est n'est pas un 'tableau à 2 dimensions'. C'est un tableau de pointeurs sur des tableaux de type int.

Donc d'un point de vue pratique je peux continuer à avancer, mais le fait de ne pas comprendre qu'est ce qui ne marche pas ici c'est peu satisfaisant pour l'esprit...

Est-ce que tu fais bien la différence entre un objet statique et un objet dynamique ?

[Melem]

Bon il faut que je réécrive ce que j'ai écrit il y quelques jours on dirait. C'est pas grave, mais je vais résumer. Si tu définis une matrice comme suit:

Code :

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

typedef int ** MATRICE;

Et que tu déclares une variable - disons A par exemple - comme étant de type MATRICE, alors une allocation dynamique d'un objet de type MATRICE doit ressembler à l'une des deux formes suivantes:

Code :

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

A = AllocMatrice(5, 3);

ou :

Code :

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

AllocMatrice(&A, 5, 3);

Dans ce dernier cas le prototype pour AllocMatrice est donc :

Code :

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

void AllocMatrice(MATRICE * p_A, int n, int m);

Pour ce qui est du type d'un tableau de dim2 à valeurs entières, je continue de penser que c'est int**.

Non! c'est un int *, et pareil pour un tableau à 10 000 dimensions.

Une déclaration :

Code :

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

int t[5][8][3][20];

par exemple est tout simplement équivalente à :

Code :

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

int t[ 5*8*3*20 ];

Et on a :

Code :

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

t[i][j][k][l] == t[ i*8*3*20   +   j*3*20   +   k*20   +   l ]

[crocodilex]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int ** new_matrix (size_t n, size_t m)
{  
      [...]

      if (err)
      {
         /* erreur d'allocation : liberation de tout ce qui a ete alloue' */
         free(tab[i]), tab[i] = NULL;
         free (tab), ab = NULL;
      }

      [...]
}

Tu as loupé une boucle.... + une erreur de frappe dans le dernier free.

[Emmanuel Delahaye]

Tu as loupé une boucle.... + une erreur de frappe dans le dernier free.

Corrigé, merci.

[Médinoc]

Je ne peux pas rajouter grand-chose à ce qu'a dit Emmanuel sur l'importance de la différence entre matrices statiques et dynamiques.
Sans compter qu'on peut faire plus tordu, comme allouer dynamiquement une matrice aux dimensions statiques (attention, GROS risque de confusion).

Mais pour l'allocation de matrices dynamiques, je serais plus du genre à conseiller des fonctions plus simples: Pas plus d'une allocation par dimension :

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/* Autre fonction d'allocation
   --------------------------- */
double ** AutreAllocTable2D(
 size_t taille1, /*[in] Nb de lignes */
 size_t taille2  /*[in] Nb de valeurs par ligne */
 )
{
    double ** ppValeurs;
    size_t const taille1x2 = taille1*taille2;
    if(taille1x2 / taille2 != taille1)
        return NULL; /*Débordement des tailles*/
 
    ppValeurs = malloc(sizeof(*ppValeurs)*taille1);
    if(ppValeurs != NULL)
    {
        double * pValeurs = malloc(sizeof(*pValeurs)*taille1x2);
        if(pValeurs != NULL)
        {
            size_t i;
            /* Affecter tous les pointeurs */
            for(i=0 ; i<taille1 ; ++i)
                ppValeurs[i] = pValeurs + (i*taille2);
        }
        else
        {
            /* Echec de la seconde allocation, liberer la premiere */
            free(ppValeurs), ppValeurs=NULL;
        }
    }/*if*/
    return ppValeurs;
}
 
/* Autre fonction de destruction
   ----------------------------- */
void AutreFreeTable2D(double **ppValeurs)
{
    if(ppValeurs != NULL)
    {
        free(ppValeurs[0]);
        free(ppValeurs);
    }
}

Attention, ce n'est absolument pas compatibles avec les fonctions d'Emmanuel : Ne pas mélanger les deux.

Edit: Une paire de petits schémas illustrant les différents concepts :

Et aussi une version avec affichage de débogage.
Et La version C++.