[C] Allouer de la mémoire à un pointeur mais...

[Snakes_Master1]

Bonjour !

Voilà mon problème ce soir : je voudrais allouer de la mémoire un pointeur situé dans une structure (A). J'étudie la question grâce au site du zero, donc je n'ai pas encore beaucoup beaucoup de connaissances. Ensuite, j'ai aussi une structure (B) dans cette structure (A), et la structure (B) contient un pointeur pour lequel j'aimerai allouer de la mémoire dynamiquement !, mais ça c'est moins urgent...

Illustration :

typedef struct B B
struct B
{
    char *Nom
}


typedef struct A A
struct A
{
    int *Ressource
    B *Ville
}

Voilà, je fais exprès de bien structurer ma question pour esperer avoir une réponse aussi structuré

Merci à ceux qui peuvent m'aider

[lorinc]

je ne vois pas où est le problème.

tu as une struct toto :

typedef struct toto_str
{
 char* chaine;
} toto;

dès que tu veux utiliser un toto, il faut allouer chaine :

toto mon_toto;
mon_toto.chaine = malloc(10*sizeof(char));

À la limite, tu peux tout mettre dans une fonction, histoire de pas avoir à tout réécrire :

/* fonction qui alloue un nouveau toto avec une chaine de taille size */
toto* creerToto(int size)
{
 toto* t;
 t = malloc(sizeof(toto));
 t->chaine = malloc(size*sizeof(char));

 return t;
}

Et ne pas oublier de faire la fonction de désallocation histoire de pas perdre de mémoire :

/* désallocation d'un toto */
void detruireToto(toto *t)
{
 free(t->chaine);
 free(t);
}

Petite feature sympa, tu peux t'arranger pour que le pointeur soit mis à NULL histoire de ne pas le réutiliser si la mémoire à été désallouée. 2 façons, une simple mais chiante à l'utilisation, et une compliquée mais pratique à l'utilisation.

La simple :

/* désallocation d'un toto*/
toto * detruireToto(toto *t)
{
 free(t->chaine);
 free(t);
 return NULL;
}

et tu t'en sers comme suit :

/*exemple de creation puis destruction d'un toto*/
toto *t = creerToto(10);
t = detruireToto(t);

La compliquée :

/* detruit un toto */
void detruireToto(toto **t)
{
 free( (*t)->chaine);
 free( (*t));
 *t = NULL;
}

et tu t'en sers comme suit :

/* exemple creation et destruction toto 2 */
toto * t = creerToto(10);
/* on passe l'adresse du pointeur pour changer sa valeur */
detruireToto(&t);

Après, si tu as une structure qui encapsule un toto, et bien, c'est pareil, tu fais une fonction d'allocation/destruction afin de ne pas avoir à tout réécrire à chaque allocation/destruction (ce qui est générateur d'erreur).

par exemple, avec une structure tata contenant un toto :

typedef struct tata_str
{
 toto * the_toto;
 int * tab;
} tata;

la fonction d'allocation :

/* alloue un tata avec size pour le toto et nb pour tab*/
tata * creerTata(int nb, int size)
{
 tata * ta;

 ta = malloc(sizeof(tata));
 ta->the_toto = creerToto(size);
 ta->tab = malloc(nb*sizeof(int));

 return ta;
}

je te laisse imaginer la fonction de destruction

[Snakes_Master1]

Merci beaucoup pour ce post très complet lorinc !

En fait j'ai oublier une chose dans mon énnoncé : une structure est un tableau, l'autre un pointeur !

[Mephisto]

pas de gros changement

a ce moment, ta struct A ne contient plus t_list *B mais t_list **B

malloc A

malloc B (le pointeur sur structure) du nombre d'elements que tu y rentrera (si tu ne sais pas, malloc pour 1, ou plus si tu as un minimum de maillons a placer, et realloc a chaque rajout)

malloc B[x] et remplie-le

sinon, tu peux aussi faire une liste chainee

typedef struct sb

{

char *toto;

struct sb *next;

struct sb *last;

} B;

et ta struct A ne change alors pas

la, tu malloc juste ton B une fois, tu initialise next et last a 0, et a chaque fois que tu rajoute un maillon

t_list *new;

[malloc new]

new->last = b;

b->next = new;

b = new;

l'ideal dans ce cas la etant de se faire un jeu de fonctions (une sorte de mini-lib-listes-chainees), pour add, drop, sort, etc. tes elements

tu n'auras plus a t'embetter avec ca ensuite, juste a appeler tes fonctions qui s'occuperont de malloc et de linker tes maillons

j'avoue avoir etait assez brouillon ; si tu n'as pas bien compris (pour certains, les listes chainnees, ca passe mal au debut ), n'hesite pas a demander des fonctions d'exemple

+

[Snakes_Master1]

Merci beaucoup Je m'y met demain !

[Mephisto]

tiens nous au courrant