लैम्ब्डा ओवरलोड बनाने के लिए मुझे विविधता टेम्पलेट विरासत का उपयोग करने की क्या ज़रूरत है?

Question

मैं चरम टेम्पलेट पैरामीटर की पुनरावर्ती प्रकृति का उपयोग करने की मूल अवधारणा को समझता हूं और पैरामीटर सूची के माध्यम से अपना रास्ता "खाने" के क्रम में एक विशिष्ट टेम्पलेट तत्कालता को समझता हूं।

मैं समझता हूं कि लैम्ब्डा को कुछ प्रकार लेने के लिए लिखा जा सकता है और फिर कुछ प्रकार वापस कर सकते हैं। ध्यान रखें कि मैं अभी भी सी ++ 14 और सी ++ 11 सीख रहा हूं, इसलिए मैंने एक या दूसरे को महारत हासिल नहीं किया है।

// For std::string 
#include <string> 

// For std::cout 
#include <iostream> 


//Create a generalized list instantiation 
template <typename ... F> 
struct overload : public F... { 
    overload(F... f) : F(f)... {} 
};  

//Create an specific end-case, where we directly 
//inherit the() operator in order to inherit 
//multiple() overloads 
template <typename F> 
struct overload : F { 
    using F::operator(); 
}; 


//template function to create an overload 
template <class... F> 
auto make_overload(F... f) { 
    return (f...); 
} 

int main() { 
    auto f = [](int x,int y) -> int { 
     return x+y; 
    }; 
    auto g = [](double x,double y) -> int { 
     return std::ftoi(x+y); 
    }; 
    auto h = [](std::string x,std::string y) -> int { 
     return std::stoi(x+y); 
    }; 

    //Ah, but this is a function. 
    auto fgh = make_overload(f,g,h); 

    std::cout << (fgh(1,2)) << std::endl; 
    std::cout << (fgh(1.5,2.5)) << std::endl; 
    std::cout << (fgh("bob","larry")) << std::endl; 
} 

Coliru: http://coliru.stacked-crooked.com/a/5df2919ccf9e99a6

क्या मैं धारणात्मक यहाँ याद आ रही है

यहाँ otherStack Overflow questions को देखकर पर बाद मेरे प्रयास किया गया था? अन्य उत्तरों संक्षेप में चेहरे के मूल्य पर इस समस्या का उत्तर दे सकते हैं, लेकिन मैं एक स्पष्टीकरण की तलाश कर रहा हूं कि उत्तर मेरी सोच को क्यों बढ़ाता है। अगर मैं समझता हूं कि ऑपरेटरों के उत्तराधिकारी के लिए मुझे using F::operator() करने की आवश्यकता है और मैं सही ढंग से बताता हूं कि वापसी और पैरामीटर प्रकार अलग हैं, तो मुझे यह काम करने के लिए और क्या करने की आवश्यकता है?

1. एक सामान्य variadic टेम्पलेट आधार वर्ग बनाएँ:

   यहाँ सोचा था की मेरी ट्रेन है।

2. विशिष्ट लैम्ब्डा के operator() को अधिभारित करने के लिए एक विशिष्ट टेम्पलेट केस बनाएं।
3. एक भिन्न टेम्पलेट तर्क सूची लेने के लिए एक सहायक फ़ंक्शन बनाएं और फिर "ओवरलोड" श्रेणी बनाने के लिए इसका उपयोग करें।
4. सुनिश्चित करें कि प्रकार स्पष्ट हैं।

Answer 1

आपने वास्तव में रिकर्स नहीं किया था।

// primary template; not defined. 
template <class... F> struct overload; 

// recursive case; inherit from the first and overload<rest...> 
template<class F1, class... F> 
struct overload<F1, F...> : F1, overload<F...> { 
    overload(F1 f1, F... f) : F1(f1), overload<F...>(f...) {} 

    // bring all operator()s from the bases into the derived class 
    using F1::operator(); 
    using overload<F...>::operator(); 
};  

// Base case of recursion 
template <class F> 
struct overload<F> : F { 
    overload(F f) : F(f) {} 
    using F::operator(); 
};