लैम्ब्डा सादे कार्यों की तुलना में उन्नत कंपाइलर अनुकूलन की अनुमति क्यों देता है

निकोलाई जोसुटिस द्वारा सी स्टैंडर्ड लाइब्रेरी (दूसरा संस्करण) का दावा है कि लैम्ब्डा कर सकता है सादे फ़ंक्शंस की तुलना में कंपाइलरों द्वारा अधिक प्रभावी ढंग से अनुकूलित किया जा सकता है। यह लाभ फ़ंक्शन ऑब्जेक्ट के रूप में लैम्ब्डा की प्रकृति से उत्पन्न होता है।

जब एक लैम्ब्डा को फ़ंक्शन टेम्पलेट में पास किया जाता है, तो इसे विशेष रूप से उस ऑब्जेक्ट के अनुरूप एक नए फ़ंक्शन के रूप में इंस्टेंट किया जाता है। यह कंपाइलर को लैम्ब्डा कॉल को आसानी से इनलाइन करने की अनुमति देता है। इसके विपरीत, सादे फ़ंक्शंस के साथ, एक फ़ंक्शन पॉइंटर फ़ंक्शन टेम्पलेट को पास कर दिया जाता है। परंपरागत रूप से, कंपाइलरों को फ़ंक्शन पॉइंटर्स के माध्यम से किए गए कॉल को इनलाइन करने में कठिनाइयों का सामना करना पड़ता है। शून्य मानचित्र (इटर प्रारंभ, इटर अंत, एफ एफ) { के लिए (; प्रारंभ ! = अंत; आरंभ) *शुरू = एफ(*शुरू); }

इस फ़ंक्शन को लैम्ब्डा के साथ लागू करना:

template 
void map(Iter begin, Iter end, F f) {
    for (; begin != end;   begin)
        *begin = f(*begin);
}

इस मामले में, कंपाइलर के पास _some_lambda_type::operator() तक पहुंच है और वह इसमें निर्बाध रूप से इनलाइन कॉल कर सकता है। प्रत्येक लैम्ब्डा का एक अलग प्रकार होता है, इसलिए मैप() के साथ एक अलग लैम्ब्डा का उपयोग करने से एक नया इंस्टेंटेशन उत्पन्न होगा।

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });

map(int* प्रारंभ, int* अंत, int (*f)(int)) { के लिए (; प्रारंभ ! = अंत; आरंभ) *शुरू = एफ(*शुरू); }

template 
void map(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end;   begin)
        *begin = f.operator()(*begin);
}