Discussion :

[themadmax]

Bonjour,
J'utilise des sortes de variables étendu dans un programme, qui permettent de faire de la pseudo réflexion sur le contenu des variables membre d'une classe.
Pour être plus claire voici a quoi cela ressemble:

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
#include <string>
#include <iostream>
#include <vector>
 
class Value
{
	int _value ;
	std::string _name ;
 
public:
	Value(const std::string& name, int v);
	const std::string& getName();
	int get();
};
 
Value::Value(const std::string& name, int v) : _name(name), _value(v) {}
int Value::get() { return _value; }
const std::string& Value::getName() { return _name; }
 
class Container
{
	std::vector<Value*> _values ;
public:
	friend std::ostream& operator <<(std::ostream &os,const Container &obj) ;
	void add(Value* v);
};
 
std::ostream& operator <<(std::ostream &os,const Container &obj)
{
	std::vector<Value*>::const_iterator it = obj._values.begin() ;
	for ( ; it != obj._values.end(); it++ )
	      	os << (*it)->getName() << " : " << (*it)->get() << std::endl ;
      	return os;
}
 
void Container::add(Value* v)
{
	_values.push_back( v );
}
 
class Test : public Container
{
	Value _v;
public:
	Test();
};
 
Test::Test() : _v("age",12)
{
	add( &_v );
}
 
int main()
{
	Test t ;
	std::cout << t ;
}

Il doit surement exister d'autre implémentation j'aimerai savoir si vous avez déjà utilisé ce genre de "truc". Mais besoin serai d'avoir un automatise qui évite l'appel a chaque fois de la fonction add, et aussi mais dans mes rêves serai de savoir la listes des valeurs mais sans intensité la classe.

Merci d'avance de vos avis

[poukill]

Hello !

Moi ça me parait pas débile ton truc. J'ai même regardé en templatisant, ce que tu avais déjà fait j'imagine.

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
 
#include <string>
#include <iostream>
#include <vector>
 
template <typename T>
class Value
{
	T _value ;
	std::string _name ;
 
public:
	Value(const std::string& name, T v);
	const std::string& getName() const;
	T get() const;
};
 
template <typename T> Value<T>::Value(const std::string& name, T v) : _name(name), _value(v) {}
template <typename T> T Value<T>::get() const { return _value; }
template <typename T> const std::string& Value<T>::getName() const { return _name; }
 
template <typename T>
class Container
{
	std::vector<Value<T>*> _values ;
public:
	template <typename U>
	friend std::ostream& operator <<(std::ostream &os,const Container<U> &obj) ;
	void add(Value<T>* v);
};
 
template <typename T>
std::ostream& operator <<(std::ostream &os,const Container<T> &obj)
{
	std::vector<Value<T>*>::const_iterator it = obj._values.begin() ;
	for ( ; it != obj._values.end(); it++ )
		os << (*it)->getName() << " : " << (*it)->get() << std::endl ;
	return os;
}
 
template <typename T>
void Container<T>::add(Value<T>* v)
{
	_values.push_back( v );
}
 
class Test : public Container<int>
{
	Value<int> _v;
public:
	Test();
};
 
Test::Test() : _v("age",12)
{
	add( &_v );
}
 
int main()
{
	Test t ;
	std::cout << t ;
}

Y'a quand même plusieurs défauts à ce système:

1. Tu es très intrusif : pour que ton système de réflexion soit étendu à une classe, il faut carrément la recoder. Ca oblige donc à prévoir la conception à l'avance. On sait tous que c'est pas toujours possible !
2. Ca oblige quelques bizarreries, notamment ton héritage public, alors que la classe de base n'a ni destructeur virtuel (attention), ni fonction membre virtuelle. Bref, on comprend pas trop pourquoi. Moi, ça me convient moyennement.
3. Tu places un petit bout de "connaissance" dans chaque classe. J'aurai plutôt vu un endroit où toute l'introspection est faite. Mais ça c'est plus personnel !

Perso, j'utilise CAMP depuis peu. Je l'ai trouvé sur ce post de Laurent, et je la trouve très bien foutue. Ca m'a permis de gérer mes paramètres internes de classes depuis mon IHM, alors que ma conception initiale était très loin de ça !

Je sais pas si tu y as déjà jeté un coup d'oeil, mais ça vaut le coup !

[themadmax]

Merci de la réponse je regarderai de plus près.
En tout cas j'ai la même problématique que toi j'utilise cette introspection pour la sérialisation et aussi pour la configuration dans l'interface graphique.
Le souci c'est que j'ai des variables "étendues" contraint ex. [0=>100].

Sinon pour le passage en template en effet j'ai implémenté une Value générique, et une class template qui en hérite mais par contre mon container n'est pas en template ce qui permet de contenir tous les types.

Code :

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

1
2
3
4
5
6
7
8
9
10
class Value {...};
template <class T> class TValue : public Value {...};
class Container {
std::vector<Value*> _values ;
};
class Test : public Container
{
	Value<int> _v;
	Value<float> _w;
};

[poukill]

En tout cas j'ai la même problématique que toi j'utilise cette introspection pour la sérialisation et aussi pour la configuration dans l'interface graphique.

Perso, j'ai résolu ce problème avec CAMP. Le moteur d'introspection permet de Register un peu comme une factory, tagger toute variable membre et fonction. Je m'en sers même pour documenter : mon IHM affiche une courte descrition de telle ou telle variable ou fonction.
C'est non intrusif, ça supporte les hiérarchies polymorphes, et c'est super facile à prendre en main !
A essayer d'urgence !

Le souci c'est que j'ai des variables "étendues" contraint ex. [0=>100].

Là j'ai pas compris, tu peux développer ?

[Laurent Gomila]

Les containtes peuvent aussi être implémentées avec CAMP en utilisant les tags (on peut ajouter par exemple les paires <"min", 0> et <"max", 100> comme tags à certaines propriétés).

[themadmax]

Merci pour vos réponses, surtout sur la possibilité des ces variables contraintes.
Hélas pour le moment l'accès au site et fermé si vous avez un mirror...