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 :

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);
            }
    );
}
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
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
Malheureusement ce code ne permet pas de :

-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 :

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;}
 
};
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é).

et on créera une deuxième structure :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
template<unsigned int N>
struct my_event_get
{
};
L'objectif :

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.

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>);
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
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...);
}
Merci d'avance.