🏵️ 🗃️ ⚙️ लम्बदास: C ++ 11 से C ++ 20 तक। भाग २ 🚼 🌦️ 🔈

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

श्रृंखला के पहले भाग में, हमने C ++ 03, C ++ 11 और C ++ 14 के संदर्भ में लंबोदा को देखा। इस लेख में, मैंने इस शक्तिशाली सी ++ सुविधा, मूल उपयोग, वाक्यविन्यास और भाषा मानकों में से प्रत्येक में सुधार के पीछे की प्रेरणाओं का वर्णन किया। मैंने कुछ सीमावर्ती मामलों का भी उल्लेख किया है।
अब यह C ++ 17 पर जाने और भविष्य पर एक नज़र रखने का समय है (बहुत करीब!): C ++ 20।

प्रविष्टि

एक त्वरित अनुस्मारक: इस श्रृंखला के लिए विचार क्राको में हमारे हालिया सी ++ उपयोगकर्ता समूह की बैठकों में से एक के बाद आया।

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

मैंने थॉमस से कोड लेने का फैसला किया (उनकी अनुमति से!) और इसके आधार पर लेख लिखा। श्रृंखला के पहले भाग में मैंने लैम्बडा के भावों के बारे में बात की:

मूल वाक्य रचना
लंबोदर प्रकार
कॉल ऑपरेटर
चर (उत्परिवर्तनीय, वैश्विक, स्थिर चर, वर्ग के सदस्य और यह सूचक, गति-सक्षम-केवल ऑब्जेक्ट, संचय करने वाले कांस्टेबल) कैप्चर करना:
- वापसी प्रकार
- IIFE - तुरंत लागू समारोह अभिव्यक्ति
- फ़ंक्शन पॉइंटर में रूपांतरण
- वापसी प्रकार
- IIFE - तुरंत लागू अभिव्यक्तियाँ
- एक फ़ंक्शन पॉइंटर में कनवर्ट करें
C ++ 14 में सुधार
- वापसी प्रकार आउटपुट
- इनिशलाइज़र के साथ कैप्चर करें
- एक सदस्य चर पर कब्जा
- सामान्य लंबोदर भाव

उपरोक्त सूची लंबोदर अभिव्यक्ति के इतिहास का केवल एक हिस्सा है!

अब देखते हैं कि C ++ 17 में क्या बदलाव आया है और C ++ 20 में हमें क्या मिलता है!

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

मानक (प्रकाशन से पहले मसौदा) लंबोदर पर N659 अनुभाग: [expr.prim.lambda] । C ++ 17 ने लैम्ब्डा अभिव्यक्ति में दो महत्वपूर्ण सुधार लाए:

constexpr लंबोदर
इस पर कब्जा *

इन नवाचारों का हमारे लिए क्या मतलब है? चलिए इसका पता लगाते हैं।

कॉन्स्टैक्स लैम्ब्डा एक्सप्रेशन

C ++ 17 के साथ शुरू, मानक स्पष्ट रूप से परिभाषित operator() एक लैम्ब्डा प्रकार के लिए constexpr रूप में, यदि संभव हो तो:

Expr.prim.lambda से # 4 :
फ़ंक्शन कॉल ऑपरेटर एक कॉन्स्ट्रेक्स फ़ंक्शन होता है यदि संबंधित लैम्ब्डा अभिव्यक्ति की स्थिति पैरामीटर की घोषणा कॉन्स्टैक्स के बाद होती है, या यह कॉन्स्ट्रेक्स फ़ंक्शन की आवश्यकताओं को पूरा करती है।

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

 constexpr auto Square = [] (int n) { return n*n; }; // implicitly constexpr static_assert(Square(2) == 4);

याद रखें कि C ++ 17 में constexpr फ़ंक्शन को इन नियमों का पालन करना चाहिए:

यह आभासी नहीं होना चाहिए;
- इसका वापसी प्रकार एक शाब्दिक प्रकार होना चाहिए;
- इसके प्रत्येक प्रकार के मापदंडों का शाब्दिक प्रकार होना चाहिए;
- इसका शरीर = हटाना, = डिफ़ॉल्ट या एक यौगिक विवरण होना चाहिए जिसमें शामिल नहीं है
  - asm परिभाषाएँ
  - गोटो एक्सप्रेशन,
  - लेबल,
  - ब्लॉक या प्रयास करें
  - एक गैर-शाब्दिक चर की परिभाषा, एक स्थिर चर, या एक स्ट्रीमिंग मेमोरी चर जिसके लिए आरंभीकरण नहीं किया जाता है।

अधिक व्यावहारिक उदाहरण के बारे में क्या?

 template<typename Range, typename Func, typename T> constexpr T SimpleAccumulate(const Range& range, Func func, T init) { for (auto &&elem: range) { init += func(elem); } return init; } int main() { constexpr std::array arr{ 1, 2, 3 }; static_assert(SimpleAccumulate(arr, [](int i) { return i * i; }, 0) == 14); }

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

कोड constexpr lambda का उपयोग करता है, और फिर इसे सरल SimpleAccumulate एल्गोरिथ्म में पास किया जाता है। एल्गोरिथ्म कई C ++ 17 तत्वों का उपयोग करता है: std::array , std::begin constexpr और std::end (एक सीमा के साथ लूप में प्रयुक्त) के लिए constexpr भी अब constexpr , इसलिए इसका अर्थ है कि सभी कोड निष्पादित किए जा सकते हैं संकलन के समय।

बेशक, यह सब नहीं है।

आप चर पर कब्जा कर सकते हैं (बशर्ते कि वे constexpr भी हों):

 constexpr int add(int const& t, int const& u) { return t + u; } int main() { constexpr int x = 0; constexpr auto lam = [x](int n) { return add(x, n); }; static_assert(lam(10) == 10); }

लेकिन एक दिलचस्प मामला है जब आप कैप्चर किए गए चर को आगे नहीं बढ़ाते हैं, उदाहरण के लिए:

 constexpr int x = 0; constexpr auto lam = [x](int n) { return n + x };

इस मामले में, क्लैंग में हमें निम्नलिखित चेतावनी मिल सकती है:

warning: lambda capture 'x' is not required to be captured for this use

यह संभवतः इस तथ्य के कारण है कि प्रत्येक उपयोग के साथ एक्स को जगह में बदला जा सकता है (जब तक कि आप इसे आगे स्थानांतरित नहीं करते हैं या इस नाम का पता नहीं लेते हैं)।

लेकिन कृपया मुझे बताएं कि क्या आप इस व्यवहार के लिए आधिकारिक नियम जानते हैं। मैंने केवल ( cppreference से ) पाया (लेकिन मैं इसे ड्राफ्ट में नहीं पा सकता ...)

(अनुवादक का ध्यान दें: जैसा कि हमारे पाठक लिखते हैं, मेरा मतलब है कि हर जगह पर 'x' के मूल्य को प्रतिस्थापित करना जहां इसका उपयोग किया जाता है। इसे बदलना निश्चित रूप से असंभव है।)

एक लैम्ब्डा एक्सप्रेशन किसी वेरिएबल के वैल्यू को बिना कैप्चर किए पढ़ सकता है
* एक निरंतर non-volatile पूर्णांक या प्रगणित प्रकार है और इसे constexpr या के साथ आरंभीकृत किया गया है
* constexpr और कोई constexpr सदस्य नहीं है।

भविष्य के लिए तैयार रहें:

C ++ 20 में, हमारे पास मानक मानक एल्गोरिदम होंगे और, संभवतः, यहां तक कि कुछ कंटेनर भी, इसलिए इस संदर्भ में constexpr लैम्ब्डा बहुत उपयोगी होगा। आपका कोड रन-टाइम संस्करण के साथ-साथ constexpr वर्जन (संकलन-समय संस्करण) के लिए समान दिखेगा!

संक्षेप में:

constexpr lambda आपको बॉयलरप्लेट प्रोग्रामिंग के अनुरूप होने की अनुमति देता है और संभवत: इसका कोड छोटा होता है।

अब C ++ 17 में उपलब्ध दूसरी महत्वपूर्ण विशेषता पर चलते हैं:

* इस पर कब्जा
इस पर कब्जा *

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

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

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

इनिशियलाइज़र के साथ कैप्चर का उपयोग करके वांछित सदस्य चर को कैप्चर करना आपको अस्थायी मानों के साथ संभावित त्रुटियों से बचाता है, लेकिन जब हम एक विधि को कॉल करना चाहते हैं तो हम ऐसा नहीं कर सकते हैं:

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

 struct Baz { auto foo() { return [this] { print(); }; } void print() const { std::cout << s << '\n'; } std::string s; };

C ++ 14 में, कोड सुरक्षित बनाने का एकमात्र तरीका this कि इसे एक इनिशलाइज़र के साथ कैप्चर किया जाए:

 auto foo() { return [self=*this] { self.print(); }; }   C ++ 17    : auto foo() { return [*this] { print(); }; }

एक और बात:

ध्यान दें कि यदि आप एक सदस्य समारोह में [=] लिखते हैं, तो this निहित है! इससे भविष्य में त्रुटियां हो सकती हैं ... और यह C ++ 20 में अप्रचलित हो जाएगा।

तो हम अगले भाग पर आते हैं: भविष्य।

सी ++ 20 के साथ भविष्य

C ++ 20 में, हमें निम्नलिखित कार्य मिलते हैं:

अनुमति दें [=, this] एक लैम्ब्डा कैप्चर के रूप में - P0409R2 और इस के निहित कैप्चर को [=] - P0806 के माध्यम से रद्द करें
लैंबडा इनिट में पैकेज का विस्तार lambda init-capture: ... args = std::move (args)] () {} - L08080
स्थिर, thread_local और संरचित बाइंडिंग के लिए लैम्ब्डा कैप्चर - P1091
लैम्ब्डा पैटर्न (अवधारणाओं के साथ भी) - P0428R2
सरलीकृत लंबोदर कैप्चर - P0588R1
डिफ़ॉल्ट स्थिति को सहेजे बिना रचनात्मक और नियत लंबोदर - P0624R2
एक अलंकृत संदर्भ में लम्बदास - P0315R4

ज्यादातर मामलों में, नए पेश किए गए कार्यों में लैम्बडा का उपयोग "स्पष्ट" होता है, और वे कुछ उन्नत उपयोग के मामलों के लिए अनुमति देते हैं।

उदाहरण के लिए, P1091 के साथ आप एक संरचित बंधन पर कब्जा कर सकते हैं।

हमारे पास इसे कैप्चर करने से संबंधित स्पष्टीकरण भी हैं। C ++ 20 में, यदि आप एक विधि में [=] कैप्चर करते हैं, तो आपको एक चेतावनी मिलेगी:

 struct Baz { auto foo() { return [=] { std::cout << s << std::endl; }; } std::string s; }; GCC 9: warning: implicit capture of 'this' via '[=]' is deprecated in C++20

यदि आपको वास्तव में इस पर कब्जा करने की आवश्यकता है, तो आपको [=, this] लिखना चाहिए।

उन्नत उपयोग के मामलों से संबंधित परिवर्तन भी हैं, जैसे कि स्टेटलेस संदर्भ और स्टेटलेस लैम्ब्डा जो कि डिफ़ॉल्ट रूप से निर्मित किए जा सकते हैं।

दोनों परिवर्तनों के साथ आप लिख सकते हैं:

 std::map<int, int, decltype([](int x, int y) { return x > y; })> map;

वाक्यों के पहले संस्करण में इन विशेषताओं के लिए उद्देश्य पढ़ें: P0315R0 और P0624R0 ।

लेकिन आइए एक दिलचस्प विशेषता देखें: लैम्ब्डा टेम्पलेट्स।

लैम्बड पैटर्न

C ++ 14 में, हमें सामान्यीकृत लैम्ब्डा मिला, जिसका अर्थ है कि ऑटो के रूप में घोषित पैरामीटर टेम्पलेट पैरामीटर हैं।

लंबोदर के लिए:

 [](auto x) { x; }

कंपाइलर एक कॉल स्टेटमेंट बनाता है जो निम्नलिखित बॉयलरप्लेट विधि से मेल खाता है:

 template<typename T> void operator(T x) { x; }

लेकिन इस टेम्पलेट पैरामीटर को बदलने और वास्तविक टेम्पलेट तर्क का उपयोग करने का कोई तरीका नहीं था। C ++ 20 में, यह संभव होगा।

उदाहरण के लिए, हम किसी प्रकार के वैक्टर के साथ काम करने के लिए अपने लैम्ब्डा को कैसे सीमित कर सकते हैं?

हम एक सामान्य मेमना लिख सकते हैं:

 auto foo = []<typename T>(const auto& vec) { std::cout<< std::size(vec) << '\n'; std::cout<< vec.capacity() << '\n'; };

लेकिन अगर आप इसे एक अंतर पैरामीटर (उदाहरण के लिए, foo(10); ) कहते हैं, तो आपको कुछ मुश्किल से पढ़ने में कठिनाई हो सकती है:

 prog.cc: In instantiation of 'main()::<lambda(const auto:1&)> [with auto:1 = int]': prog.cc:16:11: required from here prog.cc:11:30: error: no matching function for call to 'size(const int&)' 11 | std::cout<< std::size(vec) << '\n';

C ++ 20 में हम लिख सकते हैं:

 auto foo = []<typename T>(std::vector<T> const& vec) { std::cout<< std::size(vec) << '\n'; std::cout<< vec.capacity() << '\n'; };

उपरोक्त लैम्ब्डा टेम्पलेट कॉल स्टेटमेंट की अनुमति देता है:

 <typename T> void operator(std::vector<T> const& s) { ... }

टेम्पलेट पैरामीटर कैप्चर क्लॉज [] अनुसरण करता है।

यदि आप इसे int (foo(10);) , तो आपको एक अच्छा संदेश मिलेगा:

 note: mismatched types 'const std::vector<T>' and 'int'

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

उपरोक्त उदाहरण में, संकलक हमें लैम्बडा इंटरफेस में विसंगतियों के बारे में शरीर के अंदर के कोड की तुलना में चेतावनी दे सकता है।

एक और महत्वपूर्ण पहलू यह है कि एक सार्वभौमिक लंबो में आपके पास केवल एक चर है, न कि इसका टेम्पलेट प्रकार। इसलिए, यदि आप इसे एक्सेस करना चाहते हैं, तो आपको डिक्टाइप (x) (तर्क के साथ लंबोदर अभिव्यक्ति के लिए) (ऑटो x) का उपयोग करना होगा। यह कुछ कोड को अधिक क्रियात्मक और जटिल बनाता है।

उदाहरण के लिए (P0428 से कोड का उपयोग करके):

 auto f = [](auto const& x) { using T = std::decay_t<decltype(x)>; T copy = x; T::static_function(); using Iterator = typename T::iterator; }

अब आप इस प्रकार लिख सकते हैं:

 auto f = []<typename T>(T const& x) { T::static_function(); T copy = x; using Iterator = typename T::iterator; }

उपरोक्त अनुभाग में, हमारे पास C ++ 20 का संक्षिप्त विवरण था, लेकिन मेरे पास आपके लिए एक और अतिरिक्त उपयोग का मामला है। यह तकनीक C ++ 14 में भी संभव है। तो पर पढ़ें

बोनस - लैम्ब्डा के साथ लिफ्टिंग

हमारे पास वर्तमान में एक समस्या है जब आपके पास फ़ंक्शन ओवरलोड हैं और आप उन्हें मानक एल्गोरिदम (या कुछ भी जिसे कुछ ऑब्जेक्ट की आवश्यकता होती है) में पास करना चाहते हैं:

 // two overloads: void foo(int) {} void foo(float) {} int main() { std::vector<int> vi; std::for_each(vi.begin(), vi.end(), foo); }

हमें GCC 9 (ट्रंक) से निम्न त्रुटि मिलती है:

 error: no matching function for call to for_each(std::vector<int>::iterator, std::vector<int>::iterator, <unresolved overloaded function type>) std::for_each(vi.begin(), vi.end(), foo); ^^^^^

हालांकि, एक चाल है जिसमें हम एक लंबो का उपयोग कर सकते हैं और फिर वांछित अधिभार फ़ंक्शन को कॉल कर सकते हैं।

मूल रूप में, सरल मूल्य प्रकारों के लिए, हमारे दो कार्यों के लिए, हम निम्नलिखित कोड लिख सकते हैं:

 std::for_each(vi.begin(), vi.end(), [](auto x) { return foo(x); });

और सबसे सामान्य रूप में, हमें थोड़ा और टाइप करने की आवश्यकता है:

 #define LIFT(foo) \ [](auto&&... x) \ noexcept(noexcept(foo(std::forward<decltype(x)>(x)...))) \ -> decltype(foo(std::forward<decltype(x)>(x)...)) \ { return foo(std::forward<decltype(x)>(x)...); }

बहुत जटिल कोड ... सही? :)

आइए इसे डिक्रिप्ट करने का प्रयास करें:

हम एक सामान्य लैम्ब्डा बनाते हैं और फिर हमारे द्वारा प्राप्त सभी तर्कों को पास करते हैं। इसे सही ढंग से निर्धारित करने के लिए, हमें noexcept और वापसी मान के प्रकार को निर्दिष्ट करने की आवश्यकता है। इसलिए हमें कॉलिंग कोड को डुप्लिकेट करना होगा - ताकि सही प्रकार मिल सके।
ऐसे LIFT मैक्रो किसी भी कंपाइलर में काम करता है जो C ++ 14 को सपोर्ट करता है।

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

निष्कर्ष

इस पोस्ट में, हमने C ++ 17 में महत्वपूर्ण बदलावों को देखा, और C ++ 20 में नई सुविधाओं का अवलोकन दिया।

आप देख सकते हैं कि भाषा के प्रत्येक पुनरावृत्ति के साथ, लैम्बडा के भाव अन्य C ++ तत्वों के साथ मिश्रित होते हैं। उदाहरण के लिए, C ++ 17 से पहले, हम उन्हें कॉन्स्टैक्स के संदर्भ में उपयोग नहीं कर सकते थे, लेकिन अब यह संभव है। इसी तरह जेनेरिक लैम्ब्डा के साथ C ++ 14 से शुरू होता है और टेम्पलेट लैम्बडा के रूप में C ++ 20 में उनका विकास होता है। क्या मुझे कुछ याद आ रहा है? शायद आपके पास कुछ रोमांचक उदाहरण हैं? कृपया मुझे टिप्पणियों में बताएं!

संदर्भ

C ++ 11 - [expr.prim.lambda]
C ++ 14 - [expr.prim.lambda]
C ++ 17 - [expr.prim.lambda]
C ++ में लैंबडा एक्सप्रेशंस | Microsoft डॉक्स
साइमन ब्रांड - कार्यों के लिए ओवरलोड सेट पास करना
जेसन टर्नर - सी ++ वीकली - एप 128 - लेम्बडा के लिए सी ++ 20 का टेम्प्लेट सिंटैक्स
जेसन टर्नर - सी ++ वीकली - एप 41 - सी ++ 17 का कॉन्स्ट्रेक्स लैंबडा सपोर्ट

हम सभी को पाठ्यक्रम पर पारंपरिक मुफ्त वेबिनार के लिए आमंत्रित करते हैं, जो कल 14 जून को होगा।

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

More articles: