रिकर्सिव कॉल (सी ++ 11)

Question

संभव डुप्लिकेट:
Recursive lambda functions in c++0x

मैं एक लैम्ब्डा क्यों फोन नहीं कर सकते हैं रिकर्सिवली अगर मैं के रूप में यह लिखें:

auto a = [&] 
{ 
    static int i = 0; i++; 
    std::cout << i << std::endl; 
    if (i<10) 
    a(); //recursive call 
}; 

यह संकलन त्रुटि देता है (ideone):

prog.cpp:8:18: error: '((const main()::<lambda()>*)this)->main()::<lambda()>::a' cannot be used as a function 

prog.cpp: In function 'int main()': 
prog.cpp:9:9: error: variable 'auto a' with 'auto' type used in its own initializer 

त्रुटि का क्या अर्थ है?

मैं कारण क्यों मैं यह नहीं लिख सकते हैं:

auto i=i+1; //error: unable to deduce 'auto' from '<expression error>' 

हम इस नहीं लिख सकते हैं क्योंकि i के प्रकार यह आरंभीकरण, किस प्रकार करता है, तो निष्कर्ष निकाला नहीं जा सकता है इसका मतलब है से निष्कर्ष निकाला जाना है i स्वयं प्रारंभ में दिखाई देता है (ideone)। लेकिन लैम्ब्डा के मामले में यह कैसे मायने रखता है? यदि मैं गलत नहीं हूं, तो लैम्ब्डा का प्रकार इसके पैरामीटर (रिटर्न) और रिटर्न प्रकार द्वारा निर्धारित होता है; यह शरीर पर निर्भर नहीं करता है अगर यह कुछ भी नहीं लौटाता है (इस मामले में, वापसी प्रकार को void के रूप में घटाया जाता है, चाहे लैम्ब्डा-बॉडी में अन्य बयानों के बावजूद)।

वैसे भी, मैं एक वैकल्पिक हल मिल गया है, और मैं के रूप में के बजाय std::function उपयोग कर सकते हैं:

std::function<void()> a = [&] 
{ 
    static int i = 0; i++; 
    std::cout << i << std::endl; 
    if (i<10) 
     a(); 
}; 

जो जुर्माना संकलन (ideone)। लेकिन मुझे अभी भी यह जानने में दिलचस्पी है कि auto संस्करण संकलित क्यों नहीं करता है।

Answer 1

कारण यह है कि auto चर के लैम्ब्डा-अभिव्यक्ति प्रारंभकर्ताओं के लिए कोई विशेष मामला नहीं है।

ऐसे विशेष मामले त्रुटियों और दुरुपयोगों के लिए प्रवण होंगे। जब आप प्रस्ताव देते हैं कि a() जैसे कुछ काम करना चाहिए तो आपको नियमों को परिभाषित करने की आवश्यकता है। operator() कैसे देखा गया है? a के प्रकार की सटीक स्थिति क्या है? क्या प्रकार पूरा हो जाएगा? (जिसका अर्थ है कि आप पहले से ही लैम्ब्डा की कैप्चर सूची जानते हैं)। एक बार जब आप एक प्रारूप के लिए उचित प्रारूप में तैयार कर लेंगे, तो इस पर बयान देना आसान होगा।

आपके उपयोग के मामले की अनुमति दे अभी तक एक और मामले में जहां आप, क्योंकि a() में a के प्रकार का निर्धारण करने के लिए आप यह सुनिश्चित करें कि प्रारंभकर्ता कुछ भी नहीं के साथ समाप्त होता होना चाहिए कोड में आगे स्कैन करने के लिए की जरूरत का मतलब होगा कि कर सकते थे "unlambda" प्रकार

struct y { void operator()() { } }; 
template<typename T> y operator+(T, y) { return y(); } 
auto x = [] { x(); } + y(); 

इस मामले में, x()y::operator() पर कॉल करेगा, लैम्ब्डा नहीं।

जैसा कि अब है, a को इसके पूरे प्रारंभकर्ता में उल्लिखित करने के लिए मना किया गया है। क्योंकि सी ++ में, auto एक प्रकार नहीं है। यह केवल एक प्रकार निर्दिष्ट एक टू-बी-डिस्प्लेटेड प्रकार के लिए खड़ा है। नतीजतन, एक अभिव्यक्ति में कभी भी ऑटो टाइप नहीं हो सकता है।

Answer 2

मैं इसे देख auto a मामले और std::function<void()> a मामले के बीच महत्वपूर्ण अंतर यह है कि प्रकार std::function<void()> के बारे में/देखभाल क्या असली समारोह के प्रकार यह वास्तव में करने के लिए संदर्भित करता है पता नहीं है। लेखन:

auto a; 

थोड़ा समझ में आता है:

std::function<void()> a; 

बिल्कुल ठीक है, जहां के रूप में है। तो जब आप std::function<void()> का उपयोग करते हैं तो कैप्चर को संश्लेषित करने का समय आता है, जिसे इस प्रकार के बारे में जाना जाना आवश्यक है, जबकि auto के साथ यह अभी तक ज्ञात नहीं है।

Answer 3

एक पुनरावर्ती समारोह f में f द्वारा परिभाषित और वापसी f के प्रकार भी auto के मामले में f से निर्धारित होता है तो यह अनंत प्रत्यावर्तन की ओर जाता है है।

जब auto एक प्रकार प्राप्त करने का प्रयास करता है। decltype (f()) आगे एक अन्य decltype (एफ) 'को कम कर देगा जैसे एफ एफ प्राप्त करने के लिए एफ कुछ भी पुनरावर्ती पर एक कॉल भी रिकर्सिव है। रिकर्सिव फ़ंक्शन पर लागू होने पर वापसी प्रकार निर्धारण पुनरावर्तक हो जाता है। रिकर्सन के रिकर्सिव फ़ंक्शन एंड में रनटाइम पर किया जा सकता है। लेकिन दृढ़ संकल्प स्थिर है केवल