J'ai réussi!
Par contre le code source n'est pas simple à comprendre.
#ifndef FUNCTION
#define FUNCTION
namespace sfgl {
namespace helper {
template<int ...> struct seq {};
template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};
template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
}
template<typename R> class Function {
public :
template <typename ...A> Function (R(*f)(A...)) : function(&f) {
}
template <typename ...A> R operator()(A... args) {
R(*func)(A...) = *reinterpret_cast<R**>(function);
std::tuple<A...> params = std::make_tuple(args...);
return callFunc(typename helper::gens<sizeof...(A)>::type(), params);
}
template<int ...S,typename ...A>
R callFunc(helper::seq<S...>, std::tuple<A...> params) {
R(*func)(A...) = *reinterpret_cast<R**>(function);
return f(std::get<S>(params) ...);
}
private :
R** function;
};
Ce que je voulais faire c'est wrapper n'importe quel type de pointeur sur fonction pour l'appeler plus tard.
Afin de wrapper ensuite ces pointeurs de fonctions dans un conteneur avec un id ainsi j'appelle le bon pointeur de fonction en passant l'id du pointeur de fonction au conteneur.
void f (std::string text, std::string text2) {
std::cout<<"I'm a function "<<text<<" "<<text2<<endl;
}
int main () {
std::map<std::string, Function<void>> ptrfunc;
Function<void> f1 = &f;
ptrfunc.insert(std::pair<std::string, Function<void>>("Fonction test", f1));
std::map<std::string, Function<void>>::iterator it = ptrfunc.find("Fonction test");
it->second("text1", "text2");
return 0;
}
Ainsi je stocke tout mes signaux dans un conteneur en les liant à une action, et lors du déclenchement d'un event, j'appelle la bonne fonction suivant son id en lui passant les paramètres que je veux.
Je ne sais pas si cette technique peut marcher avec les fonctions membres par contre. (Faut que je continue mes tests)
Et d'après ce que j'ai pu lire, std::function et std::bind ne permettent pas de faire ça. :/ (Voilà de quoi je parlais quand je disais "faire mieux que std::function".)
