लम्बदास: C ++ 11 से C ++ 20 तक। भाग 1

शुभ दोपहर, दोस्तों। आज हमने आपके लिए लेख के पहले भाग "लैम्ब्डास: सी ++ 11 से सी ++ 20" का अनुवाद तैयार किया है । इस सामग्री का प्रकाशन पाठ्यक्रम "C ++ डेवलपर" के लॉन्च के साथ मेल खाने के लिए समयबद्ध है, जो कल शुरू होता है।

लैम्ब्डा के भाव C ++ 11 में सबसे शक्तिशाली परिवर्धन में से एक हैं और प्रत्येक नई भाषा मानक के साथ विकसित होते रहते हैं। इस लेख में, हम उनके इतिहास पर जाएँगे और आधुनिक C ++ के इस महत्वपूर्ण भाग के विकास को देखेंगे।



दूसरा भाग यहाँ उपलब्ध है:
लैम्ब्डा: सी ++ 11 से सी ++ 20, भाग 2 तक

प्रविष्टि

एक स्थानीय C ++ उपयोगकर्ता समूह की बैठक में, हमारे पास लैम्ब्डा अभिव्यक्ति के "इतिहास" पर एक लाइव प्रोग्रामिंग सत्र था। बातचीत का नेतृत्व C ++ विशेषज्ञ टॉमाज़ कामीस्की ( थॉमस लिंक्डिन प्रोफ़ाइल देखें ) द्वारा किया गया था। यहाँ घटना है:

लैम्ब्डा: C ++ 11 से C ++ 20 - C ++ उपयोगकर्ता समूह क्राको

मैंने थॉमस से कोड लेने का फैसला किया (उनकी अनुमति से!), इसका वर्णन करें और एक अलग लेख बनाएं।

हम C ++ 03 और कॉम्पैक्ट स्थानीय कार्यात्मक अभिव्यक्तियों की आवश्यकता की खोज करके शुरू करेंगे। फिर हम C ++ 11 और C ++ 14 पर जाते हैं। श्रृंखला के दूसरे भाग में, हम C ++ 17 में परिवर्तन देखेंगे और C ++ 20 में क्या होगा, इस पर भी एक नज़र डालते हैं।

C ++ 03 में लैम्ब्डा

शुरुआत से ही, एसटीएल के std::algorithms , जैसे std::sort , किसी भी ऑब्जेक्ट को ले सकते हैं और इसे कंटेनर तत्वों पर कॉल कर सकते हैं। हालाँकि, C ++ 03 में, यह केवल फ़ंक्शन और फ़ंक्शनलर्स को इंगित करता है।

उदाहरण के लिए:

 #include <iostream> #include <algorithm> #include <vector> struct PrintFunctor { void operator()(int x) const { std::cout << x << std::endl; } }; int main() { std::vector<int> v; v.push_back(1); v.push_back(2); std::for_each(v.begin(), v.end(), PrintFunctor()); } 

रनिंग कोड: @Wandbox

लेकिन समस्या यह थी कि आपको एक अलग फ़ंक्शन या फ़ंक्टर को एक अलग दायरे में लिखना था, और एल्गोरिथ्म कॉल के दायरे में नहीं।

संभावित समाधान के रूप में, आप एक स्थानीय फ़नकार वर्ग लिखने पर विचार कर सकते हैं - चूंकि C ++ हमेशा इस वाक्यविन्यास का समर्थन करता है। लेकिन यह काम नहीं करता ...

इस कोड पर एक नज़र डालें:

 int main() { struct PrintFunctor { void operator()(int x) const { std::cout << x << std::endl; } }; std::vector<int> v; v.push_back(1); v.push_back(2); std::for_each(v.begin(), v.end(), PrintFunctor()); } 

इसे -std=c++98 साथ संकलित करने का प्रयास करें और आपको GCC में निम्नलिखित त्रुटि दिखाई देगी:

 error: template argument for 'template<class _IIter, class _Funct> _Funct std::for_each(_IIter, _IIter, _Funct)' uses local type 'main()::PrintFunctor' 

अनिवार्य रूप से, C ++ 98/03 में, आप स्थानीय प्रकार के टेम्पलेट का उदाहरण नहीं बना सकते हैं।
इन सभी सीमाओं के कारण, समिति ने एक नई सुविधा विकसित करना शुरू किया, जिसे हम "जगह" ... "लंबोदर भाव" कह सकते हैं!

यदि हम N3337 - C ++ 11 के अंतिम संस्करण को देखते हैं, तो हम लैम्ब्डा के लिए एक अलग अनुभाग देखेंगे: [expr.prim.lambda] ।

C ++ 11 से आगे

मुझे लगता है कि भाषा में समझदारी से लंबोदर को जोड़ा गया है। वे नए वाक्यविन्यास का उपयोग करते हैं, लेकिन फिर संकलक इसे एक वास्तविक वर्ग में "विस्तारित" करता है। इस प्रकार, हमारे पास वास्तविक सख्ती से टाइप की गई भाषा के सभी फायदे (और कभी-कभी नुकसान) हैं।

यहाँ एक मूल कोड उदाहरण है जो संबंधित स्थानीय फ़नकार वस्तु को भी दिखाता है:

 #include <iostream> #include <algorithm> #include <vector> int main() { struct { void operator()(int x) const { std::cout << x << '\n'; } } someInstance; std::vector<int> v; v.push_back(1); v.push_back(2); std::for_each(v.begin(), v.end(), someInstance); std::for_each(v.begin(), v.end(), [] (int x) { std::cout << x << '\n'; } ); } 

उदाहरण: @WandBox

आप CppInsights को भी देख सकते हैं, जो दिखाता है कि कंपाइलर कोड को कैसे बढ़ाता है:

इस उदाहरण पर एक नज़र डालें:

CppInsighs: लैम्ब्डा टेस्ट

इस उदाहरण में, संकलक परिवर्तित करता है:

 [] (int x) { std::cout << x << '\n'; } 

इस (सरलीकृत रूप) के समान कुछ में:

 struct { void operator()(int x) const { std::cout << x << '\n'; } } someInstance; 

लंबोदर एक्सप्रेशन सिंटैक्स:

 [] () { ; } ^ ^ ^ | | | | | : mutable, exception, trailing return, ... | | |   |      

शुरू करने से पहले कुछ परिभाषाएँ:

[Expr.prim.lambda # 2] से :

एक लंबोदर अभिव्यक्ति का मूल्यांकन करने से एक अस्थायी गतिरोध उत्पन्न होता है। इस अस्थायी वस्तु को क्लोजर ऑब्जेक्ट कहा जाता है।

और [expr.prim.lambda # 3] से :

लैम्ब्डा अभिव्यक्ति का प्रकार (जो एक क्लोजर ऑब्जेक्ट का प्रकार भी है) क्लास का एक अनूठा नाम रहित गैर-यूनियन प्रकार है जिसे क्लोजर प्रकार कहा जाता है।

लंबोदर भाव के कुछ उदाहरण:

उदाहरण के लिए:

 [](float f, int a) { return a*f; } [](MyClass t) -> int { auto a = t.compute(); return a; } [](int a, int b) { return a < b; } 

लंबोदर प्रकार

चूंकि कंपाइलर प्रत्येक लैम्ब्डा के लिए एक अद्वितीय नाम उत्पन्न करता है, इसलिए इसे पहले से जानना संभव नहीं है।

 auto myLambda = [](int a) -> double { return 2.0 * a; } 

इसके अलावा [expr.prim.lambda] :
लैम्ब्डा एक्सप्रेशन से जुड़े क्लोजर टाइप में एक रिमोट ([dcl.fct.def.delete]) डिफॉल्ट कंस्ट्रक्टर और एक रिमोट असाइनमेंट ऑपरेटर होता है।

इसलिए, आप नहीं लिख सकते हैं:

 auto foo = [&x, &y]() { ++x; ++y; }; decltype(foo) fooCopy; 

इसके परिणामस्वरूप GCC में निम्नलिखित त्रुटि होगी:

 error: use of deleted function 'main()::<lambda()>::<lambda>()' decltype(foo) fooCopy; ^~~~~~~ note: a lambda closure type has a deleted default constructor 

कॉल ऑपरेटर

कोड जिसे आपने लैम्ब्डा बॉडी में रखा है, उसे ऑपरेटर () में इसी क्लोजर प्रकार के कोड में अनुवाद किया गया है।

डिफ़ॉल्ट रूप से, यह एक अंतर्निहित स्थिर विधि है। आप मापदंडों को घोषित करने के बाद परिवर्तनशील निर्दिष्ट करके इसे बदल सकते हैं:

 auto myLambda = [](int a) mutable { std::cout << a; } 

हालांकि निरंतर विधि एक खाली कैप्चर सूची के बिना एक लंबोदर के लिए "समस्या" नहीं है ... यह तब मायने रखता है जब आप कुछ पर कब्जा करना चाहते हैं।

कब्जा

[] न केवल एक लैम्ब्डा का परिचय देता है, बल्कि इसमें कैद किए गए चरों की सूची भी होती है। इसे कैप्चर सूची कहा जाता है।

किसी वैरिएबल को कैप्चर करके, आप क्लोजर प्रकार में इस वैरिएबल की कॉपी मेंबर बनाते हैं। फिर लैम्ब्डा बॉडी के अंदर आप इसे एक्सेस कर सकते हैं।

मूल वाक्यविन्यास है:

• [और] - संदर्भ द्वारा कब्जा, स्वचालित भंडारण में सभी चर दायरे में घोषित किए जाते हैं
• [=] - मान द्वारा कैप्चर करना, मान कॉपी किया गया है
• [x, & y] - स्पष्ट रूप से x को मान से, और y को संदर्भ द्वारा कैप्चर करता है

उदाहरण के लिए:

 int x = 1, y = 1; { std::cout << x << " " << y << std::endl; auto foo = [&x, &y]() { ++x; ++y; }; foo(); std::cout << x << " " << y << std::endl; } 

आप यहां पूरे उदाहरण के साथ खेल सकते हैं: @Wandbox

यद्यपि यह निर्दिष्ट करना [=] या [&] सुविधाजनक हो सकता है - चूंकि यह स्वचालित रूप से भंडारण में सभी चर को कैप्चर करता है, इसलिए चर स्पष्ट रूप से कैप्चर करना अधिक स्पष्ट है। इस प्रकार, संकलक आपको अवांछित प्रभावों के बारे में चेतावनी दे सकता है (उदाहरण के लिए, वैश्विक और स्थिर चर पर नोट्स)

आप स्कॉट मेयर्स द्वारा प्रभावी मॉडर्न C ++ के पैरा 31 में और अधिक पढ़ सकते हैं: "डिफ़ॉल्ट कैप्चर मोड से बचें।"

और एक महत्वपूर्ण उद्धरण:

C ++ क्लोजर कैप्चर किए गए लिंक के जीवनकाल को नहीं बढ़ाता है।

परिवर्तनशील

डिफ़ॉल्ट रूप से, क्लोजर प्रकार ऑपरेटर () स्थिर है, और आप लंबोदर अभिव्यक्ति के शरीर के अंदर कैप्चर किए गए चर को संशोधित नहीं कर सकते।
यदि आप इस व्यवहार को बदलना चाहते हैं, तो आपको पैरामीटर सूची के बाद परिवर्तनशील कीवर्ड जोड़ना होगा:

 int x = 1, y = 1; std::cout << x << " " << y << std::endl; auto foo = [x, y]() mutable { ++x; ++y; }; foo(); std::cout << x << " " << y << std::endl; 

उपरोक्त उदाहरण में, हम x और y के मूल्यों को बदल सकते हैं ... लेकिन ये केवल संलग्न दायरे से x और y की प्रतियां हैं।

वैश्विक चर कैप्चर

यदि आपके पास एक वैश्विक मूल्य है और फिर आप एक लैम्ब्डा में [=] का उपयोग करते हैं, तो आप सोच सकते हैं कि वैश्विक मूल्य भी मूल्य द्वारा कब्जा कर लिया गया है ... लेकिन ऐसा नहीं है।

 int global = 10; int main() { std::cout << global << std::endl; auto foo = [=] () mutable { ++global; }; foo(); std::cout << global << std::endl; [] { ++global; } (); std::cout << global << std::endl; [global] { ++global; } (); } 

आप यहां कोड के साथ खेल सकते हैं: @Wandbox

स्वचालित संग्रहण में केवल चर ही कैप्चर किए जाते हैं। जीसीसी निम्नलिखित चेतावनी भी जारी कर सकता है:

 warning: capture of variable 'global' with non-automatic storage duration 

यह चेतावनी केवल तभी दिखाई देगी जब आप स्पष्ट रूप से वैश्विक चर को कैप्चर करेंगे, इसलिए यदि आप [=] उपयोग करते हैं, तो संकलक आपकी मदद नहीं करेगा।
क्लैंग संकलक अधिक उपयोगी है क्योंकि यह एक त्रुटि उत्पन्न करता है:

 error: 'global' cannot be captured because it does not have automatic storage duration 

@Wandbox देखें

स्थैतिक चर को पकड़ना

स्थिर चर को पकड़ना वैश्विक कब्जा करने के समान है:

 #include <iostream> void bar() { static int static_int = 10; std::cout << static_int << std::endl; auto foo = [=] () mutable { ++static_int; }; foo(); std::cout << static_int << std::endl; [] { ++static_int; } (); std::cout << static_int << std::endl; [static_int] { ++static_int; } (); } int main() { bar(); } 

आप यहां कोड के साथ खेल सकते हैं: @Wandbox

निष्कर्ष:

 10 11 12 

और फिर, एक चेतावनी केवल तभी दिखाई देगी जब आप स्पष्ट रूप से एक स्थिर चर पर कब्जा कर लेंगे, इसलिए यदि आप [=] उपयोग करते हैं, तो संकलक आपकी मदद नहीं करेगा।

कक्षा सदस्य कब्जा

क्या आप जानते हैं कि निम्नलिखित कोड को निष्पादित करने के बाद क्या होता है:

 #include <iostream> #include <functional> struct Baz { std::function<void()> foo() { return [=] { std::cout << s << std::endl; }; } std::string s; }; int main() { auto f1 = Baz{"ala"}.foo(); auto f2 = Baz{"ula"}.foo(); f1(); f2(); } 

कोड एक बाज ऑब्जेक्ट घोषित करता है और फिर foo() कहता है। ध्यान दें कि foo() एक लैम्ब्डा ( std::function में संग्रहीत std::function ) देता है जो वर्ग के एक सदस्य को पकड़ता है।

चूंकि हम अस्थायी वस्तुओं का उपयोग करते हैं, इसलिए हम यह सुनिश्चित नहीं कर सकते कि f1 और f2 कहे जाने पर क्या होगा। यह एक झूलने वाली लिंक समस्या है जो अपरिभाषित व्यवहार का कारण बनती है।

इसी तरह:

 struct Bar { std::string const& foo() const { return s; }; std::string s; }; auto&& f1 = Bar{"ala"}.foo(); //   

@Wandbox कोड के साथ खेलते हैं

फिर, यदि आप स्पष्ट रूप से कैप्चर निर्दिष्ट करते हैं ([s]):

 std::function<void()> foo() { return [s] { std::cout << s << std::endl; }; } 

संकलक आपकी त्रुटि को रोक देगा:

 In member function 'std::function<void()> Baz::foo()': error: capture of non-variable 'Baz::s' error: 'this' was not captured for this lambda function ... 

एक उदाहरण देखें: @Wandbox

मूव-सक्षम-केवल ऑब्जेक्ट

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

 std::unique_ptr<int> p(new int[10]); auto foo = [p] () {}; //  .... 

लगातार बचत

यदि आप एक निरंतर चर पर कब्जा करते हैं, तो कब्ज संरक्षित है:

 int const x = 10; auto foo = [x] () mutable { std::cout << std::is_const<decltype(x)>::value << std::endl; x = 11; }; foo(); 

कोड देखें: @Wandbox

वापसी प्रकार

C ++ 11 में, आप रिटर्न लैम्बडा टाइप को trailing छोड़ सकते हैं, और फिर कंपाइलर इसे आपके लिए आउटपुट करेगा।

प्रारंभ में, रिटर्न वैल्यू टाइप का आउटपुट एक रिटर्न स्टेटमेंट वाले लैम्ब्डा तक सीमित था, लेकिन यह प्रतिबंध जल्दी हटा दिया गया था, क्योंकि अधिक सुविधाजनक संस्करण के कार्यान्वयन में कोई समस्या नहीं थी।

सी ++ मानक कोर भाषा दोष रिपोर्ट और स्वीकृत मुद्दे देखें (सही लिंक खोजने के लिए थॉमस का धन्यवाद!)

इस प्रकार, C ++ 11 से शुरू होकर, कंपाइलर रिटर्न मान के प्रकार का अनुमान लगा सकता है यदि सभी रिटर्न स्टेटमेंट को एक ही प्रकार में बदला जा सकता है।

यदि सभी रिटर्न स्टेटमेंट अभिव्यक्ति को लौटाते हैं और रूपांतरण लैवल्यू-टू-रिवल्यू (7.1 [conv.lval]), एरे-टू-पॉइंटर (7.2 [conv.array]) और फंक्शन-टू-पॉइंटर (7.3 / वाक्य) के बाद रिटर्न टाइप करते हैं। func]) जेनेरिक प्रकार के समान है;

 auto baz = [] () { int x = 10; if ( x < 20) return x * 1.1; else return x * 2.1; }; 

आप यहां कोड के साथ खेल सकते हैं: @Wandbox

ऊपर लंबोदर में दो return , लेकिन वे सभी double इशारा करते हैं, इसलिए कंपाइलर टाइप कर सकते हैं।

IIFE - तुरंत लागू समारोह अभिव्यक्ति

हमारे उदाहरणों में, मैंने एक लैम्ब्डा को परिभाषित किया और फिर इसे क्लोजर ऑब्जेक्ट का उपयोग करके बुलाया ... लेकिन इसे तुरंत भी कहा जा सकता है:

 int x = 1, y = 1; [&]() { ++x; ++y; }(); // <-- call () std::cout << x << " " << y << std::endl; 

ऐसी अभिव्यक्ति निरंतर वस्तुओं के जटिल प्रारंभिककरण में उपयोगी हो सकती है।

 const auto val = []() { /*   ... */ }(); 

मैंने इसके बारे में कॉम्प्लेक्स इनिशियलाइज़ेशन पोस्ट के लिए IIFE में अधिक लिखा।

एक फ़ंक्शन पॉइंटर में कनवर्ट करें

कैप्चर के बिना लैम्बडा एक्सप्रेशन के लिए क्लोजर टाइप में एक ओपन नॉन-वर्चुअल इंपैक्ट फंक्शन है, जो किसी पॉइंटर को एक फंक्शन में कन्वर्ट करने के लिए होता है, जिसमें एक ही पैरामीटर होता है और क्लोजर टाइप के फंक्शन को कॉल करने के ऑपरेटर के रूप में रिटर्न टाइप होता है। इस रूपांतरण फ़ंक्शन द्वारा लौटाए गए मान को फ़ंक्शन का पता होना चाहिए, जिसे जब कॉल किया जाता है, तो एक क्लोजर प्रकार के समान फ़ंक्शन के ऑपरेटर को कॉल करने के समान प्रभाव पड़ता है।

दूसरे शब्दों में, आप लंबर को बिना कैप्चर के फ़ंक्शन पॉइंटर में बदल सकते हैं।

उदाहरण के लिए:

 #include <iostream> void callWith10(void(* bar)(int)) { bar(10); } int main() { struct { using f_ptr = void(*)(int); void operator()(int s) const { return call(s); } operator f_ptr() const { return &call; } private: static void call(int s) { std::cout << s << std::endl; }; } baz; callWith10(baz); callWith10([](int x) { std::cout << x << std::endl; }); } 

आप यहां कोड के साथ खेल सकते हैं: @Wandbox

C ++ 14 में सुधार

N4140 मानक और लैम्ब्डा: [expr.prim.lambda] ।

C ++ 14 ने लैम्ब्डा अभिव्यक्ति में दो महत्वपूर्ण सुधार जोड़े:

• शुरुआती के साथ कब्जा
• आम लंबोदर

ये सुविधाएँ C ++ 11 में दिखाई देने वाली कई समस्याओं को हल करती हैं।

वापसी प्रकार

कार्यों के लिए स्वत: आउटपुट नियमों का पालन करने के लिए लैम्ब्डा अभिव्यक्ति के रिटर्न मूल्य प्रकार के आउटपुट को अपडेट किया गया है।

[expr.prim.lambda # 4]

लैम्ब्डा का वापसी प्रकार ऑटो है, जिसे पीछे आने वाले विवरणों द्वारा प्रतिस्थापित किया जाता है, यदि रिटर्न डीटेल्स में प्रदान किया जाता है और / या अनुमान लगाया जाता है, जैसा कि [dcl.spec.auto] में वर्णित है।

शुरुआती के साथ कब्जा

संक्षेप में, हम क्लोजर प्रकार का एक नया सदस्य चर बना सकते हैं और फिर इसका उपयोग लंबोदर अभिव्यक्ति के अंदर कर सकते हैं।

उदाहरण के लिए:

 int main() { int x = 10; int y = 11; auto foo = [z = x+y]() { std::cout << z << '\n'; }; foo(); } 

यह कई समस्याओं को हल कर सकता है, उदाहरण के लिए, उन प्रकारों के साथ जो केवल चलने के लिए उपलब्ध हैं।

विस्थापन

अब हम ऑब्जेक्ट को क्लोजर प्रकार के सदस्य में ले जा सकते हैं:

 #include <memory> int main() { std::unique_ptr<int> p(new int[10]); auto foo = [x=10] () mutable { ++x; }; auto bar = [ptr=std::move(p)] {}; auto baz = [p=std::move(p)] {}; } 

अनुकूलन

एक अन्य विचार यह है कि इसे संभावित अनुकूलन तकनीक के रूप में उपयोग किया जाए। हर बार जब हम लंबोदर कहते हैं तो कुछ मूल्य की गणना करने के बजाय, हम इसे एक बार इनिशियलाइज़र में गणना कर सकते हैं:

 #include <iostream> #include <algorithm> #include <vector> #include <memory> #include <iostream> #include <string> int main() { using namespace std::string_literals; std::vector<std::string> vs; std::find_if(vs.begin(), vs.end(), [](std::string const& s) { return s == "foo"s + "bar"s; }); std::find_if(vs.begin(), vs.end(), [p="foo"s + "bar"s](std::string const& s) { return s == p; }); } 

एक सदस्य चर पर कब्जा

एक शुरुआती चर का उपयोग किसी सदस्य चर को पकड़ने के लिए भी किया जा सकता है। तब हम सदस्य चर की एक प्रति प्राप्त कर सकते हैं और लिंक के झूलने की चिंता नहीं कर सकते।

उदाहरण के लिए:

 struct Baz { auto foo() { return [s=s] { std::cout << s << std::endl; }; } std::string s; }; int main() { auto f1 = Baz{"ala"}.foo(); auto f2 = Baz{"ula"}.foo(); f1(); f2(); } 

आप यहां कोड के साथ खेल सकते हैं: @Wandbox


foo() हम एक सदस्य चर को बंद प्रकार से कॉपी करके कैप्चर करते हैं। इसके अलावा, हम ऑटो का उपयोग पूरी विधि (पूर्व में, C ++ 11 में हम std::function उपयोग कर सकते हैं) के उत्पादन के लिए करते हैं।

सामान्य लंबोदर भाव

एक और महत्वपूर्ण सुधार सामान्यीकृत लैम्ब्डा है।
C ++ 14 से शुरू करके आप लिख सकते हैं:

 auto foo = [](auto x) { std::cout << x << '\n'; }; foo(10); foo(10.1234); foo("hello world"); 

यह टाइप क्लोजर के कॉल स्टेटमेंट में टेम्प्लेट डिक्लेरेशन का उपयोग करने के बराबर है:

 struct { template<typename T> void operator()(T x) const { std::cout << x << '\n'; } } someInstance; 

इस तरह का एक सामान्य लैंबडा बहुत उपयोगी हो सकता है जब एक प्रकार का अनुमान लगाना मुश्किल हो।

उदाहरण के लिए:

 std::map<std::string, int> numbers { { "one", 1 }, {"two", 2 }, { "three", 3 } }; //      pair<const string, int>! std::for_each(std::begin(numbers), std::end(numbers), [](const std::pair<std::string, int>& entry) { std::cout << entry.first << " = " << entry.second << '\n'; } ); 

क्या मैं यहाँ गलत हूँ? क्या प्रविष्टि में सही प्रकार है?
।
।
।
शायद नहीं, क्योंकि std :: map std::pair<const Key, T> का मान प्रकार है। तो मेरा कोड लाइनों की अतिरिक्त प्रतियां बना देगा ...
यह auto साथ तय किया जा सकता है:

 std::for_each(std::begin(numbers), std::end(numbers), [](auto& entry) { std::cout << entry.first << " = " << entry.second << '\n'; } ); 

आप यहां कोड के साथ खेल सकते हैं: @Wandbox

निष्कर्ष

क्या कहानी है!

इस लेख में, हमने C ++ 03 और C ++ 11 में लैम्बडा एक्सप्रेशन के पहले दिनों से शुरुआत की और C ++ 14 में एक बेहतर संस्करण पर चले गए।

आपने देखा कि लैम्बडा कैसे बनाया जाता है, इस अभिव्यक्ति की मूल संरचना क्या है, कैप्चर सूची क्या है, और बहुत कुछ।

लेख के अगले भाग में, हम C ++ 17 पर आगे बढ़ेंगे और C ++ 20 की भविष्य की विशेषताओं को जानेंगे।

दूसरा भाग यहाँ उपलब्ध है:

लैम्ब्डा: सी ++ 11 से सी ++ 20, भाग 2 तक


संदर्भ

C ++ 11 - [expr.prim.lambda]
C ++ 14 - [expr.prim.lambda]
C ++ में लैंबडा एक्सप्रेशंस | Microsoft डॉक्स
सी ++ लैम्ब्डा - स्टिकी बिट्स - डेमेजिफ़ाइंग द्वारा संचालित - फ़ेहास द्वारा संचालित; स्टिकी बिट्स - फेबेश द्वारा संचालित


हम आपकी टिप्पणियों की प्रतीक्षा कर रहे हैं और "C ++ डेवलपर" पाठ्यक्रम में रुचि रखने वाले सभी को आमंत्रित करते हैं।