C++14 में जेनेरिक लैम्ब्डा कैसे काम करता है?

पृष्ठभूमि: C++11 लैम्ब्डास

C++11 में, लैम्ब्डा एक्सप्रेशन्स पेश किए गए थे। लैम्ब्डा मूल रूप से एक फ़ंक्शन ऑब्जेक्ट है जिसे अन्य फ़ंक्शन कॉल स्टेटमेंट्स के अंदर नेस्टेड किया जा सकता है। auto कीवर्ड के साथ लैम्ब्डा एक्सप्रेशन्स को जोड़कर, उन्हें बाद में उपयोग किया जा सकता है।

C++14 सुधार: जेनेरिक लैम्ब्डास

C++14 में, ये लैम्ब्डा एक्सप्रेशन्स बेहतर हुए। यहां हम **जेनेरिक** या **पॉलीमॉर्फिक लैम्ब्डा** प्राप्त कर सकते हैं। उदाहरण के लिए, यदि हम एक लैम्ब्डा बनाना चाहते हैं जो इंटीजर्स जोड़ सके, फ्लोट्स जोड़ सके, और स्ट्रिंग्स भी कनकैट कर सके, तो हमें इस जेनेरिक लैम्ब्डा का उपयोग करना होगा।

सिंटैक्स

[](auto x, auto y) { return x + y; }

auto पैरामीटर टाइप्स लैम्ब्डा को किसी भी टाइप के आर्गुमेंट्स स्वीकार करने की अनुमति देते हैं जो + ऑपरेटर का समर्थन करते हैं।

उदाहरण

#include <iostream>
#include <string>
using namespace std;

int main() {
    // जेनेरिक लैम्ब्डा परिभाषित करें
    auto add = [](auto arg1, auto arg2) {
        return arg1 + arg2;
    };
    
    cout << "Sum of integers: " << add(5, 8) << endl;
    cout << "Sum of floats: " << add(2.75, 5.639) << endl;
    cout << "Concatenate Strings: " << add(string("Hello "), string("World")) << endl;
    
    // यह वेक्टर और अन्य टाइप्स के साथ भी काम करता है जिनमें operator+ है
    vector v1 = {1, 2}, v2 = {3, 4};
    // auto v3 = add(v1, v2);  // त्रुटि: vector में operator+ नहीं है
    
    return 0;
}

आउटपुट

Sum of integers: 13
Sum of floats: 8.389
Concatenate Strings: Hello World

यह कैसे काम करता है?

जेनेरिक लैम्ब्डा के लिए, कंपाइलर एक **टेम्पलेट फ़ंक्शन ऑपरेटर()** के साथ फंक्टर क्लास जनरेट करता है:

// वैचारिक रूप से जो कंपाइलर जनरेट करता है
struct GenericLambda {
    template <typename T, typename U>
    auto operator()(T x, U y) const -> decltype(x + y) {
        return x + y;
    }
};

उन्नत उपयोग

जेनेरिक लैम्ब्डा के साथ STL एल्गोरिदम

vector v = {1, 2, 3, 4, 5};

// किसी भी कंटेनर और टाइप के साथ काम करने वाला जेनेरिक प्रिंट
auto print = [](const auto& container) {
    for (const auto& elem : container) {
        cout << elem << ' ';
    }
    cout << '\n';
};

print(v);  // वेक्टर के साथ काम करता है
print(array{1, 2, 3});  // ऐरे के साथ काम करता है
print(list{1, 2, 3});   // लिस्ट के साथ काम करता है

ऑटो रिटर्न टाइप डिडक्शन (C++14)

// C++20: एक्सप्लिसिट टेम्पलेट पैरामीटर्स
auto func = []<typename T>(T x, T y) {
    return x + y;
};