C/C++ में लैम्ब्डा फंक्शन का महत्व

लैम्ब्डा फंक्शन (Lambda Function) - लैम्ब्डा एक इनलाइन फंक्शन है जिसे मुख्य प्रोग्राम के स्कोप के बाहर किसी कार्यान्वयन की आवश्यकता नहीं होती।

लैम्ब्डा फंक्शन की विशेषताएं

• एक वेरिएबल द्वारा मान के रूप में उपयोग किया जा सकता है
• इसे **फंक्टर (functors)** कहा जाता है - एक ऑब्जेक्ट जिसे फंक्शन की तरह कॉल किया जा सकता है
• जब भी कंपाइलर लैम्ब्डा फंक्शन की परिभाषा देखता है, यह लैम्ब्डा के लिए एक कस्टम ऑब्जेक्ट बनाता है
• सामान्य फंक्शन से अधिक कार्यक्षमता: **कैप्चरिंग मैकेनिज्म** होता है जो उपयोग किए गए वेरिएबल्स को कैप्चर करता है
• कैप्चर किया गया वेरिएबल ऑब्जेक्ट के सदस्य के रूप में माना जाता है
• "फंक्शन ऑब्जेक्ट" के रूप में संदर्भित किया जा सकता है जिसका अपना स्कोप और लाइफटाइम होता है
• सामान्य फंक्शन में पैरामीटर के रूप में पास किया जा सकता है

लैम्ब्डा सिंटैक्स (C++11 और बाद में)

[कैप्चर] (पैरामीटर्स) -> रिटर्न_टाइप { फंक्शन_बॉडी };

• [ ] - कैप्चर क्लॉज
• ( ) - पैरामीटर्स (वैकल्पिक)
• -> - रिटर्न टाइप (वैकल्पिक, निगमित किया जा सकता है)
• {...} - फंक्शन बॉडी

उदाहरण: बुनियादी लैम्ब्डा

auto lambda = [](int a) -> int { return a - 1; };
int result = lambda(5);  // result = 4

कैप्चर मोड्स

1. नाम से कैप्चर (मान द्वारा) - [x]

वेरिएबल की स्थानीय प्रति बनाता है। लैम्ब्डा के अंदर मूल वेरिएबल में परिवर्तन प्रतिबिंबित नहीं होते।

int main() {
    std::set<int> s = {1, 2, 3};
    int i = 20;
    std::for_each(s.begin(), s.end(), [i](int& elem) {
        std::cout << elem * i << std::endl;  // i की कॉपी उपयोग होती है
    });
}

2. संदर्भ द्वारा कैप्चर - [&x]

मूल वेरिएबल को संदर्भित करता है। लैम्ब्डा के अंदर परिवर्तन मूल वेरिएबल को प्रभावित करते हैं।

int main() {
    std::set<int> s = {1, 2, 3};
    int result = 0;
    std::for_each(s.begin(), s.end(), [&result](int& elem) {
        result += elem;  // मूल result संशोधित होता है
    });
    std::cout << result << std::endl;  // 6
}

3. सभी को मान द्वारा कैप्चर - [=]

4. सभी को संदर्भ द्वारा कैप्चर - [&]

5. मिश्रित - [=, &x] या [&, x]

मेंबर फंक्शन के अंदर लैम्ब्डा

class Func {
public:
    Func(std::set<int> s) : s1(s) {}
    
    void func(int level) {
        // 'this' कैप्चर करके मेंबर एक्सेस करें
        auto it = std::remove_if(s1.begin(), s1.end(), 
            [this, level](int i) -> bool { 
                return (i < level); 
            });
        s1.erase(it, s1.end());
    }
private:
    std::set<int> s1;
};

C बनाम C++

• C++: C++11 से लैम्ब्डा अभिव्यक्तियों का मूल समर्थन
• C: मूल लैम्ब्डा समर्थन नहीं; फंक्शन पॉइंटर्स और स्टेट स्ट्रक्चर्स का उपयोग करके अनुकरण करें

C में अनुकरण

// C में लैम्ब्डा जैसा व्यवहार
typedef struct {
    int (*func)(int, void*);
    void* context;
} Lambda;

int add_context(int x, void* ctx) {
    int* val = (int*)ctx;
    return x + *val;
}

int main() {
    int captured = 10;
    Lambda lambda = {add_context, &captured};
    printf("%d\n", lambda.func(5, lambda.context));  // 15
    return 0;
}

उपयोग के मामले

• STL एल्गोरिदम्स (sort, find_if, for_each) के साथ
• कॉलबैक्स और इवेंट हैंडलर्स
• लेजी इवैल्यूएशन
• फंक्शनल प्रोग्रामिंग पैटर्न्स