Discussion :

[LittleWhite]

Bonjour,

Je viens de me mettre à la glib, juste pour avoir des structures de données en C.
Vive les tables de hachage et autres \o/.

Donc aujourd'hui, j'utilise des GArray. Dans mes tableaux je veux des char*.
Avant d'ajouter mon char* avec 'g_array_append_val()', j'alloue la mémoire, et je copie la chaine à partir d'une source statique dans le nouvel endroit de mémoire. Je ne pense pas que la glib puisse copier ma chaines de caractères toute seule .
Bref ... j'ai un jolie char* ... qui un beau jour devra être désalloué.

Je pensais faire un bête:

Code :

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

1
2
 
g_array_free(pVFile->pFile,TRUE);

Et comme j'avais mis à TRUE, je pensais que cela ferait des free() sur les éléments, mais il ne semble pas que ce soit le cas ( vive valgrind ).
Avant de faire ce g_array_free, je parcours donc mon tableau, pour faire les free de mes éléments.
Cela ne plante pas ... cela semble marcher ... mais tout les pointeurs sont déclaré par valgrind comme still reachable... du coup je pense toujours avoir une fuite de mémoire.

Quelqu'un peut t'il m'expliquer un peu le fonctionnement, et comment faire pour faire une libération de la mémoire propre?

Merci beaucoup

[liberforce]

Bonjour,

attention à la terminologie :
pointeur sur char → char *
pointeur sur char * → char **

Comme tu n'es pas trop précis sur les termes, c'est difficile de comprendre ce que tu essaies de faire. Nous montrer du code serait mieux. Mais si ce que tu veux faire, c'est avoir un tableau de pointeurs, où chaque élément pointe vers une chaîne de caractères déjà allouée, alors c'est vers GPtrArray qu'il faut t'orienter. Et si c'est un tableau où chaque élément est un caractère, alors utilise GByteArray...

[LittleWhite]

:red:

Je parle d'un tableau qui stockerai des char* ( des chaines de caractères ).
Je vais voir un peu plus tard sur les GPtrArray...

( Je corrige aussi mon post initial )

[teuf13]

Je seconde Liberforce, un exemple de code qui leake serait beaucoup plus précis. C'est les détails qui comptent, ce que tu décris est cohérent, mais il y a l'air d'avoir un problème dans ce que tu fais, problème que tu ne décriras pas avec des mots vu que tu n'as pas conscience de ce que c'est (sinon le problème n'existerait pas)

[LittleWhite]

Oui je comprends votre point de vue . C'est juste que je vais extraire les bouts de code important dans cas, et j'ai un peu peur de louper un truc à vous montrer.

Donc ... mon fichier .h:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <glib.h>
 
typedef struct VFile
{
	GArray* pFile;
}VFile;
 
void cstVFile(VFile* const pVFile);
void dstVFile(VFile* const pVFile);

La définition des 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
 
void cstVFile(VFile* const pVFile)
{
	assert(pVFile);
 
	pVFile->pFile = g_array_sized_new(FALSE, FALSE, sizeof(char*), NB_LINES_FILE);
}
 
void dstVFile(VFile* const pVFile)
{
	unsigned int i = 0;
 
	assert(pVFile);
 
	for ( i = 0 ; i < pVFile->pFile->len ; i++ )
	{
		free(g_array_index(pVFile->pFile,char*,i));
	}
 
	g_array_free(pVFile->pFile,TRUE);
 
#ifdef _SAFE
	pVFile->pFile = NULL;
#endif
}

Et la partie de l'ajout dans le GArray:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
char* ligne = (char*) malloc(sizeof(char)*nbCar);
 
if ( ligne == NULL )
{
	fprintf(stderr, "Erreur d'allocation de mémoire pour la ligne");
	return -3;
}
 
strncpy(ligne, bufferLigne, nbCar);
ligne[nbCar-1]='\0';
 
// Ajout de la ligne dans le VFile
g_array_append_val(pVFile->pFile,ligne);

Dans le main:

Code :

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

1
2
3
4
5
6
7
8
 
VFile vfileFR;
 
cstVFile(&vfileFR);
 
// Appel de la fonction ci dessus ...
 
dstVFile(&vfileFR);

Note: Je vais bientot remplacer ce GArray par un GPtrArray qui est une peu plus logique.

[teuf13]

Utilise g_strdup plutôt que malloc+strncpy, ça éliminera une possibilité d'erreur. Par contre la doc de g_array_free est explicite sur le fait que c'est à toi de libérer les éléments contenus dans le tableau un à un. Ce que fait g_array_free, c'est la libération de la structure GArray, et potentiellement de la mémoire allouée pour le tableau proprement dit (ie pour stocker les char*).