C++ chiamante funzione universale

Question

Vorrei implementare un chiamante funzione che funziona proprio come il costruttore thread. Ad esempio

std::thread second (bar,0); 

inizierà un thread che chiama bar con l'unico argomento 0. Mi piacerebbe fare la stessa cosa, ma non so come.

Ad esempio, dato:

void myFunc(int a){ 
    cout << a << endl; 
} 

Vorrei:

int main() { 
    caller(myFunc,12); 
} 

per chiamare myFunc con il parametro 12.

Answer 1

std::bind renderà un oggetto chiamabile da qualsiasi oggetto chiamabile con un insieme arbitrario di parametri, proprio come fa il costruttore thread. Quindi, solo avvolgere che in una funzione che lo chiama:

template <typename... Args> 
auto caller(Args &&... args) { 
    return std::bind(std::forward<Args>(args)...)(); 
} 

Si noti che il tipo di ritorno auto richiede C++ 14 o successivo. Per C++ 11, è necessario restituire void o specificare il tipo:

auto caller(Args &&... args) 
    -> decltype(std::bind(std::forward<Args>(args)...)()) 

Answer 2

Se tutto quello che vogliamo fare è chiamare una funzione arbitraria con un argomento arbitrario, questo è solo un modello su entrambi i tipi:

template <typename Function, typename Arg> 
void call_with_one(Function&& f, Arg&& arg) { 
    f(std::forward<Arg>(arg)); 
} 

che è possibile espandere per chiamare con qualsiasi numero di argomenti, rendendo variadic :

template <typename Function, typename... Arg> 
void call_with_any(Function f, Arg&&... args) { 
    f(std::forward<Arg>(args)...); 
} 

o realmente f dovrebbe essere un punto di riferimento di inoltro così:

template <typename Function, typename... Arg> 
void call_with_any(Function&& f, Arg&&... args) { 
    std::forward<Function>(f)(std::forward<Arg>(args)...); 
} 

Si noti che questo funzionerà solo con funzioni e oggetti che implementano operator(). Se f è un puntatore a membro, ciò non riuscirà: sarà invece necessario utilizzare std::bind come suggerisce Mike Seymour.