Implémentation d'un modèle Functor pouvant stocker les arguments de sa fonction

Question

Je souhaite lier tout type d'événement à des fonctions de tout type pour le système d'interface utilisateur (G) d'un jeu sur lequel je travaille. Je souhaite stocker n'importe quel type de fonctions et ses arguments initiaux dans une classe de modèle Functor, que je peux lier à un index de liaison de signal. Les événements liés à une liaison de signal le déclenchent dès qu'ils apparaissent dans la file d'attente d'événements, ce qui provoque l'appel de tous les Functors liés à cette liaison.

J'ai trouvé que le moyen de stocker les arguments de la fonction était d'utiliser un std::tuple dans le modèle de foncteur, mais j'ai besoin d'aide pour l'initialiser correctement et le déballer correctement lors de l'appel de la fonction.

C'est ce que j'ai jusqu'à présent:

template<typename R, typename... Args> 
class FuncBinding { 
private: 
    std::tuple<Args...> args; 
    R(*fun)(Args...); 

public:    
    FuncBinding(R(*pF)(Args...) , Args... pArgs) 
     :fun(pF), args(std::make_tuple<Args...>(pArgs)) {} 

    R invoke() { 
     return fun(args...); 
    } 

    R callFunc(Args... pArgs) { 
     return fun(pArgs...); 
    } 
}; 

Comment puis-je utiliser le pack de paramètres Args correctement pour ...

• ... créer la classe de modèle std::tuple<Args...> appropiately
• ... initialise le std::tuple<Args...> instance args avec les arguments de foncteur
• ... déballer e tuple lorsque vous appelez la fonction via le pointeur de fonction R(*fun)(Args...)

Answer 1

Un tuple est juste un autre type de classe du point de vue de l'initialisation, de sorte que vous initialisez juste en passant le paquet dans son constructeur:

FuncBinding(R(*pF)(Args...) , Args... pArgs) 
: fun(pF), args(pArgs...) 
{ } 

ou, de manière plus efficace:

args(std::forward<Args>(pArgs)...) 

J'utilise forward au lieu de std::move() au cas où certains Args... sont des types de référence lvalue. Du côté de l'invocation

---

, il y a une fonction 17 C++ appelé std::apply() qui fait ce que vous voulez:

R invoke() { 
    return std::apply(fun, args); 
} 

Il est implémentable en C++ 11. La page cppreference contient une implémentation qui implique std::make_index_sequence, elle-même implémentable dans C++ 11 (et il existe de nombreuses implémentations de ce type sur ce site).