बूस्ट ट्रांसफर इटरेटर और सी ++ 11 लैम्ब्डा

Question

मैं बूस्ट :: एडेप्टर :: एडाप्टर में सी ++ 0x लैम्ब्डा प्रदान करके परिवर्तित करने की कोशिश कर रहा हूं।

निम्नलिखित कोड संकलित नहीं करता है। मैं बूस्ट 1.48 के साथ जी ++ 4.6.2 का उपयोग कर रहा हूं।

#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; 
} 

मैं यहां क्या गलत कर रहा हूं पर कोई विचार?

Answer 1

खैर lambdas अच्छा नहीं खेलते हैं, क्योंकि वे constructible डिफ़ॉल्ट नहीं कर रहे हैं, जो iterators के लिए आवश्यक है।

#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); 
} 

तो फिर तुम सिर्फ यह कर सकते हैं:

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

यह अच्छी तरह से ज्ञात मुद्दा है। यहाँ देखो

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

जल्दी ही आपको उपयोग decltype बजाय boost::result_of के लिए इस मैक्रो

#define BOOST_RESULT_OF_USE_DECLTYPE 

उपयोग करना चाहिए।

से here

उद्धरण अपने संकलक decltype का समर्थन करता है, तो आप स्वत: परिणाम प्रकार कटौती मैक्रो BOOST_RESULT_OF_USE_DECLTYPE को परिभाषित करने, निम्न उदाहरण में से सक्षम कर सकते हैं।

Answer 3

@ हमेशा के जवाब (#define BOOST_RESULT_OF_USE_DECLTYPE) मेरे लिए काम नहीं किया यहाँ एक आवरण मैं lambdas के लिए इस्तेमाल करते हैं। और @ पॉल का जवाब बहुत लंबा है (और बहुत सामान्य)। एक अधिक विशिष्ट समाधान हो सकता है:

#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; 
} 

(यह 2016 1.58 बूस्ट है और यह अभी भी टूटी हुई है कम से कम कैप्चर बिना लैम्ब्डा boost::transformed की आवश्यकताओं को पूरा करना चाहिए।।)

तो लैम्ब्डा नहीं था 'टी एक पर कब्जा (नहीं अपने मामले) है कोड थोड़ा सरल किया जाएगा या आप इस्तेमाल कर सकते हैं:

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