Wywołanie funkcji uniwersalnej C++

Question

Chciałbym zaimplementować wywołanie funkcji, które działa tak jak konstruktor thread. Na przykład

std::thread second (bar,0); 

rozpocznie wątku, który wywołuje bar z jednym argumentem 0. Chciałbym zrobić to samo, ale nie wiem jak.

Na przykład, biorąc pod uwagę:

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

Chciałbym:

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

zadzwonić myFunc z parametrem 12.

Answer 1

wykona obiekt wywoływalny z dowolnego obiektu wywoływalnego z dowolnym zbiorem parametrów, tak jak robi to konstruktor thread. Więc po prostu owinąć że w funkcji, która nazywa go:

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

Należy pamiętać, że auto typ zwracany wymaga C++ 14 lub później. W przypadku C++ 11 musisz albo zwrócić void, albo określić typ:

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

Answer 2

Jeśli wszystko, co chcesz zrobić, to zadzwonić do dowolnej funkcji z dowolnego argumentu, że to tylko szablon na obu typach:

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

który można rozszerzyć, aby zadzwonić z dowolną liczbą args przez co o zmiennej liczbie argumentów :

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

Albo naprawdę f powinno być odniesienie spedycja także:

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

Należy zauważyć, że działa to tylko z funkcjami i obiektami implementującymi operator(). Jeśli f jest wskaźnikiem do elementu, to się nie powiedzie - będziesz musiał zamiast tego użyć std::bind jako sugestii Mike Seymour.