Discussion :

[nivose110]

Bonjour,

Voila, j ai une la structure suivante :

Code :

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

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 :

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

[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:

else
{
// on desalloue tab_info;
// ....
free(tab_info);
tab_info = NULL;
break;
}

[nivose110]

c pour cela que j ai mis un commentaire.
Normalement ca aurait du etre quelque chose de ce genre (en pseudo langage)

Code :

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

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.

[mat.M]

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é !

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

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

[David.Schris]

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 ?

[nivose110]

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 :

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.

[nivose110]

Code :

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

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 :

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

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

[granquet]

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.

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"

[David.Schris]

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.

[nivose110]

Donc se qui serait mieux serait de faire ceci

Code :

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

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 :

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

[Dud225]

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.

[David.Schris]

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

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

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.

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

[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?