non può chiamare generico membro std :: funzione dalla classe modello

Question

Quando si compila il seguente codice:

#include <functional> 

template <typename functionSignature> 
class Class 
{   
    std::function<functionSignature> func; 
public: 
    Class(const std::function<functionSignature>& arg) : func(arg) {} 
    void callFunc() { func(); } 
}; 

void f(const int i) {} 

int main() 
{ 
    Class<void(const int)> a(std::bind(f, 10)); 
    a.callFunc(); 
    return 0; 
} 

Il compilatore VS 2015 genera il seguente messaggio di errore alla sesta riga:

error C2064: term does not evaluate to a function taking 0 arguments. 

Ora, Credo che questo sia dovuto al fatto che il compilatore pensa che lo functionSignature non sia, beh, una firma di funzione; lo stesso errore si verifica quando istanziato e provo a chiamare operator() su un std::function<int> invece di std::function<int()>, per esempio.

Come posso garantire che l'argomento del modello sarà sempre una firma di funzione, in modo che io possa chiamare operator() su std::function?

Answer 1

Il tuo errore è qui:

Class<void(const int)> a(std::bind(f, 10)); 

La funzione Class::callFunc() invoca func() - cioè, senza argomenti. Il risultato di std::bind(f, 10) è anche una funzione che non accetta argomenti, che è coerente con l'argomento del modello per il modello di classe. L'utilizzo di Class<void(const int)> non è coerente con l'utilizzo nel modello di classe e l'inizializzazione.

La soluzione è semplice: modificare la linea errante per

Class<void()> a(std::bind(f, 10)); 

Answer 2

ho il sospetto che si desidera qualcosa di simile:

template <typename F> 
class Class; 

template<typename R, typename... P> 
class Class<R(P...)> { 
public: 
    std::function<R(P...)> func; 
    void callFunc(P... p) { func(p...); } 
}; 

Utilizzando specializzazione parziale in questo modo si può facilmente definire il tipo che si desidera.
A titolo di esempio, è possibile utilizzarlo come:

Class<int(double)> c; 

Naturalmente, ho notato che non avete costruttori per la classe, in modo da invocare func non è una buona idea, ma è abbastanza facile da definire e passare una funzione adeguata come argomento.

Ne consegue un esempio completo e funzionante in cui ho usato il operator() per richiamare la funzione:

#include <functional> 

template <typename F> 
class Class; 

template<typename R, typename... P> 
class Class<R(P...)> { 
public: 
    Class(std::function<R(P...)> f): func{f} { } 
    void operator()(P... p) { func(p...); } 
private: 
    std::function<R(P...)> func; 
}; 

void fn() { } 

int main() { 
    std::function<void()> f = fn; 
    Class<void()> c{f}; 
    c(); 
} 

Answer 3

E 'questo ciò che si sta cercando di fare?

http://ideone.com/fork/IZ0Z1A

Se functionSignature non è una funzione, la funzione std :: si generano errori quando si crea classe, ma si potrebbe aggiungere un costruttore e buttare là un static_assert(std::is_function<functionSignature>::value == true," "); se vuoi immagino.

#include <functional> 
#include <iostream> 

template <typename functionSignature> 
class Class 
{ 
public: 
    std::function<functionSignature> func; 
    void callFunc() { func(); } 
}; 

void f() 
{ 
    std::cout << "hello" << std::endl; 
} 

int main() 
{ 
    Class<decltype(f)> t {f}; 
    t.callFunc(); 

    return 0; 
}