Discussion :

[flipper203]

Bonjour,
j'utilise une liste STL pour stocker les addresses des pointeurs alloues dynamiquement pour ensuite les libérer. Voici ma fonction de desallocation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void HDF5_Free_Memory()
{
	list<void*>::iterator iter;
 
	for(iter = list_Dyn_Alloc.begin() ; iter != list_Dyn_Alloc.end(); iter++ )
	{
		delete (*(iter._Ptr))._Myval;
	}
	list_Dyn_Alloc.clear();
}

Mes allocations sont toutes faites avec "new".

En mode debug, cette fonction marche tres bien, mais en mode release, voici l erreur que me donne Visual studio 8:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
error C2248: 'std::list<_Ty>::_Const_iterator<_Secure_validation>::_Ptr' : cannot access protected member declared in class 'std::list<_Ty>::_Const_iterator<_Secure_validation>'
        with
        [
            _Ty=void *,
            _Secure_validation=true
        ]
        D:\Studio2005\VC\include\list(316) : see declaration of 'std::list<_Ty>::_Const_iterator<_Secure_validation>::_Ptr'
        with
        [
            _Ty=void *,
            _Secure_validation=true
        ]

Je ne comprend pas pourquoi je peux acceder a _Ptr en mode debuge et pas en mode release.

[Matthieu Brucher]

En mode debug, les structures de données sont parfois différentes du mode release. De manière générale, ne pas s'appuyer sur des membres commençant pas _, c'est pas standard, on ne sait pas si ça existe partout.

[flipper203]

ok, mais alors comment faire pour acceder a l addresse que j ai mis dans la liste. Voici comment ca se passe:

ma liste est de type :

Code :

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

list<void*> list_Dyn_Alloc;

voici comment j ajoute l addresse de l element allour dynamiquement

Code :

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

1
2
str_buffer = new char[(str_buffer_str->size() + 1)* sizeof(char)];
list_Dyn_Alloc.push_back(str_buffer);

coment donc acceder ensuite a l addresse de cet element via la STL

[Matthieu Brucher]

quand tu récupères un élément de la liste, c'est un void*, pourquoi prendre son adresse ?? c'est ça qu'on doit envoyer au delete - en fait, c'est même pas vrai, il faudrait le transformer en un type de données -

[flipper203]

si je fais un delete de iter, ce n est pas la memoire allouee que je vais desallouer mais l element de la liste chainee non?

[Matthieu Brucher]

Un iter, tu ne peux pas le delete puisqu'il est alloué sur la pile. Un *iter, c'est ton pointeur en question que tu veux effacer.
Mais comme dit, tu fais un new quelque chose pour allouer cette mémoire, là, il voudra appeler le destructeur, mais il n'y en a pas pour un void*, donc tu vas avoir des soucis.
Vive les void*.

[Laurent Gomila]

Code :

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

(*(iter._Ptr))._Myval

Ca doit être la pire des manières pour accéder à ce qui est pointé par un itérateur.
Ecris plus simplement :

Code :

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

*iter

Ensuite, pour détruire un objet mieux vaut connaître son type... Sinon boom.

Les void* c'est crade, tu veux faire quoi au juste ?

[flipper203]

bah en fait dans mon programme, j alloue de la memoire de type different, et je veux ensuite la desallouer, d'ou le void*

[Matthieu Brucher]

bah en fait dans mon programme, j alloue de la memoire de type different, et je veux ensuite la desallouer, d'ou le void*

C'est une liste de quoi que tu as ?

[flipper203]

ma liste contient les addresses des allocation dynamiques

[Matthieu Brucher]

Allocations dynamiques de quoi ?

[flipper203]

de tableaux de char, double, int, enfin de plusieur type

[rigobert]

de tableaux de char, double, int, enfin de plusieur type

Dans ce cas peut-être en utilisant un objet encapsulant les différents types de pointeurs supportés (sous forme d'union par ex), avec un flag permettant de stocker le type alloué et un destructeur chargé de libérer la mémoire allouée avec le bon type; ce qui fait que tout serait désalloué automatiquement lorsque la liste est détruite.

[Matthieu Brucher]

-> boost::any

[Laurent Gomila]

ma liste contient les addresses des allocation dynamiques

de tableaux de char, double, int, enfin de plusieur type

Je ne veux même pas savoir ce que tu essayes de faire avec ça

Si c'était un genre de gestionnaire de mémoire qui ne conservait les adresses mémoire que pour de la vérification ou du logging OK, mais compter sur ce tableau de void* pour détruire les variables allouées, c'est cradingue...

[Antoine_935]

de tableaux de char, double, int, enfin de plusieur type

tu veux faire un langage interprété ?

[flipper203]

Je vais essayer d expliquer plus en détail....donc, en fait, j ai des fonctions qui prennent en parametre un buffer de string ou de double (en fonction de la fonction):

Code :

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

1
2
3
int HDF5_Read_Attr_str(const char* file_Name, const char* dataset_Name, const char* attr_Name, char* &str_buffer);
 
int HDF5_Read_Data(const char* file_Name, const char* dataset_Name, double* &dble_buffer);

Dans ces fonctions, j alloue dynamiquement la memoire de ces buffers. Je ne peux donc pas la desallouer dans la fonction, car la fonction appelante utilise ce buffer pour recuperer les donnees. C'est pour ca que j ai mls en place la liste chainee de void* pour recuperer les addresses a desallouer a la fin de l execution de mon programme. Je ne vois pas comment je peux faire autrement si ce n est d avoir deux liste chainees, une de chaque type (double et string).

Avez vous des propositions?

[rigobert]

Tu peux soit gérer 2 listes de char* et double*, soit gérer une seule liste d'une structure/classe agrégeant les 2 types.

La seconde solution présentant l'avantage de pouvoir insérer un code de désallocation automatique des buffers dans le destructeur (appelé à la destruction de la liste), évitant ansi les problèmes potentiels de fuites.

[Laurent Gomila]

Tu ne peux pas simplement utiliser des trucs un peu plus intelligents que des pointeurs bruts (std::vector, std::string, boost:: xxx_ptr, ...) ?

Sinon oui, avoir deux listes sera une bien meilleure option. Ce n'est pas comme si tu avais à gérer 50 types différents.