Discussion :

[G]

Bonjour,

J'ai une fuite mémoire dans un pg car un vector composé de pointeurs alloués par des new n'est jamais effacé (et les delete ne sont jamais faits ...)

J'ai regardé la contribution de Loulou24 sur le sujet dans le forum et qui, selon moi, répond à mon besoin ... mais j'ai un souci car je travaille sur des données 'const'.
Le msg d'erreur est le suivant :

error C2665: 'delete' : none of the 2 overloads can convert parameter 1 from type 'const tCC *'
c:\program files\microsoft visual studio\vc98\include\algorithm(37) : see reference to function template instantiation 'int __thiscall Delete::operator ()(const tCC *& ) const' being compiled
Error executing cl.exe.

Pour que ce soit plus clair, je vous donne le petit bout de code avec :

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
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
#include <vector>
#include <algorithm>
 
typedef struct {
 unsigned long idx;
 float valf;
 } tCC;
 
typedef const tCC* tCCConstPtr;
typedef std::vector<tCCConstPtr>	ttCCConstPtrVector;
 
struct Delete
{
	template <class T> operator () (T *&p) const
	{
		delete p;
		p = NULL;
	}
};
 
void main(void)
{
	ttCCConstPtrVector aCubes;
 
	tCC* pC = new tCC;
	pC->idx = 0;
	pC->valf = 0.0;
	aCubes.push_back(pC);
 
	tCC* pC1 = new tCC;
	pC1->idx = 1;
	pC1->valf = 1.0;
	aCubes.push_back(pC1);
 
	tCC* pC2 = new tCC;
	pC2->idx = 2;
	pC2->valf = 2.0;
	aCubes.push_back(pC2);
 
	std::for_each(aCubes.begin(), aCubes.end(), Delete());
}

Quelqu'un peut-il m'indiquer ce que j'ai mal fait ? Là où ça pêche ?
Si Loulou24 est dispo, je suis sûr qu'il va me trouver cela rapidement ...

Merci d'avance.


[Balises CODE et QUOTE rajoutées par Loulou24, merci d'y penser à l'avenir]

[Laurent Gomila]

Tu vas envoyer du const T* à ton foncteur, mais celui-ci attend des T*, donc ça ne passe pas (tu perds le const ). Il faut prendre dans ton foncteur des pointeurs constants ; pour ça il faudra retirer le "p = NULL" (puisque celui-ci sera constant) mais ça ne gène pas dans ton cas.

Code :

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

1
2
3
4
5
6
7
struct Delete
{
   template <class T> operator () (const T *p) const
   {
      delete p;
   }
};

[G]

Je viens d'essayer avec un foncteur prenant des

Code :

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

const T *p

mais j'ai le même message d'erreur à la compil.
Pourtant, il me semblait que ta réponse allait suffire.
Y'a autre chose qui cloche ...

[Herode]

Tu vas envoyer du const T* à ton foncteur, mais celui-ci attend des T*, donc ça ne passe pas (tu perds le const ). Il faut prendre dans ton foncteur des pointeurs constants ; pour ça il faudra retirer le "p = NULL" (puisque celui-ci sera constant)

Hmmm, je ne crois pas...
L'itérateur du vector renvoie bien des const tCC*.
Du reste, il s'agit bien de pointeurs sur tCC constants, et non pas de pointeurs constants sur tCC. Donc l'instruction "p=NULL", bien qu'inutile, ne gêne pas.

Accessoirement, je viens de tester le code sur BCC5 et ça passe bien. Juste un warning du compilateur signalant que l'operator() devrait renvoyer quelque chose (ou être déclaré comme renvoyant void). Quel compilateur utilises-tu ?

NB : J'ai testé avec un

Code :

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

#include <iostream>

à la place du stdio.h, mais je doute que ce soit là l'origine du problème

[G]

J'utilise le compilo de Visual C++ (6.0).

[Laurent Gomila]

Euh oui effectivement, il manque un void dans la signature de operator ().

Hmmm, je ne crois pas...
L'itérateur du vector renvoie bien des const tCC*.
Du reste, il s'agit bien de pointeurs sur tCC constants, et non pas de pointeurs constants sur tCC. Donc l'instruction "p=NULL", bien qu'inutile, ne gêne pas

Oui, le paramètre passé sera un const tCC* alors que le foncteur attend un tCC*, donc il y a bien problème. Par contre ok pour le delete NULL, me suis un peu embrouillé.

Je pense que le problème est que VC6 ne supporte pas le delete d'un pointeur sur constante (c'est pourtant bien autorisé dans la norme).

Solution : un cast barbare (pour virer le const) ou changement de compilo

[Herode]

Grmf... J'avais bien eu quelques soucis avec la STL de Dinkumware dans le temps, mais c'est trop vieux pour que je sois précis là-dessus. Il faudrait jeter un oeil dans leur code pour voir.

Juste par curiosité, as-tu essayé de remplacer le for_each par une boucle faite à la main pour comparer les compilations ?

[Laurent Gomila]

De toute façon le message est clair : c'est sur delete que porte l'erreur. Le passage par le foncteur fonctionne bien lui.

[Herode]

Oui, le paramètre passé sera un const tCC* alors que le foncteur attend un tCC*, donc il y a bien problème.

C'est là que j'ai du mal à te suivre, mais d'un autre côté ça fait un bail que je n'ai pas touché au C++
Alors reprends-moi si je dis des bêtises... mais il me semble que le paramètre template T prend la classe qu'on lui envoie. Il ne fait pas spécialement de filtre sur les modificateurs const, non ?
Ainsi :

Code :

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

1
2
3
4
5
 
template<class T>  foo( T arg ) {... }
int i = ...; foo( p );  (1)
int *pi = ...; foo( pi ); (2)
const int* pci = ...; foo( pci ); (3)

interprète T comme un int (1), un int* (2) et un const int* (3) respectivement, non ????

D'ailleurs, si tel est bien le cas, ne suffit-il pas de définir le foncteur comme suit :

Code :

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

1
2
3
4
5
6
7
8
struct Delete 
{ 
   template <class T> void operator () ( T &p ) const 
   { 
      delete p;
      p = NULL; 
   } 
};

[G]

Je réponds à la question d'Herode : oui j'ai essayé de changer le for_each par un parcours plus "classique" du vecteur et ... je n'ai plus d'erreur de compilation !
Du coup, j'ai essayé cela dans le code que je dois améliorer (car l'origine du pb est bien de corriger une fuite mémoire) mais je ne vois pas d'effets positifs avec GlowCode.

Il faut donc que je continue à investiguer ...

[Laurent Gomila]

Alors reprends-moi si je dis des bêtises... mais il me semble que le paramètre template T prend la classe qu'on lui envoie. Il ne fait pas spécialement de filtre sur les modificateurs const, non ?

Avec T en paramètre je pense que oui, ça prendrait bien "const tCC*", mais pas avec T* en paramètre. C'est là que ça coince.
Tu peux tout à fait prendre un T en paramètre, prendre un T* explicitait juste le fait que ce soit un pointeur.

Sinon, bizarre que ça passe avec une boucle déroulée à la main M'enfin bon, je suis un peu dans le cirage moi ce matin.

[G]

Oui c'est bizarre. Personnellement, je ne trouve pas d'explication pour l'instant.

Mais ce qui me gêne aussi (pour préciser mon dernier post), c'est que Purify m'indique que mon petit bout de code perd autant de mémoire lorsque je fais appel au foncteur que lorsque je ne fais rien (en gros des new et des push_back) sans me soucier de libérer la mémoire. Là, je suis un peu vert ...

[Luc Hermitte]

Ce n'est pas le void qui manque ?

[Herode]

Oui c'est bizarre. Personnellement, je ne trouve pas d'explication pour l'instant.
Mais ce qui me gêne aussi (pour préciser mon dernier post), c'est que Purify m'indique que mon petit bout de code perd autant de mémoire lorsque je fais appel au foncteur que lorsque je ne fais rien (en gros des new et des push_back) sans me soucier de libérer la mémoire. Là, je suis un peu vert ...

Et donc, avec la signature

Code :

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

template <class T> void operator () ( T &p )

ça ne marche toujours pas ??

[Herode]

Sinon, bizarre que ça passe avec une boucle déroulée à la main M'enfin bon, je suis un peu dans le cirage moi ce matin.

Moi, je trouve ça plutôt rassurant En déroulant la boucle à la main, on évite le passage par le template en appelant directement delete sur l'itérateur dé-référencé. Cela indique bien que le problème se situe au niveau des arguments d'entrée de l'operator() du foncteur.

[G]

Non le void n'apporte aucun changement.

[G]

En fait, j'ai résolu mon pb en utilisant qqchose de basique et qui n'a pas la généricité d'un foncteur ...

Je parcours ma boucle de begin() à end() et je fais un delete de l'élément pointé par l'itérateur (avec un cast à cause du const !) puis je le mets à NULL.

Je sais, ce n'est pas "glorieux" mais cela répond à mon besoin donc je m'en contente pour l'instant. Par contre, il me reste des zones d'ombre sur les infos que vous m'aviez données et sur le "pourquoi ça ne marche pas" ...

Merci en tous les cas.

[Luc Hermitte]

Je parcours ma boucle de begin() à end() et je fais un delete de l'élément pointé par l'itérateur
a- (avec un cast à cause du const !)
b- puis je le mets à NULL.

a- tu ne devrais pas en voir besoin, sauf si tu fais b-.
Le compilo râle sur un simple

Code :

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

1
2
3
4
5
int main() {
    const int * i = 0;
    delete i;
    return 0;
}

?

b- A chaque fois que je l'ai vu appliqué, cela ne servait strictement à rien -- contrairement à d'autres langages le C++ ne nécessite pas que l'on dise au GC de se dépécher en remettant des pointeurs à 0 (oups! "références").
Soit le vecteur va ensuite être détruit => remettre à 0 est inutile
Soit les élements détruits doivent être supprimés du vecteur => on fait un erase derrière qui de la même façon retire tout intérêt à la remise à 0 -- clear, même combat.