c++ - Lambda capture causes incompatible operand types error? -

निम्न कोड पर विचार करें:

  मुख्य () {bool t; ... std :: function & lt; bool (bool) & gt; एफ = टी? [] (Bool b) {वापसी b; }: [] (बूल बी) {वापसी! बी; }; // OK std :: function & lt; bool (bool) & gt; एफ = टी? [टी] (बूल बी) {रिटर्न टी == बी; }: [टी] (बूल बी) {रिटर्न टी! = बी; }; // त्रुटि}   
 जब क्लैंग 3.1 के साथ संकलित किया जाता है, तो गैर कैप्चर लैम्ब्डा का काम करता है, जबकि कैप्चर वाला कोई विफल रहता है:  
  main.cpp: 12:36: त्रुटि: असंगत ऑपरेटैंड प्रकार ('और लेफ्टिडा पर मेन.cpp: 12: 38 & gt;' और '& lt; लैबडा at मेन.cpp: 12: 71 & gt;') std :: function & lt; bool (bool) & gt ; F2 = टी? [टी] (बूल बी) {रिटर्न टी == बी; }: [टी] (बूल बी) {रिटर्न टी! = बी; }; // त्रुटि ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~   
 क्यों एक ही चर कैप्चरिंग 2 lambdas असंगत प्रकारों के कारण होता है?   < P> 
 
 लैम्ब्डा का प्रकार "एक अनूठा, गैर-यूनियन वर्ग प्रकार" है जिसे क्लोजर प्रकार कहा जाता है।  
  उदाहरण : यदि आप इसे लिखते हैं: यदि आप इसे लिखते हैं:  <पूर्व>  स्वतः एक = [टी] (बूल बी) {रिटर्न टी == बी;}; ऑटो बी = [टी] (बीूल बी) {रिटर्न टी! = बी;};   
 फिर संकलक इस (अधिक या कम) संकलित करता है:  
  वर्ग unique_lambda_name_1 {bool t; सार्वजनिक: अनूठा_लांबडा_नाव_1 (बूल टी_) टी (_t) {} बूल ऑपरेटर () (बूल बी) कॉन्स्ट {रिटर्न टी == बी; } } पर); वर्ग unique_lambda_name_2 {bool t; सार्वजनिक: अद्वितीय_लांबडा_नाव_2 (बूल टी_) टी (_t) {} बूल ऑपरेटर () (bool b) const {return t! = B; }} बी (टी);   
 ए और बी में अलग-अलग प्रकार हैं और क्या इसका इस्तेमाल नहीं किया जा सकता? ऑपरेटर।  
 हालांकि, 5.1.2 (6) कहते हैं, कि बिना किसी कैप्चर के लैम्ब्डा का बंद प्रकार एक स्पष्ट, सार्वजनिक रूपांतरण ऑपरेटर है, जो लैम्ब्डा को फ़ंक्शन पॉइंटर में बदल देता है - गैर-क्लोजर को सरल कार्यों के रूप में लागू किया जा सकता है एक ही तर्क और वापसी प्रकार के साथ कोई लैम्ब्डा एक ही प्रकार के संकेतक में परिवर्तित हो सकते हैं और इसलिए त्रिगुट? ऑपरेटर उन्हें लागू किया जा सकता है।  
  उदाहरण:  गैर कैप्चर लैम्ब्डा:  
  स्वतः सी = [] (bool b) {return b;};   
 इस तरह कार्यान्वित किया जाता है:  
  वर्ग unique_lambda_name_3 {स्थिर बूल निकाय (bool b) {वापसी b; } सार्वजनिक: बूल ऑपरेटर () (bool b) const {रिटर्न शरीर (बी); } ऑपरेटर गिरावट (& amp; बॉडी) () const {रिटर्न & amp; बॉडी; } } सी;   
 जिसका अर्थ है कि यह पंक्ति:  
  स्वतः x = t? [] (Bool b) {वापसी b;}: [] (bool b) {वापसी! बी;};   
 वास्तव में इसका अर्थ है:  
  // एक अधिक टाइप करने वाला टाइल्डफोल (* pfun_t) (bool) बनाने के लिए एक टाइप किया हुआ; Pfun_t x = t? ((Pfun_t) [] (bool b) {वापसी b;}): (pfun_t) ([] (bool b) {return! B;});