Identifier type de données et instance de classe

**emmr.rida** · 14/07/2009, 01h12

Bonsoir,
J'ai un tableau de pointeurs (void *) dans lequel je stoque les adresses d'objets de n'importe quel type partant du bool, int, double vers les objets instances de classes.
J'aimerai bien identifier chaque élément de mon tableau et savoir si c'est un type de données C/C++ ou bien un objet en évitant un très longue code de vérification tel que :
if(typeid(*(int *)pv) == typeid(int)) {
} else if...

Dans l'attente de vos réponses, veuillez agréer mes demoiselles, dames et messieurs mes remerciéments et salutations les plus distingués.

**3DArchi** · 14/07/2009, 09h41

Salut,
Pourquoi ne pas utiliser boost.any ou boost.variant selon ton besoin ?

**emmr.rida** · 14/07/2009, 11h01

C'est un petit projet personnel auquel j'aimerai ne pas utiliser de bibliothéque supplémentaire. J'ai testé une petite hack qui consiste à convertir un pointeur d'un type de données standard en un pointeur d'objet d'une classe et le passé à typeid. Si le pointeur n'est pas un pointeur vers un objet d'une classe le typeid léve une exception std::__non_rtti_object mais je suis persuadé que la gestion des exceptions coute très chers en ce qui concerne le temps CPU.

Je me demande si y a une solution propre et portable...
Merci.

**Davidbrcz** · 14/07/2009, 16h49

Envoyé par emmr.rida

Bonsoir,
J'ai un tableau de pointeurs (void *) dans lequel je stoque les adresses d'objets de n'importe quel type partant du bool, int, double vers les objets instances de classes.
J'aimerai bien identifier chaque élément de mon tableau et savoir si c'est un type de données C/C++ ou bien un objet en évitant un très longue code de vérification tel que :
if(typeid(*(int *)pv) == typeid(int)) {
} else if...

Dans l'attente de vos réponses, veuillez agréer mes demoiselles, dames et messieurs mes remerciéments et salutations les plus distingués.

Ca sent la mauvaise conception. Pourquoi as tu besoin de stocker dans du void* des choses aussi heterogenes que des int, bool, ... ?
Le C++ est tel que void* devrait etre banni, au moins dans les conteneurs.

PS/ viendrait tu de Java ?

**emmr.rida** · 14/07/2009, 20h00

Non, je viens du dotnet et avant je viens du C/C++.
A vrai dire j'essais de réaliser un Garbage Collector en C++. Gérer une Heap spéciale pour les blocks mémoire alloués me semble un investissement très cher pour un petit projet personnel (juste pour le plaisir de la programmation durant mon temps libre). Donc, je stoque les adresses mémoire alloués dans une hash table et j'ai besoin de connaitre le type de chaque block mémoire pour libération propre. Donc si y a des suggestions, je suis prenant!
Merci pour vos réponses.

**3DArchi** · 14/07/2009, 20h08

Utilises des pointeurs intelligents. Un article Pointeurs intelligents de Loïc Joly présente très bien la chose. Les pointeurs intelligents sont le garbage collector du C++.

**emmr.rida** · 14/07/2009, 20h23

J'ai déjà crée une implémentation spéciale des pointeurs intelligents pour mon petit system et la FAQ et les articles DVP m'ont bien aidé...
J'aimerai bien continuer avec la structure actuelle de mon GC et à tout problème étrange la solution est aussi étrange, non?

**3DArchi** · 14/07/2009, 20h42

Pour ton GC, utilise tes pointeurs intelligents alors. Pourquoi rajouter une couche ?
Sinon, éventuellement quelque chose comme ça :

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
 
struct GC_ElementBase
{
   virtual  ~GC_ElementBase()=0;
};
template<class T>
struct GC_Element : public GC_ElementBase
{
   ~GC_Element(){}
   emmr::smart_ptr<T> element;
};
 
struct GC
{
std::vector<GC_ElementBase> allocations_en_cours;
};

A la réflexion, n'utiliserais-tu pas des void* car l'approche générique posait problème ? Peut être que l'article de Alp sur le Type Erasure est une réponse à ton problème de base ?

**emmr.rida** · 14/07/2009, 20h50

Oui, je sens que c'est à ça que je voulais arrivé mais il me manquait quelque chose!
Merci 3DArchi, je vais étudier ce que tu m'as proposé et te dire si ça a marché.
Merci bien.

**emmr.rida** · 15/07/2009, 16h11

J'ai appri tant de choses en étudiant l'article que tu m'as proposé 3DArchi

Cependant... Voici mon problème :
J'ai un GC qui compte le nombre d'utilisation d'un block mémoire et quand le nombre atteint ZERO, GC doit libérer ce block mémoire.
J'ai une classe qui gére les pointeurs des blocks mémoire. Cette classe et +/- une implémentation des pointeurs intelligents qui incrémente ou décrémente le nombre d'utilisation du block mémoire géré quand elle reçoit un pointeur ou quand elle le perde. Elle ne détruit pas! Elle met à jour le nombre d'utilisation d'un block mémoire dans le GC.
Le GC (pour simplifier les choses) a une hash table map<unsigned int, size_t> dont la clé est l'adresse du block mémoire et la valeur est le nombre d'utilisation du block mémoire par mis à jour par emmr::smart_pointer. Quand size_t devient ZERO je veux détruire unsigned int.
Je sais que la conception laisse à désirer mais je veux pas perdre du temps à créer un gestionnaire de mémoire pour mon GC simpliste.

**3DArchi** · 15/07/2009, 16h25

Salut,
Si tu as compris l'article, en gros tu as compris qu'il te faut remplacer la clé unsigned int (que tu devais sauvagement casté en void* non ?

) en GC_ElementBase.

**emmr.rida** · 15/07/2009, 17h09

Si je touche pas à mon smart_ptr et que je stoque les adresses des blocks mémoire sous forme de GC_Element casté en GC_ElementBase, je dois parcourir toute la liste pour trouver le GC_Element lequel je dois mettre à jour son ref count.
Si je modifie mon smart_ptr pour gérer des GC_Element, des couches et des indirections supplémentaires sans réel raison.
Si je suis à coté de la plaque, n'hésite pas à me corriger.

**3DArchi** · 15/07/2009, 17h12

Pour que ce soit plus clair, montre ton code : ta GC, ton smart ptr, ta gestion de l'allocation et de la libération.

**emmr.rida** · 15/07/2009, 18h50

Je voulais envoyer une copie du projet VC++ mais la page de gestion de pièces jointes reste figée! Donc :

SimpleGC.h

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#pragma once
 
#ifdef _PRINT_MEMORY_LEAKS
	#define _CRTDBG_MAP_ALLOC
	#include <stdlib.h>
	#include <crtdbg.h>
#endif
 
// Every object who would be freed by GC
// have to inherit from GCDestructor
class GCDestructor
{
public :
	// Called by GC managed classes destructor to cleanup object's memory
	virtual void DoGCDestructor(void) = 0;
};
 
 
class SimpleGC
{
private :
	typedef std::map<unsigned int, int> objects_map;
	typedef std::map<unsigned int, int>::iterator iterator_map;
 
	objects_map objmap; // Hash table to store memory adresses
	size_t m_nObj2Free; // Number of objects that need to be freed
	size_t m_nBytes2Free; // Number of bytes that need to be freed
	bool m_IsNowFreeing; // true when GC is actually freeing memory
public :
	size_t m_nFreeOnSize; // Size of free bytes to start free unused memory
public :
	static const int REFC_INC = +1;
	static const int REFC_DEC = -1;
public:
	SimpleGC(void) : m_nObj2Free(0), m_nBytes2Free(0), m_nFreeOnSize(10 * 1024), m_IsNowFreeing(0)
	{
	}
 
	~SimpleGC(void)
	{
		FreeUnusedMemory();
 
#ifdef _PRINT_MEMORY_LEAKS
		_CrtDumpMemoryLeaks();
#endif
	}
 
	int UpdateReferenceCounter(void *pobject, int value)
	{
		if(pobject == NULL) throw "Argument NULL Reference!";
		objmap[(unsigned int)pobject] += value;
		int refc = objmap[(unsigned int)pobject];
		if(refc <= 0) {
			m_nObj2Free++;
			m_nBytes2Free += _msize((char *)pobject);
			if(m_nBytes2Free >= m_nFreeOnSize) {
				if(!m_IsNowFreeing) { // Free now or later
					FreeUnusedMemory();
				}
			}
		}
		return refc;
	}
 
	void FreeUnusedMemory(void)
	{
		if(objmap.size() <= 0) return;
		m_IsNowFreeing = true;
		size_t nObjFreed = 0;
		size_t nBytesFreed = 0;
		iterator_map it = objmap.begin();
		do {
			if(it->second <= 0) {
				// Delete the object...
				// Too nasty and too slow!
				size_t n = _msize((void *)it->first);
				try {
				bool b = typeid(*(GCDestructor *)it->first) == typeid(GCDestructor);
					((GCDestructor *)it->first)->DoGCDestructor();
					delete (void *)it->first;
				} catch(...) {
					free((void *)it->first);
				}
				objmap.erase(it);
				it = objmap.begin();
				nObjFreed++;
				nBytesFreed += n;
			} else {
				std::advance(it, 1);
			}
		} while(it != objmap.end());
		// Verify operation validity
		if((nObjFreed != m_nObj2Free) || (nBytesFreed != m_nBytes2Free)) {
			throw "Internal GC Error!";
		}
		m_nObj2Free -= nObjFreed;
		m_nBytes2Free -= nBytesFreed;
		m_IsNowFreeing = false;
	}
};
 
extern SimpleGC __GC;

SimpleGC.cpp

Code :

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

1
2
3
4
5
6
7
#define _PRINT_MEMORY_LEAKS
#include <map>
#include <typeinfo>
 
#include "SimpleGC.h"
 
SimpleGC __GC;

GCPointer.hpp

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
#pragma once
 
template<class T>
class GCPointer
{
private :
	T *m_pTPointer;
	size_t m_Count;
private :
	void CheckArray(void);
public :
	static const T *GCP_NULL;
public:
	GCPointer(void);
	GCPointer(const GCPointer<T> &ptr);
	GCPointer(const T *pobject);
	~GCPointer(void);
public :
	size_t GetCount(void);
	bool IsUnique(void);
	size_t GetUsageCount(void);
	bool IsEmpty(void);
	void Reset(void);
	T *GetPointer(void);
public : // Operators
	bool operator ==(const GCPointer<T> &ptr);
	bool operator !=(const GCPointer<T> &ptr);
	bool operator ==(const T *pobject);
	bool operator !=(const T *pobject);
	bool operator ==(const T &value);
	bool operator !=(const T &value);
	GCPointer<T> &operator =(const GCPointer<T> &ptr);
	GCPointer<T> &operator =(const T *pobject);
	T &operator =(const T &value);
	T &operator [](const int &index);
	operator T(void);
	T &operator *(void) const;
	T *operator ->(void) const;
};
 
template<class T>
const T *GCPointer<T>::GCP_NULL = (T *)NULL;
 
template<class T>
void GCPointer<T>::CheckArray(void)
{
	if(m_pTPointer == NULL) {
		m_Count = 0;
		return;
	}
	m_Count = _msize(m_pTPointer) / sizeof(*m_pTPointer);
}
 
template<class T>
GCPointer<T>::GCPointer(void) : m_pTPointer(0), m_Count(0)
{
}
 
template<class T>
GCPointer<T>::GCPointer(const GCPointer<T> &ptr) : m_pTPointer(0), m_Count(0)
{
	if(ptr.m_pTPointer == ptr.GCP_NULL) return;
	m_pTPointer = ptr.m_pTPointer;
	__GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_INC);
	CheckArray();
}
 
template<class T>
GCPointer<T>::GCPointer(const T *pobject) : m_pTPointer(0), m_Count(0)
{
	if(pobject == NULL) return;
	m_pTPointer = (T *)pobject;
	__GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_INC);
	CheckArray();
}
 
template<class T>
GCPointer<T>::~GCPointer(void)
{
	if(m_pTPointer != NULL) __GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_DEC);
}
 
template<class T>
size_t GCPointer<T>::GetCount(void)
{
	return m_Count;
}
 
template<class T>
bool GCPointer<T>::IsUnique(void)
{
	if(m_pTPointer == NULL) return false; // Should throw?!
	return __GC.UpdateReferenceCounter(m_pTPointer, 0) == 1;
}
 
template<class T>
size_t GCPointer<T>::GetUsageCount(void)
{
	if(m_pTPointer == NULL) return 0;
	return (size_t)__GC.UpdateReferenceCounter(m_pTPointer, 0);
}
 
template<class T>
bool GCPointer<T>::IsEmpty(void)
{
	return m_pTPointer == NULL;
}
 
template<class T>
void GCPointer<T>::Reset(void)
{
	*this = GCP_NULL;
}
 
template<class T>
T *GCPointer<T>::GetPointer(void)
{
	return m_pTPointer;
}
 
template<class T>
bool GCPointer<T>::operator ==(const GCPointer<T> &ptr)
{
	return m_pTPointer == ptr.m_pTPointer;
}
 
template<class T>
bool GCPointer<T>::operator !=(const GCPointer<T> &ptr)
{
	return m_pTPointer != ptr.m_pTPointer;
}
 
template<class T>
bool GCPointer<T>::operator ==(const T *pobject)
{
	return m_pTPointer == pobject;
}
 
template<class T>
bool GCPointer<T>::operator !=(const T *pobject)
{
	return m_pTPointer != pobject;
}
 
template<class T>
bool GCPointer<T>::operator ==(const T &value)
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	return *m_pTPointer == value;
}
 
template<class T>
bool GCPointer<T>::operator !=(const T &value)
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	return *m_pTPointer != value;
}
 
template<class T>
GCPointer<T> &GCPointer<T>::operator =(const GCPointer<T> &ptr)
{
	if((ptr.m_pTPointer == ptr.GCP_NULL) && (m_pTPointer == NULL)) return *this;
	if(m_pTPointer == NULL) {
		m_pTPointer = ptr.m_pTPointer;
		__GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_INC);
		CheckArray();
		return *this;
	}
	__GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_DEC);
	m_pTPointer = ptr.m_pTPointer;
	if(m_pTPointer != NULL) __GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_INC);
	m_Count = ptr.m_Count;
	return *this;
}
 
template<class T>
GCPointer<T> &GCPointer<T>::operator =(const T *pobject)
{
	if((pobject == NULL) && (m_pTPointer == NULL)) return *this;
	if(m_pTPointer == NULL) {
		m_pTPointer = (T *)pobject;
		__GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_INC);
		CheckArray();
		return *this;
	}
	__GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_DEC);
	m_pTPointer = (T *)pobject;
	if(m_pTPointer != NULL) __GC.UpdateReferenceCounter(m_pTPointer, SimpleGC::REFC_INC);
	CheckArray();
	return *this;
}
 
template<class T>
T &GCPointer<T>::operator =(const T &value)
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	*m_pTPointer = value;
	return *m_pTPointer;
}
 
template<class T>
T &GCPointer<T>::operator [](const int &index)
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	if(index >= (int)m_Count) throw "Argument out of range!";
	return m_pTPointer[index];
}
 
template<class T>
GCPointer<T>::operator T(void)
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	return *m_pTPointer;
}
 
template<class T>
T &GCPointer<T>::operator *(void) const
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	return *m_pTPointer;
}
 
template<class T>
T *GCPointer<T>::operator ->(void) const
{
	if(m_pTPointer == NULL) throw "Null referenced pointer!";
	return m_pTPointer;
}

Merci pour l'attention, l'effort et le temps

**jabbounet** · 15/07/2009, 18h57

pour ton GC en C/C++ as tu penser a regarder par là

http://www.hpl.hp.com/personal/Hans_Boehm/gc/
http://developers.sun.com/solaris/articles/libgc.html

d'autres personnes se sont déjà attaqué au sujet.

**emmr.rida** · 15/07/2009, 19h37

Le premier je l'ai déjà vu, le deuxième je vais le voir surement. Merci.
Y en a aussi sur CodeProject.com

**jabbounet** · 16/07/2009, 10h53

Ceci dit implémenter un garbage collector en c++, je ne sais pas si ce ne serias ps plus simple de passer a java dans ce cas.

**emmr.rida** · 17/07/2009, 13h26

C'est pas ça la question, c'est juste une idée qui m'est passée par la tête et je voulais essayer mais je crois que j'ai bloqué grave!

**3DArchi** · 17/07/2009, 14h29

Envoyé par emmr.rida

Je voulais envoyer une copie du projet VC++ mais la page de gestion de pièces jointes reste figée! Donc :

Tu peux me mettre aussi ta surcharge des new/delete et un exemple d'utilisation.

**emmr.rida** · 17/07/2009, 14h51

Mon but n'est pas de créer un garbage collector pour utilisation par d'autres programmeurs ou un niveau aussi avancé! C'est juste une idée que j'avais cru pouvoir développer en une heure ou deux. Mais...

Voici le fichier main.cpp

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
43
44
45
46
47
48
49
#include <iostream>
#include <map>
#include <malloc.h>
#include <typeinfo>
#include "SimpleGC.h"
#include "GCPointer.hpp"
 
class Test : public GCDestructor
{
public :
	GCPointer<char> ptrc;
	char *buffer;
 
	Test(size_t count)
	{
		ptrc = new char[count];
		buffer = new char[count];
	}
 
	~Test(void)
	{
		DoGCDestructor();
	}
 
	void DoGCDestructor(void)
	{
		delete[] buffer;
		// Now we have to do this because unknown type delete doesn't clean up object
		// before freeing memory.
		ptrc = ptrc.GCP_NULL;
	}
};
 
void main(void)
{
	__GC.m_nFreeOnSize = 10 * 1024;
 
	GCPointer<Test> ptrt;
	for(int i = 0; i < 10000; i++) {
		GCPointer<int> ptri = new int[i + 1];
		ptri = i;
		GCPointer<double> ptrd = new double[i + 1];
		ptrd = (double)i;
		ptrt = new Test(i + 1);
		ptrt->ptrc[0] = '\0';
 
		std::cout << std::endl << *ptri;
	}
}

EDiT :
J'ai pas surcharger les opérateurs delete et new. J'aimerai garder le plus simple possible.

Identifier type de données et instance de classe

Langage C++

Discussions similaires

Partager

Partager