Une "fonction membre" générique enveloppant une ou plusieurs autres fonctions membres ?

Question

J'ai une interface où je doivent transmet des pointeurs de fonctions membres qui sont statiquement castés vers un pointeur de base et stockés dans notre dos en tant que pointeur void et type d'invocation ( mfc tables des messages ).

J'ai créé un wrapper qui gère les exceptions (try/catch très simple pour attraper std::runtime_error) car il est fastidieux et source d'erreurs de le maintenir dans chaque callback de l'utilisateur.

Jusqu'à présent, le wrapper suivant fonctionne assez bien ( L'idée est de saisir le pointeur de la fonction membre directement en tant que paramètre du modèle de valeur - ce qui revient à donner une fonction membre enveloppante pour chacune des fonctions de rappel) :

class MyClass : public CWnd/*example*/{
public:
      template<void (MyClass::*f)(CCmdUI*)>
      void Dispatch(CCmdUI* pCmdUI) {
        try {
          (this->*f)(pCmdUI);
        }
        catch (std::runtime_error& e) {
          //handle error
        }
      }
};

Mais pour éviter d'avoir une surcharge explicite pour chaque type d'appel, serait-il possible de paramétrer la liste des arguments ?

Illustration ( Remarque : cela ne fonctionne pas. ) :

      template<void (MyClass::*f)(Args...)>
      void Dispatch(Args... args) {

Answer 1

Puisque vous utilisez C++17, vous pouvez utiliser auto sur les paramètres du modèle :

template<auto f, typename... Args>
      void Dispatch(Args... args) {
      //...

Et les invoquer normalement en passant un pointeur sur la fonction membre en tant qu'argument #1 du modèle. Exemple en direct .

Si vous devez vérifier si f est un pointeur sur une fonction membre de cette classe, vous pouvez utiliser des static_assert avant d'invoquer (this->*f)(args...) .

Et une petite chose : si vous utilisez la sémantique rvalue, c'est aussi une bonne idée de recevoir Args&& et utiliser std::forward .