Transférer la signature de la méthode en tant que paramètre de modèle dans une classe

Question

Je voudrais créer une interface de modèle pour les classes de gestion de données dans mes projets.

Je peux écrire quelque chose comme ceci:

template <class T> 
class DataHandler 
{ 
    public: 
     void Process(const& T) = 0; 
}; 

Ensuite, supposons, je définir une classe de cette façon:

class MyClass: public DataHandler<int> 
{ 
    void Process(const int&) { /* Bla-bla */ } 
} 

Maintenant, venez la question, puis-je définir en quelque sorte mon interface de modèle dans la façon dont, en tant que paramètre, il recevra non seulement T, mais la signature entière de la fonction Process().

Je voudrais quelque chose travailler de cette façon:

class MyClass: public DataHandler<void (int&)> 
{ 
    void Process(const int&) { /* Bla-bla */ } 
} 

Est-il possible? Je sais que, par exemple, boost :: signal reçoit les paramètres du template de cette façon, mais si je comprends bien, ils utilisent beaucoup de magie noire là-bas.

Answer 1

Oui, vous pouvez. Mais en C++ 03, vous êtes obligé de copier/coller du code pour chaque nombre de paramètres (pas trop mal, car ici vous n'aurez pas besoin de surcharges pour const/non-const etc. Le constnes est déjà connu!).

template<typename FnType> 
struct parm; 

template<typename R, typename P1> 
struct parm<R(P1)> { 
    typedef R ret_type; 
    typedef P1 parm1_type; 
}; 

template <class T> 
class DataHandler 
{ 
    typedef typename parm<T>::ret_type ret_type; 
    typedef typename parm<T>::parm1_type parm1_type; 

    public: 
     virtual ret_type Process(parm1_type t) = 0; 
}; 

class MyClass: public DataHandler<void (const int&)> 
{ 
    void Process(const int&) { /* Bla-bla */ } 
}; 

---

En C++ 0x, vous serez en mesure d'écrire

template <class T> 
class DataHandler; 

template<typename R, typename ... P> 
class DataHandler<R(P...)> 
{ 
    public: 
     virtual R Process(P... t) = 0; 
}; 

class MyClass: public DataHandler<void (const int&)> 
{ 
    void Process(const int&) { /* Bla-bla */ } 
}; 

Combien plus agréable!