Discussion :

[transgohan]

Bonjour à toutes et à tous,

reprenant un code j'essaie d'en supprimer les fuites mémoires. Cependant je suis actuellement sur une partie dont je n'arrive pas à me dépatouiller.

Une Map est utilisée pour stocker des pointeurs de n'importe quoi (on y stocke aussi bien des pointeurs vers des entiers que des pointeurs vers des Vectors, ect).

Code c++ :

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
#include <iostream>
#include <map>
 
using namespace std;
 
class BenchEnvironment {
private:
  static BenchEnvironment* pInstance;
 
 public:
  virtual ~BenchEnvironment();
 
  static BenchEnvironment* getInstance();
 
  void addData(std::string key, void* p_dataToAdd);
  void* getData(std::string key);
 
 private:  
  BenchEnvironment();
 
 private:
  std::map<std::string, void*> datas;   
};

Code c++ :

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
#include "BenchEnvironment.h"
 
BenchEnvironment *BenchEnvironment::pInstance = NULL;
 
BenchEnvironment::BenchEnvironment()
{
}
 
BenchEnvironment::~BenchEnvironment()
{
	pInstance = NULL;
}
 
BenchEnvironment *BenchEnvironment::getInstance()
{
	if (pInstance == NULL) {
		pInstance = new BenchEnvironment();
	}
	return pInstance;
}
 
void BenchEnvironment::addData(string key, void *p_dataToAdd)
{
	datas[key] = p_dataToAdd;
}
 
void *BenchEnvironment::getData(std::string key)
{
	return datas.find(key)->second;
}

Utilisant la class de cette manière :

Code c++ :

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

1
2
int test = 1;
BenchEnvironment::getInstance()->addData("test", &test);

Cela m'ajoute 3 allocations mais aucune désallocation selon Valgrind.
Est-ce parce que c'est du void* qu'il ne sait pas comment aller libérer la mémoire des pointeurs ?

[transgohan]

Avec un delete c'est toujours mieux en fait. T_T
Perdu dans la taille du code je n'avais pas fait attention à cela.
Il y a des jours où un café me ferrai pas de mal malgré le fait que je le digère pas...

[gbdivers]

Oui, mais ...

Un delete sur void* compile ???

if the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined.
Note 78 : This implies that an object cannot be deleted using a pointer of type void* because void is not an object type.

Il faut donc (sauf erreur de ma part) faire un cast vers le type, soit avoir une hiérarchie d'objet avec destructeur virtuel

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class A { virtual ~A() {} };
class B : public A {};
 
void delete(void* p) {
   if (p.type() == "int") {
       int* pInt = static_cast<int*>(p)
       delete pInt;
   } else if (p.type() == "A" || p.type() == "") {
       A* pA = static_cast<A*>(p)
       delete pA;
   }
}

Plus généralement, utiliser un void* est très très très très moche
Au pire, utilise boost.any ou boost.variant, mais vérifie quand même si tu n'as pas un problème de conception

Et utiliser les pointeurs intelligents permet d'éviter d'oublier les delete (et est plus exception safe). Par contre, pas sur que ça passe sur un void*

[transgohan]

boost n'est pas une bibliothèque disponible de base.
De plus mes contraintes techniques m'empêcheront de toute manière de l'utiliser. Je joue la taille de mon application à l'octet près en raison d'une cible embarquée très très peu véloce et qui contient peu de mémoire.

Sinon cela ne lui pose aucun problème au compilateur (testé avec GCC et DIAB).
J'effectue actuellement le delete sur l'objet BenchEnvironment (qui est la seule allocation dynamique).
Mes variables sont statiques et donc la mémoire est libérée sans souci.

Sinon je reste dibutatif.
J'ai travaillé hier avec les static_cast pour autre chose et j'ai pu observer qu'il effectuait une copie lors de l'utilisation de static_cast.
Donc du coup il fait une copie castée, et delete le void *, puis delete le int *. Donc on revient à une surcouche pour faire la même chose puisqu'on a toujours le delete du void *.

A moins que ce sur quoi je travaillais soit un cas spécial :
char *pChar = static_cast< char * >(maString.c_str());

[gbdivers]

Pour le cast, oui, tu créés forcement une copie. Quand tu écris

Code :

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

1
2
float f = 12.34;
int i = static_cast<int>(f);

Tu crées une nouvelle variable (i) et il y a bien une copie du temporaire retourné par le cast.
Pour les pointeurs, idem, tu le copies, mais pas l'objet pointé. Il ne devrait pas y avoir d'appelle à delete sur le void* (implicite) puis sur le int* (explicite)

Et pour moi, un delete sur void* devrait échouer, le compilateur ne sait pas le type pointé et devrait donc ne pas savoir la taille de l'objet en mémoire à supprimer

Pour

Code :

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

char *pChar = static_cast< char * >(maString.c_str());

c'est quoi cette idée de faire un cast de const char* vers char* pour faire un delete ? (si j'ai bien compris ce que tu fais)
c_str() créé a priori une copie de ta chaîne en ajoutant un \0 puis tu fais un delete dessus, c'est quoi l'intérêt.
Et string est déjà une mise en oeuvre du RAII, pas besoin de se préoccuper de supprimer les données

Bref, j'ai un peu de mal à comprendre...

[transgohan]

Pas d’inquiétudes la variable char* est belle est bien utilisée avant le delete !

Le programme utilise des string, jusque là pas de souci.
Mais dans une message queue on fait passer que du char* donc vient de là ce cast.

Et string est déjà une mise en oeuvre du RAII, pas besoin de se préoccuper de supprimer les données

On est tout à fait d'accord là dessus, seule une string * mérite ce traitement.