question sur liberation de memoire

Version imprimable

Bonjour,

Voila, j ai une la structure suivante :

Code:

1
2
3
4
5
6
 
typedef struct u_info
{
    int nb;
    char *data;
} u_info_t;

j ai une fonction qui creer un tableau de type u_info_t et qui doit le remplir.

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
 
u_info_t *fill_u_info(int len, char **name, int size)
{
    int i;
    u_info_t *tab_info = (u_info_t *) calloc(len, sizeof(u_info_t));
    u_info_t *info_tmp;
    char **tmp = name
 
    if (tab_info != NULL)
    {
        for (i = 0; i < size; i++)
        {
            info_tmp = get_info(*tmp);
            if (info_tmp != NULL)
            {
                tab_info[i].nb = info_tmp->nb;
                tab_info[i].data = info_tmp->data;
                free(info_tmp);
                tmp++;
            }
            else
            {
                // on desalloue tab_info;
                // ....
                tab_info = NULL;
                break;
            }
        }
    }
 
    return tab_info;
}

Cela fonctionne, mais je voulais savoir si ceci etait correct ? surtout au niveau du free(info_tmp) car je desalloue seulement l espace de la structure, mais je ne desalloue pas l espace de de son champ data.

Merci.

MAJ :
la fonction get_info() retourne une varaible de type u_info_t *.

15/08/2006, 20h00
granquet

a chaque malloc (ou calloc) correspond un free.

c'est pas facile de repondre sans voir plus de code.

basiquement, tu alloue quand t'as besoin, et tu libére quand t'as plus besoin en remettant tes pointeurs a NULL pour etre sur de planter en cas d'erreur dans le prog (histoire de voir le bug de suite)

y manque:

Citation:

else
{
// on desalloue tab_info;
// ....
free(tab_info);
tab_info = NULL;
break;
}
15/08/2006, 20h14
nivose110
c pour cela que j ai mis un commentaire.
Normalement ca aurait du etre quelque chose de ce genre (en pseudo langage)
Code:

1 2 3 4 5 6 7 8 9 DEBUT: Tant que i < longueur de tab_info et que tab_info + i != NULL Si tab_info[i].data != NULL free(tab_info[i].data) i++ free(tab_info) FIN
Mais j ai eu la flemme de le mettre, car ma reellement ma fonction est beaucoup plus complique et que la je l ai simplifier vraiement un maximum, juste pour vous montrer mon incertitude.

Mon incertitude vient du free(info_tmp) seulement.
15/08/2006, 20h37
mat.M

Citation:

Cela fonctionne, mais je voulais savoir si ceci etait correct ? surtout au niveau du free(info_tmp) car je desalloue seulement l espace de la structure, mais je ne desalloue pas l espace de de son champ data.

D'après le code donné on fait des allocations avec calloc et après on teste si calloc a bien fonctionné .
Il n'ya pas besoin de désallouer la ou tu as mis des commentaires pour la bonne raison que calloc n'aura pas fonctionné !

Citation:

u_info_t *tab_info = (u_info_t *) calloc(len, sizeof(u_info_t));
u_info_t *info_tmp;
char **tmp = name

if (tab_info != NULL)

Meeeff !
Selon les compilos tab_info n'est pas initialisé forcément = à NULL !
Avec VC++ par ex ,tab_info vaudra quelque chose comme 0xccccccc avant d'être affecté à une adresse par calloc
Donc avant l'appel de calloc initialiser tab_info=NULL
15/08/2006, 20h41
granquet

si ta fonction get_info alloue dynamiquement un espace a l'adresse ou pointe le pointeur qu'elle retourne (je fait vraiment des phrases alacon ce soir), alors il y'as besoin d'un free. il n'y as pas plus de questions que ça a se poser y me semble.

maintenant si c'est un probleme de conception, il semblerait que pour ce genre de chose il soit frequent que la fonction retourne un pointeur sur une variable statique de la fonction, ça permet d'eviter l'utilisation de malloc//free a repetition qui sont des operations couteuses.
ça as le desavantage de rendre ta fonction non re-entrante.

et puis sinon, on ne met pas de cast en C pour malloc//calloc.
15/08/2006, 20h54
David.Schris

Citation:

Envoyé par mat.M

Avec VC++ par ex ,tab_info vaudra quelque chose comme 0xccccccc avant d'être affecté à une adresse par calloc
Donc avant l'appel de calloc initialiser tab_info=NULL

Pourquoi ?
15/08/2006, 21h16
nivose110

Citation:

Envoyé par mat.M

Selon les compilos tab_info n'est pas initialisé forcément = à NULL !
Avec VC++ par ex ,tab_info vaudra quelque chose comme 0xccccccc avant d'être affecté à une adresse par calloc
Donc avant l'appel de calloc initialiser tab_info=NULL

Quand je regarde le man voivi ce qui est dit :

Citation:

Pour calloc() et malloc(), la valeur renvoyée est un pointeur sur la mémoire allouée, qui est correctement alignée pour n'importe quel type de variable, ou NULL si la demande échoue.

Code:

1 2 3 4 5 6 7 8 9 10 .... if (info_tmp != NULL) { tab_info[i].nb = info_tmp->nb; tab_info[i].data = info_tmp->data; free(info_tmp); tmp++; } ....
Alors ce n est pas la peine de mettre free(info_tmp) et que tout est correcte point de vu allocation memoire et tout ?

le probleme est si j enleve free(info_tmp), alors lors du calloc de la prochaine iteration, on aura perdu l adresse memoire de info_tmp et on ne pourra plus y avoir acces.
De plus, normalement free(info_tmp) ne desalloue pas la memoire du champs data !!!!

Si j avais fait :
Code:

1 2 3 4 5 6 7 8 9 .... if (info_tmp != NULL) { tab_info[i] = *info_tmp; free(info_tmp); tmp++; } ....
je pense que le free(info_tmp) n aurat pas ete util ... Enfin je crois :? .
ERF si quelqun pourrait confirmer mes dires (ou refuter mes conneries).

15/08/2006, 22h15
granquet

Citation:

Envoyé par nivose110

Alors ce n est pas la peine de mettre free(info_tmp) et que tout est correcte point de vu allocation memoire et tout ?

je ne sais pas comment marche ta fonction, si elle utilise l'allocation dynamique, il faut free.
quand ... c'est a toi de voir.
personellement je trouve bete d'allouer dynamiquement dans ta fonction get_info a chaque iteration de ta boucle for.

Citation:

De plus, normalement free(info_tmp) ne desalloue pas la memoire du champs data !!!!

exact. mais d'apres ton code ce n'est pas un probleme, c'est meme devenu une "feature" :aie:
15/08/2006, 22h21
David.Schris

Citation:

Envoyé par nivose110

De plus, normalement free(info_tmp) ne desalloue pas la memoire du champs data !!!!

Exact. Et à un moment ou à un autre il faudra bien la libérer cette mémoire.

Donc se qui serait mieux serait de faire ceci

Code:

void get_info(u_info_t *info, char *tmp);

Cette fonction va remplir le pointeur info.

et dans u_info_t *fill_u_info je met

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
 
u_info_t *fill_u_info(int len, char **name, int size)
{
    int i;
    u_info_t *tab_info = (u_info_t *) calloc(len, sizeof(u_info_t));
    u_info_t *info_tmp;
    char **tmp = name
 
    if (tab_info != NULL)
    {
        for (i = 0; i < size; i++)
        {
           info_tmp = tab_info + i;
           get_info(info_tmp, *tmp);
 
            // si get_info foire il met info_tmp a NULL.
            if (info_tmp == NULL)
            {
                // on desalloue tab_info;
                // ....
                tab_info = NULL;
                break;
            }
 
            tmp++;
        }
    }
 
    return tab_info;
}

Ceci me semble effectivement mieux. Pourquoi allouer de la memoire pour un pointeur alors que l espace est deja alloue dans un tableau.

Cela vous semble aussi meilleur ?

10/04/2007, 21h05
Dud225

Citation:

Envoyé par Dark_Ebola

a chaque malloc (ou calloc) correspond un free.

Et dans le cadre d'un fork? Si l'on alloue de la mémoire, faut-il aussi la libérer dans les processus fils? En fait, je voudrais réutiliser dans un processus fils un pointeur qui a été alloué par le père. Et, pour cela, je voudrais le redimensionner afin de travailler avec la taille adéquate dans le processus fils.
10/04/2007, 22h27
David.Schris

Citation:

Envoyé par Dud225

Et dans le cadre d'un fork? [...]

Tu devrais créer un nouveau thread pour poser cette question.

Note : quand j'écris "nouveau thread", je veux bien sûr dire "nouvelle discussion", ce n'est (presque) pas de jeu de mot avec fork()...
11/04/2007, 01h07
souviron34

@nivose110 :

Normalement tu devrais faire un free du tmp data avant de libérer tmp.
Sauf qu'on ne sait pas ce qu'est ton data. Comme là tu assigne par une égalité, on doit supposer que c'est soit une valeur, soit un tableau alloué pour tmp, que tu affectes directement à la vraie structure. Et dans ce cas effectivement il ne faut pas le libérer.

Citation:

Envoyé par Dud225

Et dans le cadre d'un fork? Si l'on alloue de la mémoire, faut-il aussi la libérer dans les processus fils? En fait, je voudrais réutiliser dans un processus fils un pointeur qui a été alloué par le père. Et, pour cela, je voudrais le redimensionner afin de travailler avec la taille adéquate dans le processus fils.

Et non.. le fils ne reçoit que quelques paramètres et contextes du père, mais pas les variables de ce style.

Ce qu'il faut savoir de base c'est qu'un "fork" revient en fait à ré-éxécuter le main jusqu'à l'instruction fork, en la sautant, mais comme c'est un NOUVEAU processus il n'hérite que d'une partie de choses.

Donc si tu fais une allocation avant d'avoir atteint le fork, cette allocation sera REPETEE (et non commune) dans le processus fils.
11/04/2007, 09h37
Médinoc

Pour être plus précis, fork() duplique complètement un processus et sa zone mémoire.
Les zones allouées également sont dupliquées, donc le père ET le fils doivent libérer la leur.
12/04/2007, 22h32
Dud225

OK. Et si je fais un execl dans le fils, je ne suis plus obligé de libérer les zones mémoires allouées dans le processus fils, si?