Capturing variables in lambdas c++ In Hindi
C++ प्रोग्रामिंग लैंग्वेज में लैम्ब्डा एक्सप्रेशन C++ यूजर को किसी प्रोग्राम में एनॉनिमस फ़ंक्शन को डिफाइन करने में हेल्प करते हैं, और C++ के सबसे बेस्ट इम्पोर्टेन्ट फ़ीचर में से एक कांसेप्ट है, लैम्ब्डा एक्सप्रेशन इसके यूजर को प्रोग्राम के आस-पास के आउटर स्कोप से वेरिएबल कैप्चर करने की क्षमता प्रोवाइड करता है। इससे C++ यूजर लैम्ब्डा उस स्कोप से लोकल वेरिएबल (डेटा पैरामीटर मेंबर सहित) प्रोग्राम में अप्लाई कर सकते है, जिसमें उस लैम्ब्डा एक्सप्रेशन को डिक्लेअर किया गया है। इन लैम्ब्डा एक्सप्रेशन वेरिएबल डाटा को कैप्चर करने के कई मेथड और प्रोसेस हैं. जिसमें C++ यूजर किसी लैम्ब्डा एक्सप्रेशन को वैल्यू से, रेफरेंस से, या दोनों मेथड को ग्रुप कर कैप्चर कर सकते है।
So, let’s take a closer look at C++ programming lambda expressions and their behavior.
Capture Clause in Lambda Expressions.
C++ प्रोग्रामिंग में लैम्ब्डा का कैप्चर क्लॉज़ स्क्वायर ब्रैकेट ([]) में इंडीकेट या डिक्लेअर किया गया है, और यह मौजूदा प्रोग्राम में कंट्रोल करता है कि उसके आस-पास के पैरामीटर स्कोप से कौन से वेरिएबल डाटा टाइप लैम्ब्डा के अंदर से एक्सेस और कण्ट्रोल किए जा सकते हैं। C++ यूजर लैम्ब्डा एक्सप्रेशन में वेरिएबल को कई तरीकों से कैप्चर और प्रोग्राम के स्कोप को मैनेज कर सकते हैं.
Syntax of a Lambda Capture Clause.
[ capture ]( parameters ) -> return_type { function_body }
Element of a Lambda Capture Clause.
- [] – यह लैम्ब्डा एक्सप्रेशन में कैप्चर क्लॉज़ स्क्वायर ब्रैकेट है।
- parameters – यह लैम्ब्डा एक्सप्रेशन में डिफाइन पैरामीटर वेरिएबल की लिस्ट है, यह एक रेगुलर फ़ंक्शन की तरह डिफाइन होते है।
- return_type – यह लैम्ब्डा एक्सप्रेशन में एक रिटर्न टाइप (ऑप्शनल) मेथड है।
- function_body – यह लैम्ब्डा एक्सप्रेशन में वह सोर्स कोड है, जो लैम्ब्डा एक्सप्रेशन को इनवोक करने पर एक्सेक्यूट होता है।
Types of capturing variables in a lambda expression.
Capturing by value in a lambda expression.
जब C++ यूजर किसी लैम्ब्डा एक्सप्रेशन में वैल्यू से वेरिएबल को कैप्चर करते हैं. तो इस प्रोसेस में उस वेरिएबल की एक कॉपी क्रिएट की जाती है, और मौजूदा लैम्ब्डा एक्सप्रेशन के अंदर अप्लाई की जाती है। मौजूदा लैम्ब्डा लॉजिक के अंदर वेरिएबल में किए गए किसी भी प्रकार के मॉडिफिकेशन एक्सटर्नल स्कोप में ओरिजिनल वेरिएबल को इम्पैक्ट नहीं करते हैं।
Example of capturing a lambda expression by value.
#include <iostream>
int main() {
int p = 3;
int q = 4;
// here we capture by value Lambda expressions
auto total = [p, q]() {
return p + q; // here p and q are captured by value expression
};
std::cout << “The total of p and q is – ” << total() << std::endl; // Result is – 7
// here we modify update p and q variable value in the outer scope
p = 11;
q = 19;
// here the values of p and q inside the lambda are unaffected after modification
std::cout << “Total value [after updatation] – ” << total() << std::endl; // Result is – 7
return 0;
}
Explanation of capturing a lambda expression by value.
- यहाँ इस एक्साम्प्ल में, लैम्ब्डा [p, q]() p और q वेरिएबल को वैल्यू से कैप्चर करता है, इसका मतलब है कि यह p और q लैम्ब्डा पैरामीटर की एक कॉपी क्रिएट करता है।
- लैम्ब्डा के आउटर स्कोप में p और q वैल्यू को मॉडिफाई करने से लैम्ब्डा के अंदर की वैल्यू पर कोई इम्पैक्ट नहीं होता है, क्योंकि यहाँ उन्हें वैल्यू से कैप्चर किया गया था।
Capture by reference in a lambda expression.
जब C++ यूजर किसी प्रोगाम में रेफरेंस से किसी लैम्ब्डा एक्सप्रेशन वेरिएबल को कैप्चर करते हैं, तो यूजर डिफाइन लैम्ब्डा लॉजिक मौजूदा वेरिएबल की कोई कॉपी क्रिएट नहीं करता है। इसके बदले, यह डायरेक्ट आउटर स्कोप से ओरिजिनल वेरिएबल को एक्सेस और मैनेज करता है। इसके परिणाम स्वरुप, लैम्ब्डा एक्सप्रेशन के अंदर डिफाइन किए गए कोई भी मॉडिफिकेशन अपडेट आउटर स्कोप में ओरिजिनल वेरिएबल को इम्पैक्ट करते है।
Example of a lambda expression capturing by reference.
#include <iostream>
int main() {
int p = 6;
int q = 4;
// here we capture by reference Lambda expressions
auto total = [&p, &q]() {
return p + q; // here p and q are captured by reference
};
std::cout << “The total of p and q is – ” << total() << std::endl; // Result is – 10
// here we modify update p and q variable value in the outer scope
p = 7;
q = 9;
// here the values of p and q inside the lambda are updated
std::cout << “Total value [after updatation] – ” << total() << std::endl; // Result is – 16
return 0;
}
Explanation of a lambda expression capturing by reference.
- यहाँ इस एक्साम्प्ल में, लैम्ब्डा एक्सप्रेशन [&p, &q]() रेफरेंस से p और q वेरिएबल को कैप्चर करता है, इसका मतलब है कि यह ओरिजिनल वेरिएबल पर ऑपरेट करता है।
- जब p और q वेरिएबल को लैम्ब्डा के बाहर मॉडिफ़ाई किया जाता है, तो ये बदलाव लैम्ब्डा में सीधे डिस्प्ले होते हैं. क्योंकि यहाँ लैम्ब्डा एक्सप्रेशन ओरिजिनल वेरिएबल्स के रेफरेंस को कैप्चर करता है।
Capturing all variables in a lambda expression (by value or reference).
यहाँ C++ यूजर नीचे दिए गए सिंटैक्स मेथड का यूज़ करके लैम्ब्डा एक्सप्रेशन के आस-पास के वेरिएबल स्कोप से सभी वैरिएबल को वैल्यू या रेफरेंस मेथड से लैम्ब्डा एक्सप्रेशन में कैप्चर कर सकते हैं.
- Capture all variables by value in a lambda expression – [=]
- Capture all variables by reference in a lambda expression – [&]
Example of capturing all variables by value in a lambda expression.
#include <iostream>
int main() {
int p = 6;
int q = 5;
// here we capture all Lambda expressions variables by value method
auto total = [=]() {
return p + q; // here both p and q are captured by value
};
std::cout << “The total of p and q is – ” << total() << std::endl; // Result is – 11
p = 12;
q = 7;
// here the captured values do not change, as they were captured by value method
std::cout << “Total value [after updatation] – ” << total () << std::endl; // Result is – 11
return 0;
}
Explanation of capturing all variables by value in a lambda expression.
- यहाँ इस एक्साम्प्ल में, [=] सभी लोकल लैम्ब्डा एक्सप्रेशन वेरिएबल को वैल्यू से कैप्चर करता है। लैम्ब्डा के आउटर स्कोप p और q पैरामीटर में किए गए कोई भी मॉडिफिकेशन लैम्ब्डा के अंदर कैप्चर की गई वैल्यू को इम्पैक्ट नहीं करते हैं।
Example of capturing all lambda expression variables by reference.
#include <iostream>
int main() {
int p = 5;
int q = 8;
// here we capture all variables by reference
auto total = [&]() {
return p + q; // here both p and q are captured by reference method
};
std::cout << “The total of p and q is – ” << total() << std::endl; // Result is – 13
p = 9;
q = 7;
// The captured values are updated because they were captured by reference
std::cout << “Total value [after updatation] – ” << total() << std::endl; // Result is – 16
return 0;
}
Explanation of capturing all lambda expression variables by reference.
- यहाँ इस एक्साम्प्ल में, [&] सभी लैम्ब्डा एक्सप्रेशन वेरिएबल को रेफरेंस से कैप्चर करता है। लैम्ब्डा के आउटर स्कोप में p और q वेरिएबल में किए गए कोई भी मॉडिफिकेशन लैम्ब्डा के अंदर डिस्प्ले होते हैं।
