Malloc / structures imbriquées

Version imprimable

je suis en train de créer une trame SNMP
Voila, j'ai une structure de ce type.

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
 
typedef struct
{
char           *tag;
int            longueur;
char           *valeur;
}CODAGECHAR;
 
typedef struct
{
char           *tag;
int            longueur;
int            valeur;
}CODAGEINT;
 
typedef struct
{
char           *tag;
int            longueur;
unsigned long  *valeur;
}CODAGEADDR;
 
typedef struct
{
CODAGEINT           *version;
CODAGECHAR          *community;
CODAGEINT           *typetrap;
CODAGECHAR          *oid ;
CODAGEADDR          *manaddr;
CODAGECHAR          *spef;
CODAGECHAR          *error;
CODAGECHAR          *timeticks;
CODAGECHAR          *date;
CODAGECHAR          *type;
CODAGECHAR          *code;
CODAGECHAR          *par1;
 
 
}TRAPSENDER;

Pour pouvoir la remplir, je dois faire une allocation malloc dans mon prog principal.

je fais donc :

Code:

1
2
3
4
 
TRAPSENDER tramesnmp;
 
tramesnmp = malloc (20000);

Et quand je veux remplir ma structure, tout se crache,

Code:

1
2
 
tramesnmp->version->valeur = 0;

Je comprend pas
si vous aviez une idée ou deux ça m'aiderait

Si tu veux allouer dynamiquement il faut faire ainsi:

Code:

1
2
3
4
5
6
7
8
9
 
TRAPSENDER * tramesnmp = NULL;
 
tramesnmp = malloc (20000 * sizeof (* tramesnmp));
 
if (! tramesnmp)
{
   /* ... Gestion d'erreur en cas d'erreur de malloc ... */
}

11/05/2006, 14h50
Lolita59

je comprend pas la partie :

sizeof (* tramesnmp)
comment il peut savoir la taille de tramesnmp alors que c'est justement ce que lui demande de créer...
11/05/2006, 15h03
Franck.H

Citation:

Envoyé par Lolita59

je comprend pas la partie :

sizeof (* tramesnmp)
comment il peut savoir la taille de tramesnmp alors que c'est justement ce que lui demande de créer...

* tramesnmp est un pointeur sur une structure de type TRAPSENDER donc il connais forcément la taille de l'objet sur lequel il pointe ... !
11/05/2006, 15h05
Lolita59
Code:

1 2 3 4 5 if (! tramesnmp) { /* ... Gestion d'erreur en cas d'erreur de malloc ... */ }
depuis que j'ai mis ça avant de remplir mes champs ça tourne mais il ne rentre jamais dans le if

comprend toujours pas moi :(
11/05/2006, 15h07
Franck.H
Citation:
Envoyé par Lolita59

Code:

1 2 3 4 5 if (! tramesnmp) { /* ... Gestion d'erreur en cas d'erreur de malloc ... */ }

depuis que j'ai mis ça avant de remplir mes champs ça tourne mais il ne rentre jamais dans le if

comprend toujours pas moi :(
Cette condition n'est utilisée que lorsque l'allocation de mémoire échoue c'est tout, si tu préfère une autre forme plus compréhenssible:
Code:

1 2 3 4 5 if (tramesnmp == NULL) { /* ... Erreur d'allocation ... gérer le comportement du programme ... */ }
11/05/2006, 15h10
Lolita59

Ah oki c le ! que j'avais mal interprété

Merci beaucoup, je m'en vais tester ça voir si ça tourne bien maintenant

En fait ça change pas le pb. Le prog se crashe a la ligne suivante :

Code:

1
2
3
4
5
6
7
 
 
tramesnmp = malloc (2000* sizeof (* tramesnmp));
 
          /*** mise en forme de la version du protocole SNMP ***/
          tramesnmp->version->valeur = 0;     <---ici
          tramesnmp->version->longueur = sizeof ( tramesnmp->version->valeur );

Cette allocation:

Code:

tramesnmp = malloc (2000* sizeof (* tramesnmp));

indique que tout simplement tu créé un tableau de structure de 2000 indice donc de ce fait, pour accéder à un indice précis tu dois faire comme celà:
Code:

1 2 3 4 5 /*** mise en forme de la version du protocole SNMP ***/ /* Ceci pour le premier indice du tableau biensur ! */ tramesnmp[0]->version->valeur = 0; <---ici tramesnmp[0]->version->longueur = sizeof ( tramesnmp[0]->version->valeur );

Citation:

Envoyé par Lolita59

En fait ça change pas le pb. Le prog se crashe a la ligne suivante :

Code:

1
2
3
4
5
6
7
 
 
tramesnmp = malloc (2000* sizeof (* tramesnmp));
 
          /*** mise en forme de la version du protocole SNMP ***/
          tramesnmp->version->valeur = 0;     <---ici
          tramesnmp->version->longueur = sizeof ( tramesnmp->version->valeur );

Non, il faudra faire un malloc par élément dans ta structure:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
tramesnmp = malloc (sizeof (* tramesnmp));
if(tramesmp==NULL)
 {
  /*Gestion erreur*/
 }     
 
tramesnmp->version = malloc(sizeof *(tramesnmp->version));
if(tramesnmp->version==NULL)
  {
  /*Gestion erreur*/
  }
 
/*Pareil pour tous les autres pointeurs...*/

Citation:
Envoyé par Franck.H
Cette allocation:

Code:

tramesnmp = malloc (2000* sizeof (* tramesnmp));

indique que tout simplement tu créé un tableau de structure de 2000 indice donc de ce fait, pour accéder à un indice précis tu dois faire comme celà:
Code:

1 2 3 4 5 /*** mise en forme de la version du protocole SNMP ***/ /* Ceci pour le premier indice du tableau biensur ! */ tramesnmp[0]->version->valeur = 0; <---ici tramesnmp[0]->version->longueur = sizeof ( tramesnmp[0]->version->valeur );
Mais la zone mémoire pour version n'est pas alloué pour aucun des indices...

Jc

11/05/2006, 15h28
Franck.H

Hum oui je suis bête, j'avais pas vu que c'était également des pointeurs dans cette structure :arf: mille excuse :lol:
11/05/2006, 15h28
Lolita59

A la base je voulais créer un buffer d'une taille de 2000 pour voir ce qui se passait.

Compte tenu que je ne crée qu'une seule trame SNMP à la fois, il ne me faut que 1 indice de cette structure.

Mais j'ai du mal a comprendre comment il fait pour savoir la taille de la structure avec les données dedans

parce que rien que si je met un int = 5 ou =15, ça fera deja pas la meme taille. Alors imagine les variations sur toutes les valeurs possibles de ma structure

Citation:

Envoyé par Lolita59

A la base je voulais créer un buffer d'une taille de 2000 pour voir ce qui se passait.

Compte tenu que je ne crée qu'une seule trame SNMP à la fois, il ne me faut que 1 indice de cette structure.

Mais j'ai du mal a comprendre comment il fait pour savoir la taille de la structure avec les données dedans

parce que rien que si je met un int = 5 ou =15, ça fera deja pas la meme taille. Alors imagine les variations sur toutes les valeurs possibles de ma structure

Tu as des pointeurs dans ta structure donc tu alloues la mémoire pour ta trame et ensuite tu alloues pour chaque zone nécessaires pour le trame...

Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 typedef struct sa { int a,b,c; }A; typedef struct sb { int a,b,c; float fa,fb,fc; }B; typedef struct sglobal { int c,d; A *test; B *lol; }global;
Donc si on veut allouer la mémoire pour une structure globale, on va demander une zone mémoire pour la structure globale.

Si malloc fonctionne, on va devoir allouer de la zone pour les deux structures internes.

Donc 2 malloc de plus qui vont allouer de la place pour les structure de type A et de type B.

C'est avec les pointeurs qu'on liera la structure englobante aux 2 autres internes.

Et si ces structures internes avaient des pointeurs de structures internes, on ferait encore des malloc en plus.

Ce qui donnerait en code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Global *g = malloc(sizeof *g); if(g==NULL) { /*Gestion erreur*/ } g->test = malloc(sizeof *(g->test)); if(g->test==NULL) { /*Gestion erreur*/ } g->lol = malloc(sizeof *(g->lol)); if(g->lol==NULL) { /*Gestion erreur*/ }
Jc

11/05/2006, 15h43
Lolita59

oki je vois

je me rappellais plus qu'il fallait allouer pour chaque structure
je vais aller tester ça

merci beaucoup