रिकर्सिव लैम्बडास के ओवरहेड

Question

क्या रिकर्सिव लैम्ब्डा फ़ंक्शन नियमित रिकर्सिव फ़ंक्शंस की तुलना में किसी भी ओवरहेड को प्रेरित करते हैं (क्योंकि हमें उन्हें std :: फ़ंक्शन में कैप्चर करना है)?
केवल इस कार्य के बीच क्या अंतर है और एक ही नियमित कार्य का उपयोग कर एक ही है?

int main(int argc, const char *argv[]) 
{ 
    std::function<void (int)> helloworld = [&helloworld](int count) { 
     std::cout << "Hello world" << std::endl; 
     if (count > 1) helloworld(--count); 
    }; 
    helloworld(2); 
    return 0; 
} 

Answer 1

वहाँ भूमि के ऊपर एक std::function के रूप में यह भंडारण के द्वारा lambdas रिकर्सिवली उपयोग कर रहा है, हालांकि वे खुद को मूल रूप से functors हैं। ऐसा लगता है कि gcc अच्छी तरह अनुकूलित करने में सक्षम नहीं है जिसे सीधे comparison में देखा जा सकता है।

लैम्ब्डा के व्यवहार को कार्यान्वित करना, यानी एक मजेदार बनाने वाला, gcc को फिर से अनुकूलित करने में सक्षम बनाता है। एक लैम्ब्डा के अपने विशिष्ट उदाहरण के रूप में

struct HelloWorldFunctor 
{ 
    void operator()(int count) const 
    { 
     std::cout << "Hello world" << std::endl; 
     if (count > 1) 
     { 
     this->operator()(count - 1); 
     } 
    } 
}; 
int main() 
{ 
    HelloWorldFunctor functor; 
    functor(2); 
} 

उदाहरण मैं functor इस second demo में कैसा दिखेगा बनाए हैं उनके लिए लागू किया जा सकता।

यहां तक ​​कि अगर ऐसे ही एक std::rand के रूप में अशुद्ध कार्यों के लिए कॉल का परिचय है, एक पुनरावर्ती लैम्ब्डा के बिना या एक कस्टम functor साथ प्रदर्शन अभी भी बेहतर है। यहां एक third demo है।

निष्कर्ष: std::function के उपयोग के साथ, ओवरहेड है, हालांकि यह उपयोग के मामले के आधार पर नगण्य हो सकता है। चूंकि यह उपयोग कुछ कंपाइलर अनुकूलन को रोकता है, इसलिए इसका व्यापक रूप से उपयोग नहीं किया जाना चाहिए।

Answer 2

सी में lambdas ++ functors के बराबर हैं तो यह ही होगा कि संकलक द्वारा स्वचालित रूप से बनाया कुछ वर्ग के ऑपरेटर() कॉल। जब आप पर्यावरण को कैप्चर करते हैं तो दृश्यों के पीछे क्या हो रहा है यह है कि उन कब्जे वाले चर वर्ग के निर्माता को पास किए जाते हैं और सदस्य चर के रूप में संग्रहीत होते हैं।

तो संक्षेप में, प्रदर्शन अंतर शून्य के बहुत करीब होना चाहिए।

यहाँ वहाँ कुछ और स्पष्टीकरण है: "कर रहे हैं लैम्ब्डा क्लोजर लागू कैसे"

अनुभाग पर जाएं http://www.cprogramming.com/c++11/c++11-lambda-closures.html

संपादित करें:

कुछ अनुसंधान और स्टीफन जवाब और कोड के लिए धन्यवाद करने के बाद, यह पता चला std :: समारोह मुहावरा की वजह से पुनरावर्ती lambdas पर एक ओवरहेड नहीं है। चूंकि लैम्ब्डा को स्वयं को कॉल करने के लिए std :: फ़ंक्शन पर लपेटा जाना है, इसमें वर्चुअल फ़ंक्शन को कॉल करना शामिल है जो एक ओवरहेड जोड़ता है।

विषय इस जवाब की टिप्पणी पर इलाज किया जाता है: https://stackoverflow.com/a/14591727/1112142

Answer 3

तो std::function polymorphically लागू किया गया है। अपने कोड अर्थ मोटे तौर पर के बराबर है:

struct B 
{ 
    virtual void do(int count) = 0; 
}; 

struct D 
{ 
    B* b; 
    virtual void do(int count) 
    { 
     if (count > 1) 
      b->do(count--); 
    } 
}; 

int main() 
{ 
    D d; 
    d.b = &d; 
    d.do(10); 
} 

यह एक तंग पर्याप्त प्रत्यावर्तन ऐसी है कि एक आभासी विधि देखने एक महत्वपूर्ण ओवरहेड है के लिए दुर्लभ है, लेकिन अपने आवेदन क्षेत्र के आधार पर यह निश्चित रूप से संभव है।