Bonjour, j'ai essayer de créer un GUI et je rencontre quelques problèmes :
Je souhaite créer une fonction connect (entre un signal et une fonction), qui prend en paramètre un std::string et une classe Callback (qui contient un std::function<void(void*)) .
Afin de faciliter l'utilisation de cette fonction connect, j'ai créer une fonction
template<typename R, typename Fc, typename ...Args>
R make_callback(R& retour, Fc func, Args&...arg).
Dans l'état actuel, cette fonction est capable de créer un std::function<void(void*)> qui appellera la fonction fc, avec les paramètres qu'il y a dans arg en en stockant la valeur de retour dans retour.
Voici comment est créée cette fonction :
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 template<typename R, typename fc, typename ...Args> Callback make_callback(R& retour,fc function, Args&... param) { std::tuple<Args&...> my_tuple(param...); return Callback ( [ function, &retour,my_tuple ] (void*even) { retour=call_function<R, fc, Args...>(function, my_tuple); } ); }
Malheureusement ce code ne permet pas de :
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 #ifndef FUNCTION_HPP_INCLUDED #define FUNCTION_HPP_INCLUDED #include <tuple> template<typename R, unsigned int N> struct __Apply_aux__ { template<typename Func, typename... ArgsT, typename... Args> static R apply(Func f, std::tuple<ArgsT...> & t,Args&... args) { return __Apply_aux__<R,N-1>::apply(f, t, std::get<N-1>(t), args...); } }; // Terminal case, call the function with unpacked arguments template<typename R> struct __Apply_aux__<R,0> { template<typename Func, typename... ArgsT, typename... Args> static R apply(Func f, std::tuple<ArgsT...> &, Args&... args) { return f(args...); } }; template<typename R,typename T, typename ...Args> R call_function(T fc, const std::tuple<Args&...> & t) { return __Apply_aux__<R,sizeof...(Args)>::apply(fc, const_cast<std::tuple<Args&...> &>(t)); } #endif // FUNCTION_HPP_INCLUDED
-ne pas vouloir de valeur de retour
-d'accéder a ce qu'il y a dans le void*even.
Pour combler le premier problème, j'ai créé une deuxième fonction (make_callback_void) qui ne prend pas de type de retour. Bien que ce système ne me satisfait pas il est suffisant (si quelqu'un a une autre solution, je prend).
Pour le deuxième problème, j'ai créé une structure :
On indiquera, lors de l'appel de make_callback le type de l'event que la fonction va recevoir (on pourra donc caster le void* en l'event approprié).
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10 template<typename ...Args> class Event { private : std::tuple<Args...> arg; public : Event(Args...args) : arg(args){} std::tuple<Args...> get_tuple(){return arg;} };
et on créera une deuxième structure :
L'objectif :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 template<unsigned int N> struct my_event_get { };
Dans le cas ou un des paramètres est un my_event_get<DE_NIMPORTE_QUEl_NOMBRE>, il faudrait pouvoir passer a la fonction ce qu'il y a dans le tuple de l'event.
Quelqu'un aurait-il une idée comment faire pour que dans la fonction call_function, on puisse faire un
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6 double my_function(int one, int two) { return (double)one/two } struct_servant_a_passer_le_template<int, double/*Ces parametres template permettent d'indiquer le type de l'evenement transmit*/>::make_callback(my_double, my_function, 5, my_event_get<0>);Merci d'avance.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 if(std::get<N-1>(t)==my_event_get<DE_NIMPORTE_QUEl_NOMBRE>) { return __Apply_aux__<R,N-1>::apply(f, t,std::get<DU_TEMPLATE DE LA STRUCTURE>(( (std::get<N-1>(t)).get_tuple())), args...); }
Partager