boost trasformatore iteratore e C++ 11 lambda

Question

Sto provando ad usare boost :: adapters :: trasformato fornendo un lambda C++ 0x all'adattatore.

Il seguente codice non viene compilato. Sto usando g ++ 4.6.2 con boost 1.48.

#include <iostream> 
#include <vector> 

#include <boost/range/adaptors.hpp> 
#include <boost/range/algorithm.hpp> 

using namespace std; 
namespace br = boost::range; 
namespace badpt = boost::adaptors; 


int main() 
{ 
    vector<int> a = {0,3,1,}; 
    vector<int> b = {100,200,300,400}; 

    auto my_ftor = [&b](int r)->int{return b[r];}; 

    cout<<*br::max_element(a|badpt::transformed(my_ftor))<<endl; 
} 

Qualche idea su cosa sto facendo male qui?

Answer 1

Bene i lambda non suonano bene, poiché non sono costruttibili di default, che è necessario per gli iteratori. Qui è un wrapper che uso per lambda:

#define RETURNS(...) -> decltype(__VA_ARGS__) { return (__VA_ARGS__); } 

template<class Fun> 
struct function_object 
{ 
    boost::optional<Fun> f; 

    function_object() 
    {} 
    function_object(Fun f): f(f) 
    {} 

    function_object(const function_object & rhs) : f(rhs.f) 
    {} 

    // Assignment operator is just a copy construction, which does not provide 
    // the strong exception guarantee. 
    function_object& operator=(const function_object& rhs) 
    { 
     if (this != &rhs) 
     { 
      this->~function_object(); 
      new (this) function_object(rhs); 
     } 
     return *this; 
    } 

    template<class F> 
    struct result 
    {}; 

    template<class F, class T> 
    struct result<F(T)> 
    { 
     typedef decltype(std::declval<Fun>()(std::declval<T>())) type; 
    }; 

    template<class T> 
    auto operator()(T && x) const RETURNS((*f)(std::forward<T>(x))) 

    template<class T> 
    auto operator()(T && x) RETURNS((*f)(std::forward<T>(x))) 
}; 

template<class F> 
function_object<F> make_function_object(F f) 
{ 
    return function_object<F>(f); 
} 

allora si può solo fare questo:

int main() 
{ 
    vector<int> a = {0,3,1,}; 
    vector<int> b = {100,200,300,400}; 

    cout<<*br::max_element(a|badpt::transformed(make_function_object([&b](int r)->int{return b[r];};)))<<endl; 
} 

Answer 2

È un problema ben noto. Guardate qui

http://boost.2283326.n4.nabble.com/range-cannot-use-lambda-predicate-in-adaptor-with-certain-algorithms-td3560157.html

Poco, si consiglia di utilizzare questa macro

#define BOOST_RESULT_OF_USE_DECLTYPE 

per l'uso decltype invece di boost::result_of.

Citazione di here

Se il compilatore supporta decltype, allora è possibile attivare automatico del tipo di risultato netto definendo la macro BOOST_RESULT_OF_USE_DECLTYPE, come nel seguente esempio.

Answer 3

@ risposta di sempre (#define BOOST_RESULT_OF_USE_DECLTYPE) non ha funzionato per me. E la risposta di @ Paul è troppo lunga (e troppo generica). Una soluzione più specifico può essere questo:

#include <iostream> 
#include <vector> 

#include <boost/range/adaptors.hpp> 
#include <boost/range/algorithm.hpp> 

using namespace std; 
namespace br = boost::range; 
namespace badpt = boost::adaptors; 


int main() 
{ 
    vector<int> a = {0,3,1,}; 
    vector<int> b = {100,200,300,400}; 

    struct{ 
    vector<int>* bP;        //pointer, just to imitate lambda syntax... 
    int operator()(int r) const{return (*bP)[r];} //was my_ftor = [&b](int r)->int{return b[r];}; 
    } my_ftor{&b};         //...here 

    cout<<*br::max_element(a|badpt::transformed(my_ftor))<<endl; 
} 

(E 'il 2016, Boost 1.58 e questo è ancora rotto Almeno lambda senza cattura deve soddisfare i requisiti della boost::transformed..)

Se il lambda didn Se hai una cattura (non il tuo caso) il codice sarebbe un po 'più semplice OPPURE potresti usare:

... 
int(*my_ftor)(int) = [](int r)->int{return ...;}; // function pointer default constructible and callable 
cout<<*br::max_element(a|badpt::transformed(my_ftor))<<endl; 
...