Problème struture - malloc

**dj.motte** · 13/05/2007, 14h45

Salut,

Avec linux, ok :

Code :

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

1
2
3
 
char * z = (char *) malloc( sizeof(NULL)) ;
free( z );

Maintenant essayons :

char * z = (char *) malloc( NULL) ;
free(z) ;

On va voir...En principe le système reste stable.

**dj.motte** · 13/05/2007, 14h58

Salut,

Les systèmes sont restés stables. Ma dernière allocation mémoire ne tourne pas. Ce qui invite à penser que l'on peut faire de grosses erreurs dans l'allocation de la mémoire en C, sans pour autant plomber le système.

Raison de plus à les corriger.

**Emmanuel Delahaye** · 13/05/2007, 15h08

Envoyé par dj.motte

Lorsque je fais free(z) j'ai l'habitude de faire après, z=0 ou NULL. Est-ce une mauvaise habitude ?

C'est une bonne habitude, mais NULL est plus clair que 0. Attention, ça ne règle pas les problèmes d'aliasing.

**Emmanuel Delahaye** · 13/05/2007, 15h14

Envoyé par dj.motte

Dans cette fonction :
<...>
Si "mapile" est NULL ou 0, le dernier "free(mapile)" dans "libererPile" va planter. A moins que je ne connaisse pas bien le free du C.

On ne peut pas faire un "free(0)" ou un "free(NULL)" en C, à ma connaissance, mais je peux me tromper.

Tu as raison, ce n'est pas bon, mais pas pour la raison que tu crois. Si mapile vaut NULL, if (mapile->tab != NULL) invoque un comportement indéfini. Il faut donc corriger en :

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
 
void libererPile (pile * mapile)
{
   if (mapile != NULL)
   {
      if (mapile->tab != NULL)
      {
         int i;
         for (i = 0; i < mapile->taille; i++)
         {
            libererPiece (mapile->tab[i]);
         }
         free (mapile->tab);       /* -ed- */
      }
      free (mapile);
   }
}

(personnellement, je mettrais i et taille en size_t...)

Par contre free(0) (ou free (NULL)) est correct (contrairement à fclose(NULL) qui invoque un UB).

gl · 13/05/2007, 18h41

Envoyé par dj.motte

Que donnerait :

Code :

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

1
2
 
char * z = (char*) malloc( sizeof( NULL ) ) ;

Peut-être un truc qui fait mal au système ?

Je vais essayer. Je déconnecte, puis je reprendrai après les essais.

Quel rapport avec free(NULL) ???

**Médinoc** · 15/05/2007, 09h28

Envoyé par dj.motte

Que donnerait :

Code :

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

1
2
 
char * z = (char*) malloc( sizeof( NULL ) ) ;

Peut-être un truc qui fait mal au système ?

Pour moi, c'est surtout un comportement indéfini sur une architecture où un pointeur n'a pas la taille d'un entier, selon la définition de NULL ((void*)0 ou 0).
Et ça peut aussi ne pas compiler dans le second cas: je ne suis pas sûr que sizeof(0) soit valide en C...

PS: Le cast est inutile sur un compilateur respectueux des normes.

**Emmanuel Delahaye** · 15/05/2007, 15h44

Envoyé par Médinoc

je ne suis pas sûr que sizeof(0) soit valide en C.

Si, tout à fait. 0 est une expression constante de type int, ça donne la taille d'un int.

De même sizeof (2 - 2) ou sizeof (12 * 34)

**lamoua76** · 16/05/2007, 11h02

Bonjour me revoilà !

J'aimerais créer une matrice de pointeurs de pile. Sachant que j'ai "l'habitude" de déclarer des matrices de int en int ** je pensais que pour une matrice de pointeurs de piles il suffisait de faire pile***. En regardant sur le net j'ai lu que ce n'était apparement pas correct.

Comment fonctionnent les matrices de pointeurs svp? (je trouve pas grand chose là-dessus).

Merci !

**Médinoc** · 16/05/2007, 11h05

Ben si c'est pareil, mais il faut être sûr que ta matrice de pointeurs est correctement allouée...
Typiquement, ça s'alloue ainsi, une allocation par dimension :
http://www.developpez.net/forums/sho...70&postcount=7

Ici, tu remplaces "double" par "pile *".
Mais il ne faudra pas oublier d'initialiser tes pointeurs à NULL après allocation...

**lamoua76** · 16/05/2007, 19h56

Rebonjour à tous.

Je n'arrive toujours pas à faire cette matrice de pointeurs de piles. Voici mon code :

Code :

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

1
2
3
4
5
6
7
8
9
10
/* le pile.h */
 
#include "piece.h"
 
typedef struct pile pile;
 
pile *createPile (int);
int putPiece (pile *, piece *);
void affichePile (pile *);
void libererPile (pile *);

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
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
/*Ville*/
#include <stdio.h>
#include <stdlib.h>
#include "grille.h"
 
struct grille{
	char* nom;
	pile*** grille; //matrice de pile
	int rang;
    int nb_elem;
};
 
grille *createGrille (int taille,char *nom){
   grille *magrille = malloc (taille * sizeof(magrille));
   if (magrille != NULL){
      magrille->grille = malloc (taille * sizeof (pile**));
      if (magrille->grille != NULL){
         int i,j;
 
         for (i = 0; i < taille; i++){
	         magrille->grille[i] = malloc(taille * sizeof (pile*));
    	     if(magrille->grille[i] != NULL){
    		    for (j = 0; j < taille; j++){
    			    magrille->grille[i][j] = NULL;
    		    }
    	     }
    	    else{
    	    	free (magrille), magrille = NULL;
    	    }
         }
         magrille->nom = nom;
         magrille->rang = taille;
         magrille->nb_elem = 0;
      }
      else{
         free (magrille), magrille = NULL;
      }
   }
   return magrille;
}
 
void afficheGrille(grille * magrille){
     if(magrille != NULL){
         int i,j;
         for(i=0;i<magrille->rang;i++){
             for(j=0;j<magrille->rang;j++){
                 affichePile(magrille->grille[i][j]);
             }
         }
     }
}
 
void libererGrille (grille * magrille)
{
   if (magrille->grille != NULL)
   {
      int i,j;
      for (i = 0; i < magrille->rang; i++)
      {
          for (j = 0; j < magrille->rang; j++)
          {
              if(magrille->grille[i][j] != NULL)
                  libererPile (magrille->grille[i][j]);
          }
          free(magrille->grille[i]);
      }
      free (magrille->grille);
   }
   free (magrille);
}
 
void putPile(grille * magrille,pile * mapile){
    magrille->grille[0][0] = mapile;  
    magrille->grille[0][1] = mapile;
    magrille->grille[0][2] = mapile;
    magrille->grille[0][3] = mapile;
    magrille->grille[0][4] = mapile;
 
    magrille->grille[1][0] = mapile;
    magrille->grille[1][1] = mapile;
    magrille->grille[1][2] = mapile;
    magrille->grille[1][3] = mapile;
    magrille->grille[1][4] = mapile;
 
    magrille->grille[2][0] = mapile;
    magrille->grille[2][1] = mapile;
    magrille->grille[2][2] = mapile;
    magrille->grille[2][3] = mapile;
    magrille->grille[2][4] = mapile;
 
    magrille->grille[3][0] = mapile;
    magrille->grille[3][1] = mapile;
    magrille->grille[3][2] = mapile;
    magrille->grille[3][3] = mapile;
    magrille->grille[3][4] = mapile;
 
    magrille->grille[4][0] = mapile;
    magrille->grille[4][1] = mapile;
    magrille->grille[4][2] = mapile;
    magrille->grille[4][3] = mapile;
    magrille->grille[4][4] = mapile;
 
    affichePile(magrille->grille[0][0]);
}

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/* le main de pile.c */
 
#include <stdio.h>
#include "grille.h"
 
int main (void)
{
   piece *mapiece1;
   piece *mapiece2;
   piece *mapiece3;
   piece *mapiece4;
   pile *mapile;
   int err;
   grille *magrille;
   printf ("debut\n");
   mapile = createPile (1);
 
   mapiece1 = createPiece (1, 1);
   affichePiece (mapiece1);
 
   mapiece2 = createPiece (2, 2);
   affichePiece (mapiece2);
 
   mapiece3 = createPiece (3, 3);
   affichePiece (mapiece3);
 
   mapiece4 = createPiece (4, 4);
   affichePiece (mapiece4);
 
   printf ("debut ajout\n");
 
   err = putPiece (mapile, mapiece1);
   printf ("err=%d\n", err);
   if (err)
   {
      libererPiece (mapiece1);
   }
   mapiece1 = NULL;
 
   printf ("ca devrait planter\n");
   err = putPiece (mapile, mapiece2);
   printf ("err=%d\n", err);
   if (err)
   {
      libererPiece (mapiece2);
   }
   mapiece2 = NULL;
 
   err = putPiece (mapile, mapiece3);
   printf ("err=%d\n", err);
   if (err)
   {
      libererPiece (mapiece3);
   }
   mapiece3 = NULL;
 
   err = putPiece (mapile, mapiece4);
   printf ("err=%d\n", err);
   if (err)
   {
      libererPiece (mapiece4);
   }
   mapiece4 = NULL;
 
   affichePile (mapile);
 
   //libererPile (mapile), mapile = NULL;
 
   magrille=createGrille(5,"toto");
   putPile(magrille,mapile);
 
   afficheGrille(magrille);
 
    libererGrille(magrille);
   system("pause");
   printf ("fin\n");
 
 
   return 0;
}

La fonction putPile est un test qui montre que les ajouts au sein de la matrice semblent fonctionnés mais lorsque je lance l'affichage d'un de ses éléments (qui doit être un pointeur de pile) le programme se termine brutalement.

Encore une erreur de méthode de création de la matrice je pense.

Quelqu'un pourrait m'aider svp

?

EDIT : en fait ça marche j'avais fais une erreur dans mes tests.

**Médinoc** · 16/05/2007, 23h19

Code :

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

grille *magrille = malloc (taille * sizeof(magrille));

Ça me parait une erreur, ça...

**Emmanuel Delahaye** · 17/05/2007, 10h50

Envoyé par lamoua76

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
/*Ville*/
grille *createGrille (int taille,char *nom){
   grille *magrille = malloc (taille * sizeof(magrille));
   if (magrille != NULL){
      magrille->grille = malloc (taille * sizeof (pile**));
      if (magrille->grille != NULL){
         int i,j;
 
         for (i = 0; i < taille; i++){
	         magrille->grille[i] = malloc(taille * sizeof (pile*));
    	     if(magrille->grille[i] != NULL){
    		    for (j = 0; j < taille; j++){
    			    magrille->grille[i][j] = NULL;
    		    }
    	     }
    	    else{
    	    	free (magrille), magrille = NULL;
    	    }
         }
         magrille->nom = nom;
         magrille->rang = taille;
         magrille->nb_elem = 0;
      }
      else{
         free (magrille), magrille = NULL;
      }
   }
   return magrille;
}

Je te conseille de coder selon le principe :

Code :

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

T *p = malloc (n * sizeof *p);

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

C'est beaucoup plus clair et ça provoque moins d'erreur.

Ca donne :

Code :

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

1
2
3
4
5
6
 
   grille *magrille = malloc (taille * sizeof *magrille);
   <...>
      magrille->grille = malloc (taille * sizeof *magrille->grille);
   <...>
	 magrille->grille[i] = malloc(taille * sizeof *magrille->grille[i]);

**lamoua76** · 17/05/2007, 12h25

Envoyé par Emmanuel Delahaye

Je te conseille de coder selon le principe :

Code :

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

T *p = malloc (n * sizeof *p);

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

C'est beaucoup plus clair et ça provoque moins d'erreur.

Ca donne :

Code :

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

1
2
3
4
5
6
 
   grille *magrille = malloc (taille * sizeof *magrille);
   <...>
      magrille->grille = malloc (taille * sizeof *magrille->grille);
   <...>
	 magrille->grille[i] = malloc(taille * sizeof *magrille->grille[i]);

c'est effectivement plus clair

Maintenant j'ai un autre soucis.
Ceci fonctione bien : affichePile(magrille->grille[i][j]);
Mais si je veux par exemple faire : magrille->grille[i][j]->position j'ai le droit à un beau "dereferencing pointer to incomplete type ;" à la compil. Pourtant magrille->grille[i][j] est cencée contenir un pointeur de pile (car mon affichePile fonctionne) mais je ne peux pas accéder à l'attribut position de la structure vers laquel il pointe??

Où est l'erreur dans mon résonnement svp ?

**Emmanuel Delahaye** · 17/05/2007, 12h59

Envoyé par lamoua76

Mais si je veux par exemple faire : magrille->grille[i][j]->position j'ai le droit à un beau "dereferencing pointer to incomplete type ;" à la compil. Pourtant magrille->grille[i][j] est cencée contenir un pointeur de pile (car mon affichePile fonctionne) mais je ne peux pas accéder à l'attribut position de la structure vers laquel il pointe??

C'est normal. Le contenu de 'pile' n'est pas connu, car j'ai utilisé une technique qui interdit l'accès aux données internes de l'objet. (ADT ou TAD)

Code :

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

1
2
3
 
/* pile.h */
typedef struct pile pile;

Pour y accéder, il faut créer une ou des fonctions 'accesseur' qui autorisent un accès en lecture ou en écriture à un ou des champs selon les besoins.

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

C'est une technique un peu avancée utilisée en programmation professionnelle. Elle s'inspire des bases de la POO.

**lamoua76** · 17/05/2007, 13h27

Envoyé par Emmanuel Delahaye

C'est normal. Le contenu de 'pile' n'est pas connu, car j'ai utilisé une technique qui interdit l'accès aux données internes de l'objet. (ADT ou TAD)

Code :

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

1
2
3
 
/* pile.h */
typedef struct pile pile;

Pour y accéder, il faut créer une ou des fonctions 'accesseur' qui autorisent un accès en lecture ou en écriture à un ou des champs selon les besoins.

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

C'est une technique un peu avancée utilisée en programmation professionnelle. Elle s'inspire des bases de la POO.

ah là la POO ça me parle

.
Donc si j'ai bien compris, à la façon d'écriture de classes, dans pile.c je dois écrire un getPosition(pile * mapile) , etc ... pour chacuns des attributs des strucutres? J'essaies ça de suite.

EDIT : Effectivement tu m'as mis sur la bonne piste

Merci !

**Emmanuel Delahaye** · 17/05/2007, 13h47

Envoyé par lamoua76

Donc si j'ai bien compris, à la façon d'écriture de classes, dans pile.c je dois écrire un getPosition(pile * mapile) , etc ... pour chacuns des attributs des strucutres? J'essaies ça de suite.

Uniquement ceux dont tu as besoin... (poo : "les attributs public").

**lamoua76** · 17/05/2007, 17h07

Me revoilà.

A force de réutiliser mon code je me pose la question suivante :

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
pile *createPile (int taille)
{
   pile *mapile = malloc (taille * sizeof(*mapile));
   if (mapile != NULL)
   {
      mapile->tab = malloc (taille * sizeof(*mapile->tab));
      if (mapile->tab != NULL)
      {
         int i;
         for (i = 0; i < taille; i++)
         {
            mapile->tab[i] = NULL;
         }
         mapile->position = 0;
         mapile->taille = taille;
         mapile->hauteur = 0;
      }
      else
      {
         free (mapile), mapile = NULL;
      }
   }
   return mapile;
}

pourquoi avoir fait :
pile *mapile = malloc (taille * sizeof(*mapile));
et pas
pile *mapile = malloc (sizeof(*mapile));
?
En effet, "taille" me sert à déterminer le nombre d'éléments du tableau de piece de la structure pile. Là j'ai l'impression d'allouer taille fois piles. Non ?

**Emmanuel Delahaye** · 17/05/2007, 19h59

Envoyé par lamoua76

pourquoi avoir fait :
pile *mapile = malloc (taille * sizeof(*mapile));
et pas
pile *mapile = malloc (sizeof(*mapile));
?
En effet, "taille" me sert à déterminer le nombre d'éléments du tableau de piece de la structure pile. Là j'ai l'impression d'allouer taille fois piles. Non ?

C'est bien possible !

**lamoua76** · 17/05/2007, 21h21

Bon si je suis la logique que j'ai comprise, ce fameux taille* n'a pas lieu d'être, en testant sans ça continu à fonctionner, mais comme on l'a vu précedemment, fonctionner ne signifie pas forcement correct.

Si jamais quelqu'un voit une erreur merci de me faire signe

!

Une fois terminé, je mettrais en pièces jointes mes fichiers si ça interresse quelqu'un

**abdou karim diagne** · 17/05/2007, 22h15

bonjour,d'apres ce qu'on apris c'est pas souhaitable d'utliser un typedef dans une structure et une structure se comporte comme suit:
struct chambre{
int piece;
int exemple;
};
et pour acceder aux champs il faut utiliser le point d'operateur

Problème struture - malloc

C

Discussions similaires

Partager

Partager