Transfiriendo la firma del método como parámetro de plantilla a una clase

Question

Me gustaría crear una interfaz de plantilla para las clases de manejo de datos en mis proyectos.

puedo escribir algo como esto:

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

Entonces, supongamos, que definir una clase de esta manera:

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

Ahora, vamos a la pregunta, ¿hay algún modo de definir la interfaz de mi plantilla en la forma en que como parámetro recibirá no solo el tipo T, sino la firma completa de la función Process().

me gustaría algo de trabajo de esta manera:

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

¿Es posible? Sé que, por ejemplo, boost :: signal recibe los parámetros de la plantilla de esta manera, pero, si entiendo correctamente, usan mucha magia negra allí.

Answer 1

Sí, puede. Pero en C++ 03, está obligado a copiar/pegar código para cada número de parámetros (lo que no está nada mal, ya que aquí no necesitará sobrecargas para const/non-const, etc. ¡Ya se conoce el constnes!).

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, usted será capaz de escribir

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 */ } 
}; 

lo mucho mejor!