Funzioni di ordine superiore in C++ 11

Question

Sto cercando di scrivere una funzione generica piega utilizzando le nuove funzioni anonime disponibili in C++ 11, qui è quello che ho:

template<typename T> 
T foldl(std::function<T(T,T)> f, T initial, std::vector<T> items) { 
    T accum = initial; 
    for(typename std::vector<T>::iterator it = items.begin(); it != items.end(); ++it) { 
     accum = f(accum, (*it)); 
    } 
    return accum; 
} 

Il seguente tentativo per usarlo:

std::vector<int> arr; 
arr.assign(8, 2); 
foldl([] (int x, int y) -> int { return x * y; }, 1, arr); 

causa un errore:

main.cpp:44:61: error: no matching function for call to 'foldl(main(int, char**)::<lambda(int, int)>, int, std::vector<int>&)' 
main.cpp:44:61: note: candidate is: 
main.cpp:20:3: note: template<class T> T foldl(std::function<T(T, T)>, T, std::vector<T>) 
main.cpp:20:3: note: template argument deduction/substitution failed: 
main.cpp:44:61: note: 'main(int, char**)::<lambda(int, int)>' is not derived from 'std::function<T(T, T)>' 

mi sembra che l'uso di std::function non è il giusto wa y per definire il tipo di f. Come posso correggere questo?

Answer 1

Il tuo codice non è molto generico. Non è necessario richiedere un function, vector o qualcosa del genere. E in generale, in C++, le funzioni andrebbero alla fine della lista degli argomenti (particolarmente importante per lambda, dato che possono essere grandi).

Quindi sarebbe meglio (es: più standard) di scrivere questo come questo:

template<typename Range, typename Accum> 
typename Range::value_type foldl(const Range &items, const typename Range::value_type &initial, Accum f) 
{ 
    typename Range::value_type accum = initial; 
    for(const auto &val : items) { 
     accum = f(accum, val); 
    } 

    return accum; 
} 

o si può solo use std::accumulate che fa la stessa identica cosa.

Answer 2

Non sono sicuro del motivo per cui questo modello non funziona, ma passare a utilizzare un parametro di modello per la funzione anziché std::function<> sembra funzionare in modo straordinario.

template<typename T, typename F> 
T foldl(F f, T initial, std::vector<T> items) { 

Answer 3

Se avete semplicemente convertirlo in un std::function prima, e quindi utilizzare tale, funzionerà:

std::vector<int> arr; 
arr.assign(8, 2); 
std::function<int(int,int)> f = [] (int x, int y) -> int { return x * y; }; 
foldl(f, 1, arr); 

Il problema è che lambda è un tipo diverso rispetto std::function. Ogni lambda è un tipo separato. Sebbene un lambda (e tutti gli altri oggetti funzione) sia convertibile in un std::function con il parametro di tipo appropriato, il compilatore non ha idea di quale argomento modello per T possa renderlo convertibile. (Sappiamo che T = int funzionerebbe, ma non c'è un modo generale per capirlo.) Quindi non può compilarlo.