Discussion :

[Ekinoks]

Salut !

Je fait actuellement un gestionnaire de callback, et j'aurais besoin d'un type qui correspond à l'objet dans le quel on se trouve ? un genre de TYPE_DE(this) ?
Es que c'est possible en C++ ?

Voici du code qui correspond à ce que je souhaite faire :

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
 
struct A
{
   void toClicked( void(*f)(MONTYPE*) ){}  // tel que MONTYPE correspond au type de l'objet, ici A
 
};
 
struct B : public A
{
   // hérite automatiquement de :
   /// void toClicked( void(*f)(MONTYPE*) ){}  // tel que MONTYPE correspond au type de l'objet, ici B
};
 
void f(B *b)
{
//...
}
 
int main()
{
   B b;
 
   b.toClicked(f);  // Comme "b" est de type "B", je lui donne en paramétré une fonction qui demande en paramétré un pointeur d'objet de type "B"
 
}

Quelqu'un aurais une idée de comment je pourrais faire ça ? (es que ce que je cherche à faire ne serais pas la réflexivité ?)

Merci pour votre aide.

[Lucien63]

Tu ne veux pas surcharger la fonction membre toClicked dans B c'est cela ?

[Ekinoks]

Merci pour ta réponse Lucien,

Tu ne veux pas surcharger la fonction membre toClicked dans B c'est cela ?

Oui, voila, c'est exactement ca !
Je ne veux pas avoir à créer à chaque foi la méthode "toClicked" lorsque je créer un nouvelle classe qui hérite de A. (surtout que dans la réalité, beaucoup d'autre action que toClicked), mais je veux que ca se face tout seul.

Tu aurais une idée ? ^^

[Lucien63]

J'ai pas trop compris ce que tu voulais faire mais si ta fonction f à ce prototype

Code :

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

void f(A *b);

ça te pose problème.

Parce que un truc comme cela t'es peut-être suffisant ?

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
#include <iostream>
 
 
struct A
{
   void(*fonc)(A*);
   virtual void toClicked(void(*f)(A*)){fonc = f;}
};
 
struct B : public A
{
 
};
 
void f(A *a)
{
    std::cout << "Appel de la fonction" << std::endl;
}
 
int main(){
 
   B b;
   b.toClicked(f);
   b.fonc(&b);
 
   return 0;
}

[Ekinoks]

Parce que un truc comme cela t'es peut-être suffisant ?

J'étais partie la dessus au début, mais, le fait que la fonction "f" ne peuvent QUE prendre un argument de type "A*" est un peu gênant...

du coups je cherche une manière de contourner cette limitation...

[loufoque]

Sinon, avoir le type d'une expression, c'est le but de decltype intégré à C++0x.
C'est déjà dans GCC 4.3. GCC a aussi une extension, typeof, qui fait quelque chose de similaire.

Boost.Typeof implémente aussi typeof sous Visual C++.

[Ekinoks]

Merci pour ta réponse loufoque, je vais lire de la documentation sur typeof


Je viens de finir de créer un petit exemple qui modélise exactement ma situation.

Voici le code :

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
#include <boost/bind.hpp>
#include <boost/function.hpp>
 
#include <iostream>
 
#define EVENT_CLICKED 1
 
struct CallBack;
 
struct  TK
{
	int creeCallBack(int event, void (*f)(int, CallBack*), CallBack * c)
	{
		//...
	}
 
	void suprimerCallBack(int event)
	{
		//...
	}
};
TK ToolKit;
 
 
/// A utiliser dans boost::bind
#define _ME		_1
#define _EVENT _2
 
 
 
/// Gerer les CallBack
struct CallBack
{
	boost::function1<void, int> f;
	int id_event;
 
	CallBack( boost::function1<void, int> f_, int event) : f(f_)
	{
		/// Créer un callback
		id_event = ToolKit.creeCallBack(event, call, this);
	}
 
	/// methode static appeller lorsque la ToolKit capte un signal
	static void call(int event, CallBack* arg)
	{
		arg->f(event);
	}
 
	~CallBack()
	{
		ToolKit.suprimerCallBack(id_event);
	}
};
 
 
struct Widget
{
	virtual void toClicked( boost::function2<void, Widget*, int> f )
	{
		/// Créer le callback
		new CallBack( boost::bind(f, this, _1), EVENT_CLICKED );
	}
};
 
struct Button : public Widget
{
	Button(const char *nom, boost::function2<void, Button*, int> f)
	{
		/// Créer le boutton
		//...
 
		/// Créer le callback
		new CallBack( boost::bind(f, this, _1), EVENT_CLICKED );
	}
};
 
void f(int arg1, int arg2, Widget *a, int event)
{
	printf("F !\n");
}
 
void fb(int arg1, int arg2, Button *a, int event)
{
	printf("F !\n");
}
 
int main()
{
	Widget a;
	a.toClicked( boost::bind(f, 5, 9, _ME, _EVENT) );
 
	Button b("test", boost::bind(fb, 5, 9, _ME, _EVENT));	// L'utilité du _ME est surtout pour cette situation, pour avoir la possibilité de recevoir un poiteur de l'élement que l'on créer
 
	//b.toClicked( boost::bind(fb, 5, 9, _ME, _EVENT) );	// Marche pas ! Ici le toClicked s'attend à recevoir comme _ME un Widget et non pas un Button.
}

EDIT : Je viens de retarder du coté de typeof, et... effectivement il se pourrais bien que ça puissent résoudre mon problème ! ^^

EDIT2 : Quoi que en fait peu être pas... :^/

[loufoque]

Bah tu veux le type de quoi ?

[Ekinoks]

Bah tu veux le type de quoi ?

En fait c'est dans la déclaration d'une méthode que je veux un type particulier style comme ca :

Code :

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

void toClicked( boost::function2<void, typeof(this), int> f )

[loufoque]

Pourquoi t'utilises pas le CRTP ?

[Ekinoks]

Pourquoi t'utilises pas le CRTP ?

Ho mon dieu !!! Il est fantastique ce CRTP !!!

Comment j'ai pu vivre sans ! :p


Bon, bha ca résoud très joliment mon problème !

Merci à tous pour votre aide.

PS : he... loufoque, pourrais je savoir ou a tu appris ce pattern ? Un livre ? Un site ? ^^;

[Davidbrcz]

disons que le CRTP fait partie des idiomes de bases du C++ (comme le RAII ou comme le copy-and-swap)

[loufoque]

Je n'ai jamais lu le moindre livre d'informatique, donc je suppose que ce doit être via Internet (sites, forums, usenet, mailing lists, IRC...)

[Ekinoks]

Erf, en fait j'ai toujours un problème, même avec CRTP :'(

Disons que j'ai ma classe de base qui s'appelle Widget définie comme ca :

Code :

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

1
2
3
4
5
6
7
8
9
template<class Derived> class Widget
{
   void toClicked( boost::function2<void, Derived*, int> f )
   {
      /// Créer le callback
      new CallBack( boost::bind(f, static_cast<Derived*>(this), _1),
                    EVENT_CLICKED );
   }
};

J'ai ensuite tout mes objet qui hérite de cette classe, par exemple Button :

Code :

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

1
2
3
4
class Button : public Widget<Button>
{
   //...
};

De cette manière tout les classe qui hérite de Widget peuvent utiliser la méthode toClicked en donnant en paramètre une fonction qui prend leur type en paramètre.
par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
//fonction qui prend en paramètre un type Button
void fb(Button *b, int event){}
 
void main()
{
   Button b;
   b.toClicked(fb);
}

Jusqu'à là c'est parfait !

Par contre, si maintenant j'ai un objet qui hérite pas directement de ma classe de Widget, là ça marche plus. (Par exemple si j'ai ButtonEvolue qui hérite de Button)
Si je fait appelle à la méthode toClicked à partir d'un objet ButtonEvolue, je ne pourrais pas donner en paramètre une fonction qui prend en argument un "ButtonEvolue*".

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class Button2 : public Button
{
   //...
};
 
//fonction qui prend en paramètre un type Button2
void fb2(Button2 *b, int event){}
 
void main()
{
   Button2 b2;
   b2.toClicked(fb2);  // Marche pas car le premier argument de fb2 est de type Button2*
}

Es moi qui n'utilise pas correctement CRTP ? ou faut t'il s'y prendre d'un autre manier ?
S'il vous plaît, j'aurais besoin d'un dernier petit coup de pouce car là je m'en sort vraiment pas et je n'arrive pas à voir comment je pourrais faire pour résoudre ce problème :'(


Merci pour votre aide.

[Lucien63]

Une question ?
En quoi ça te genes que le 1er paramètre de ta fonction fb2 soit de type Button ?

[Ekinoks]

Une question ?
En quoi ça te genes que le 1er paramètre de ta fonction fb2 soit de type Button ?

Merci pour ta réponse Lucien63,

Donc en fait, je suis en train d'écrire une lib graphique qui, lorsque je créer des éléments (un Button2 par exemple), donne la possibilité d'attacher une fonction binder qui s'attache automatiquement à l'action par défaut (pour le bouton, c'est le clic classique).

Le problème qui se pose, c'est que comme c'est dans le constructeur, si je veux binder l'adresse de l'objet que je créer, ca ne peu pas se faire directement en donnant le pointeur, car on ne connait pas l'adresse avant qu'il soit créé.
La méthode que j'ai trouvé est d'utiliser le "_1" de boost::bind pour dire qu'il le remplace par le pointeur de l'objet en question.

Mais il faut arriver à transformer le "this" dans le bon type, d'ou tout ce tralala...


Maintenant, si lorsque je créer un objet de type Button2 je ne peu pas donner en paramètre qu'une fonction qui ne prend pas en argument un "Button2*" mais seulement un "Button*"... cela met de trop grosse restriction :^/

[loufoque]

Tu pourrais peut-être faire comme ceci

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
template<typename T>
struct Button_common : Widget<T>
{
   /* tous les trucs communs aux boutons */
};
 
struct Button : Button_common<Button>
{
   /* les constructeurs qu'il faut se retaper */
};
 
struct Button2 : Button_common<Button2>
{
   /* les trucs nouveaux */
};

Enfin personnellement je comprends même pas pourquoi tu veux le vrai type de l'objet dans ton bind.

[Lucien63]

cela met de trop grosse restriction

lesquelles ?

[Ekinoks]

Merci pour vos réponses.

Tu pourrais peut-être faire comme ceci

Oui, effectivement, mais du coup cela complexifie un peu l'arbre des héritages, et je ne pourrais pas avoir un objet qui hérite directement de Button ou de Button2

lesquelles ?

par exemple si Button2 possède une méthode "uneActionSpecifiqueABoutton2"
et que je veux le créer comme ca:

Code :

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

1
2
 
Boutton2 b2("nom_du_bouton", boost::bind(&Button2::uneActionSpecifiqueABoutton2, _ME, /*argument*/));

[Ekinoks]

Ok, j'ai trouvé comment faire !

J'ai créé des fonctions "toFunction" qui prennent en argument un boost::bind et le transforme en boost::function.

Il regarde quel est le type des arguments que demande la fonction binder, et le transmet au template de boost::function.

Pour faire ceci, j'ai du prendre en compte tout les cas possible et surcharger a chaque foi la fonction "toFunction"
Je me retrouve ainsi avec un peu plus de 300 surcharge de "toFunction". (j'ai avidement écrit un petit scripte pour qu'il me les générer automatiquement ^^)

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
template <class R>
inline boost::function2 <R, void*, int> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(),
				boost::_bi::list0
			> b )
{
	return b;
}
 
template <class R, class B1>
inline boost::function2 <R, void*, int> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(B1),
				boost::_bi::list1<boost::_bi::value<B1> >
			> b )
{
	return b;
}
 
template <class R, class A2>
inline boost::function2 <R, void*, A2> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(A2),
				boost::_bi::list1<boost::arg<2> (*)() >
			> b )
{
	return b;
}
 
template <class R, class A1>
inline boost::function2 <R, A1, int> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(A1),
				boost::_bi::list1<boost::arg<1> (*)() >
			> b )
{
	return b;
}
 
template <class R, class B1, class B2>
inline boost::function2 <R, void*, int> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(B1, B2),
				boost::_bi::list2<boost::_bi::value<B1>, boost::_bi::value<B2> >
			> b )
{
	return b;
}
 
template <class R, class A2, class B1>
inline boost::function2 <R, void*, A2> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(A2, B1),
				boost::_bi::list2<boost::arg<2> (*)(), boost::_bi::value<B1> >
			> b )
{
	return b;
}
 
template <class R, class A2, class B1>
inline boost::function2 <R, void*, A2> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(B1, A2),
				boost::_bi::list2<boost::_bi::value<B1>, boost::arg<2> (*)() >
			> b )
{
	return b;
}
 
template <class R, class A1, class B1>
inline boost::function2 <R, A1, int> toFunction( boost::_bi::bind_t	<
				R,
				R (*)(A1, B1),
				boost::_bi::list2<boost::arg<1> (*)(), boost::_bi::value<B1> >
			> b )
{
	return b;
}
 
...
...
...

Comme les résolutions des surcharges et des templates est faite à la compilation, ce code devrais être très rapide a l'exécution.

ensuite pour l'utiliser j'ai juste a faire comme ca :

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
 
class Widget
{
	public :
		template <class F>
		void toClicked( F f )
		{
			toClicked2(toFunction(f)); // donne a toClicked2 le bon type
		}
	private :
		template <class D>
		void toClicked2( boost::function2<void, D*, int> f )
		{
			/// On peu caster this en D
			new CallBack( boost::bind(f, static_cast<D*>(this), _1), EVENT_CLICKED );
		}
};

Encore merci pour vos aides.