C++ में लैम्ब्डा एक्सप्रेशन

C++ STL में उपयोगी जेनेरिक फ़ंक्शन्स जैसे std::for_each शामिल हैं। दुर्भाग्य से उनका उपयोग करना काफी बोझिल हो सकता है, विशेष रूप से यदि आप जिस फंक्टर को लागू करना चाहते हैं वह विशेष फ़ंक्शन के लिए यूनिक है। इसलिए वह फ़ंक्शन जिसे आप बनाएंगे वह उस नेमस्पेस में केवल उस एक स्थान पर उपयोग होने के लिए होगा। इस समस्या का समाधान अनाम फ़ंक्शन्स का उपयोग करना है।

C++11 में लैम्ब्डा एक्सप्रेशन्स पेश किए गए हैं ताकि अनाम फ़ंक्शन बनाए जा सकें। उदाहरण के लिए:

उदाहरण

#include <iostream>
#include <vector>
#include <algorithm> // for_each के लिए
using namespace std;

int main() {
    vector<int> myvector;
    myvector.push_back(1);
    myvector.push_back(2);
    myvector.push_back(3);
    
    for_each(myvector.begin(), myvector.end(), [](int x) {
        cout << x * x << endl;
    });
}

आउटपुट

1
4
9

लैम्ब्डा सिंटैक्स

[कैप्चर-क्लॉज] (पैरामीटर्स) -> रिटर्न-टाइप { बॉडी }

• [कैप्चर-क्लॉज] - बाहरी वेरिएबल्स को कैप्चर कैसे करें
• (पैरामीटर्स) - फ़ंक्शन पैरामीटर्स (वैकल्पिक यदि खाली)
• -> रिटर्न-टाइप - रिटर्न टाइप (वैकल्पिक यदि डिड्यूसिबल)
• { बॉडी } - फ़ंक्शन बॉडी

कैप्चर क्लॉज के प्रकार

उदाहरण: विभिन्न कैप्चर

int x = 10, y = 20;

// वैल्यू द्वारा कैप्चर
auto lambda1 = [x]() { cout << x; }; // x = 10

// रेफरेंस द्वारा कैप्चर
auto lambda2 = [&x]() { x = 30; }; // x को मॉडिफाई करता है

// मिश्रित
auto lambda3 = [=, &y]() { y = 40; }; // x वैल्यू द्वारा, y रेफरेंस द्वारा

// जनरलाइज्ड लैंब्डा कैप्चर (C++14)
auto lambda4 = [z = x + y]() { cout << z; }; // z = 30

व्यावहारिक उदाहरण

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // फ़िल्टर: केवल इवन नंबर्स
    vector evens;
    copy_if(v.begin(), v.end(), back_inserter(evens), 
            [](int x) { return x % 2 == 0; });
    
    // ट्रांसफॉर्म: वर्ग करें
    vector squares;
    transform(v.begin(), v.end(), back_inserter(squares),
              [](int x) { return x * x; });
    
    // सॉर्ट कस्टम कम्पेरेटर के साथ
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; }); // डिसेंडिंग
    
    // एक्यूमुलेट लैंब्डा के साथ
    int sum = accumulate(v.begin(), v.end(), 0, 
                         [](int a, int b) { return a + b; });
    
    return 0;
}

म्यूटेबल लैम्ब्डा

// डिफ़ॉल्ट रूप से लैम्ब्डा const होता है
auto lambda = [x]() { x = 20; }; // एरर! x const है

// mutable कीवर्ड जोड़ें
auto lambda2 = [x]() mutable { x = 20; cout << x; }; // OK, लेकिन x कॉपी है