Problème struture - malloc

Version imprimable

Voir 40 message(s) de cette discussion en une page

13/05/2007, 14h45
dj.motte
Salut,

Avec linux, ok :
Code:

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

Citation:

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

On va voir...En principe le système reste stable.
13/05/2007, 14h58
dj.motte

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.
13/05/2007, 15h08
Emmanuel Delahaye

Citation:

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.

Citation:

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:

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).

13/05/2007, 18h41
gl
Citation:
Envoyé par dj.motte

Que donnerait :

Code:

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) ???
15/05/2007, 09h28
Médinoc
Citation:
Envoyé par dj.motte

Que donnerait :

Code:

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.
15/05/2007, 15h44
Emmanuel Delahaye

Citation:

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)
16/05/2007, 11h02
lamoua76

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 !
16/05/2007, 11h05
Médinoc

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...

Rebonjour à tous.

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

Code:

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:

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:

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 :king: ?

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

16/05/2007, 23h19
Médinoc

Code:

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

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

Citation:

Envoyé par lamoua76

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
/*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:

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:

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]);

Citation:
Envoyé par Emmanuel Delahaye
Je te conseille de coder selon le principe :

Code:

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:

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 ? :king:

17/05/2007, 12h59
Emmanuel Delahaye
Citation:

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:

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.
17/05/2007, 13h27
lamoua76
Citation:
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:

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 :yaisse2: .
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 8-) Merci ! :king:
17/05/2007, 13h47
Emmanuel Delahaye

Citation:

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").

Me revoilà.

A force de réutiliser mon code je me pose la question suivante :
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 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 ? :?

17/05/2007, 19h59
Emmanuel Delahaye

Citation:

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 !
17/05/2007, 21h21
lamoua76

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 :yaisse2: !

Une fois terminé, je mettrais en pièces jointes mes fichiers si ça interresse quelqu'un ;)
17/05/2007, 22h15
abdou karim diagne

structure

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

Voir 40 message(s) de cette discussion en une page