Come accennato nei commenti non si può davvero fare questo come lambda non sono abbastanza potenti.
Quando la sintassi [](auto val){}
è consentita, sarà molto più semplice.
Io uso il seguente per le chiamate di base nel corso tuple .:
template<typename Tuple_t, typename Func_t, std::size_t k_index = 0>
//Only come here if the passed in index is less than sie of tuple
typename std::enable_if<k_index < tuple_size<Tuple_t>::value>::type
call_over_tuple(Tuple_t& irk_tuple, Func_t i_func){
i_func(get<k_index>(irk_tuple));
call_over_tuple<Tuple_t, Func_t, k_index + 1>(irk_tuple, i_func);
}
template<typename Tuple_t, typename Func_t, std::size_t k_index>
typename std::enable_if <k_index>= tuple_size<Tuple_t>::value>::type
call_over_tuple(Tuple_t& irk_tuple, Func_t i_func){
//do nothing
}
ampliare questo a solo args casuali dà.
template<typename Func_t, typename ...Args>
void call_over_vals(Func_t i_func, Args&&... i_args){
auto arg_tuple = make_tuple(forward<Args>(i_args)...);
call_over_tuple<decltype(arg_tuple), Func_t>(arg_tuple, i_func);
}
Per avere sovraccarico di funzioni o modelli è necessario creare una classe chiamante che esegua l'offerta.
template<typename T>
void do_something(const T& irk_val){
cout << irk_val;
}
class caller_class{
public:
template<typename T>
void operator()(const T& i_val){
do_something(i_val);
}
private:
};
void print_integer(int i_val){
cout << i_val;
}
int main(int argv, char** argc){
call_over_vals(caller_class(), 3, ' ' , 2, " asdf ", 4, "\n");
//If you know the argument type just pass it in
call_over_vals(print_integer, 1, 2, 3, 4, 5);
cout << "\n";
call_over_vals([](int y_val){cout << y_val; }, 1, 2, 3, 4, 5);
}
uscita:
3 2 asdf 4
12345
12345
Penso C++ 14 ti permette di fare questo: http://coliru.stacked-crooked.com/a/386d6f281077b336 – chris
Come useresti che? Sembra un po 'come un modello di variabile (che non è consentito a livello di blocco in C++ 1y). Come un lambda polimorfo, vedi la soluzione di chris. In C++ 11, puoi implementarlo come una classe di oggetti con funzioni complete. – dyp
C'è qualche problema con l'invocazione pseudo-ricorsiva di 'foo': l'identificatore potrebbe non apparire nell'inizializzatore per una dichiarazione con' auto'. (Inoltre, non è possibile sovraccaricare lambda, ma suppongo che faccia parte della domanda.) – dyp