Discussion :

[Krisprolls31]

Bonjour tout le monde voici mon problème:

J'utilise pas mal d'allocations et réallocations mémoire dans mon code car je dois construire des tableaux 1D et 2D dont je ne connais pas à l'avance la taille. Et donc j'utilise aussi beaucoup de désallocations . pour éviter d'avoir à écrire à chaque fois :

Code :

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

1
2
3
4
5
 
int *p;
...
free(p);
p = NULL;

ou

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int i;
int** p;
...
for(i = 0; i < nblignes; i++)
{
      free(p[i]);
      p[i] = NULL;
}
free(p);
p = NULL;

j'utilise à la place deux fonctions qui vont me faire cette libération. voici ces deux fonctions :

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
 
void destroy1(int* p)
{
	if (p != NULL)
	{
		free(p);
		p = NULL;
	}
}
 
void destroy2(int** pp, int nbp)
{
	int i;
	if(pp != NULL)
	{
		for(i = 0; i < nbp; i++)
		{
			if(pp[i] != NULL){
				free(pp[i]);
				pp[i] = NULL;
			}
		}
		free(pp);
		pp = NULL;
	}
}

le problème c'est que ça n'a pas l'air de marcher ...

quand je détruit un pointeur et que je teste s'il est égal à NULL, cela me renvoie 0.

Peut être avez vous une idée sur ce problème.

Merci d'avance

[Obsidian]

le problème c'est que ça n'a pas l'air de marcher ... quand je détruit un pointeur et que je teste s'il est égal à NULL, cela me renvoie 0.

C'est ambigü mais si, dans ton code, tu écris :

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
int main (void)
{
    int * p = NULL;
 
    p = malloc (50*sizeof(int));
    destroy (p);
 
    if (p==NULL) puts ("Mémoire libérée.");
 
    return 0;
}

… alors ça ne marchera pas comme tu l'entends. D'abord parce que tu ne détruis pas le pointeur, mais seulement la zone mémoire qu'il pointe. Ensuite, en appelant destroy(), tu passes par valeur le contenu du pointeur, c'est-à-dire l'adresse de la zone à libérer.

L'argument « p » de ta fonction est vu comme une variable locale et est perdu à la sortie de ta fonction. En tout état de cause, il n'est pas lié à la variable « p » de ta fonction main() et tu ne peux donc pas changer la valeur de celle-ci depuis ta fonction.

Si tu veux le faire, il faut remonter encore d'un niveau en passant à destroy() l'adresse de ton pointeur. Donc, un prototype de la forme « int ** » comme pour le tableau de pointeurs de destroy2().

C'est un peu contraignant mais puisque tu as déjà écrit destroy2() et que tu t'en sers, tu peux utiliser la même fonction en considérant l'adresse de ton pointeur comme un tableau à une seule case :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main (void)
{
    int * p = NULL;

    p = malloc (50*sizeof(int));
    destroy2 (&p,1);

    if (p==NULL) puts ("Mémoire libérée.");

    return 0;
}

[Krisprolls31]

Merci de ta réponse. j'ai modifié mes deux fonctions en passant en paramètre non plus un pointeur mais l'adresse de ce pointeur. et effectivement ça marche. Voici mes fonctions destroy :

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
 
void destroy1(int** p)
{
	if (*p != NULL)
	{
		free(*p);
		*p = NULL;
	}
}
 
void destroy2(int*** pp, int nbp)
{
	int i;
	if(*pp != NULL)
	{
		for(i = 0; i < nbp; i++)
		{
			if((*pp)[i] != NULL){
				free((*pp)[i]);
				(*pp)[i] = NULL;
			}
		}
		free(*pp);
		*pp = NULL;
	}
}

[Obsidian]

C'est très bien. Si es perfectionniste, tu peux également vérifier si « p », en plus « de *p » n'est pas NULL également.

À bientôt.