एक समारोह है कि

Question

मैं इस

template<typename T, typename U> 
map<T,U> mapMapValues(map<T,U> old, T (f)(T,U)) 
{ 
    map<T,U> new; 
    for(auto it = old.begin(); it != old.end(); ++it) 
    { 
     new[it->first] = f(it->first,it->second); 
    } 
    return new; 
} 

और विचार की तरह एक विधि है कि आप इसे इस

BOOST_AUTO_TEST_CASE(MapMapValues_basic) 
{ 
    map<int,int> test; 
    test[1] = 1; 
    map<int,int> transformedMap = VlcFunctional::mapMapValues(test, 
     [&](int key, int value) -> int 
     { 
      return key + 1; 
     } 
    ); 
} 

की तरह फोन करता हूँ हालांकि मैं त्रुटि मिलती है तर्क के रूप में एक लैम्ब्डा अभिव्यक्ति स्वीकार करता लिखें : फ़ंक्शन टेम्पलेट का कोई उदाहरण "VlcFunctional :: mapMapValues" तर्क सूची तर्क प्रकारों से मेल खाता है: (std :: map, std :: allocator >>, __lambda1)

कोई विचार क्या मैं गलत कर रहा हूं? विजुअल स्टूडियो 2008 और इंटेल C++ कम्पाइलर 11.1

Answer 1

आपका फ़ंक्शन एक फ़ंक्शन पॉइंटर की अपेक्षा कर रहा है, न कि लैम्ब्डा।

सी ++ में, सामान्यतः, 3 प्रकार के "कॉल करने योग्य ऑब्जेक्ट्स" होते हैं।

1. फ़ंक्शन पॉइंटर्स।
2. फ़ंक्शन ऑब्जेक्ट्स।
3. लैम्ब्डा फ़ंक्शन।

आप अपने समारोह इंटरफ़ेस में इन सभी का उपयोग करने के लिए सक्षम होना चाहते हैं, तो आप std::function इस्तेमाल कर सकते हैं:

template<typename T, typename U> 
map<T,U> mapMapValues(map<T,U> old, std::function<T(T, U)> f) 
{ 
    ... 
} 

इस समारोह की अनुमति देगा के तीन प्रकार के किसी भी उपयोग के नाम से जाना ऊपर कॉल करने योग्य वस्तुओं। हालांकि, इस सुविधा के लिए कीमत फ़ंक्शन पर इनोकेशन पर ओवरहेड की एक छोटी राशि है (आमतौर पर एक शून्य सूचक जांच, फिर फ़ंक्शन पॉइंटर के माध्यम से कॉल)। इसका मतलब है कि फ़ंक्शन लगभग निश्चित रूप से रेखांकित नहीं है (शायद उन्नत WPO/LTO के साथ)।

वैकल्पिक रूप से, आप दूसरे पैरामीटर के लिए मनमाना प्रकार लेने के लिए एक अतिरिक्त टेम्पलेट पैरामीटर जोड़ सकते हैं। यह अधिक कुशल होगा, लेकिन आप इस्तेमाल किए गए फ़ंक्शन पर टाइप-सुरक्षा खो देते हैं, और इससे अधिक कोड ब्लोट हो सकता है। खाली कब्जा सूची के साथ

template<typename T, typename U, typename F> 
map<T,U> mapMapValues(map<T,U> old, F f) 

Answer 2

आपका पैरामीटर प्रकार घोषणा T (f)(T,U) प्रकार के 'नि: शुल्क समारोह एक T और एक U ले रहे हैं और एक T लौटने' है। आप इसे एक लैम्ब्डा, फ़ंक्शन ऑब्जेक्ट या उस हस्ताक्षर के साथ वास्तविक फ़ंक्शन को छोड़कर कुछ भी नहीं पारित कर सकते हैं।

आप इस तरह std::function<T(T,U)> को पैरामीटर के प्रकार बदल कर इस का समाधान कर सकता:

template<typename T, typename U> 
map<T,U> mapMapValues(map<T,U> old, std::function<T(T,U)>) 
{ 
} 

वैकल्पिक रूप से, अगर आप इस तरह एक टेम्पलेट तर्क के रूप में समारोह प्रकार की घोषणा कर सकता है:

template<typename T, typename U, typename Fn> 
map<T,U> mapMapValues(map<T,U> old, Fn fn) 
{ 
    fn(...); 
} 

Answer 3

लैम्ब्डा अभिव्यक्ति, संकेत कार्य करने के लिए क्षय चाहिए n3052 के अनुसार। हालांकि ऐसा लगता है कि यह सुविधा वीसी ++ में लागू नहीं हुई है और केवल आंशिक रूप से g ++ में है, मेरे SO question देखें।

Answer 4

मैं इस सरल लेकिन आत्म-व्याख्यात्मक उदाहरण का योगदान देना चाहता हूं। यह दिखाता है कि "कॉल करने योग्य चीजें" (फ़ंक्शंस, फ़ंक्शन ऑब्जेक्ट्स, और लैम्बडास) को फ़ंक्शन या किसी ऑब्जेक्ट में कैसे पास किया जाए।

// g++ -std=c++11 thisFile.cpp 

#include <iostream> 
#include <thread> 

using namespace std; 

// ----------------------------------------------------------------- 
class Box { 
public: 
    function<void(string)> theFunction; 
    bool funValid; 

    Box() : funValid (false) { } 

    void setFun (function<void(string)> f) { 
    theFunction = f; 
    funValid = true; 
    } 

    void callIt() { 
    if (! funValid) return; 
    theFunction (" hello from Box "); 
    } 
}; // class 

// ----------------------------------------------------------------- 
class FunClass { 
public: 
    string msg; 
    FunClass (string m) : msg (m) { } 
    void operator() (string s) { 
    cout << msg << s << endl; 
    } 
}; 

// ----------------------------------------------------------------- 
void f (string s) { 
    cout << s << endl; 
} //() 

// ----------------------------------------------------------------- 
void call_it (void (*pf) (string)) { 
    pf("call_it: hello"); 
} //() 

// ----------------------------------------------------------------- 
void call_it1 (function<void(string)> pf) { 
    pf("call_it1: hello"); 
} //() 

// ----------------------------------------------------------------- 
int main() { 

    int a = 1234; 

    FunClass fc (" christmas "); 

    f("hello"); 

    call_it (f); 

    call_it1 (f); 

    // conversion ERROR: call_it ([&] (string s) -> void { cout << s << a << endl; }); 

    call_it1 ([&] (string s) -> void { cout << s << a << endl; }); 

    Box ca; 

    ca.callIt(); 

    ca.setFun (f); 

    ca.callIt(); 

    ca.setFun ([&] (string s) -> void { cout << s << a << endl; }); 

    ca.callIt(); 

    ca.setFun (fc); 

    ca.callIt(); 

} //() 

Answer 5

यहाँ कैसे पैरामीटर

class YourClass 
{ 
void YourClass::callback(void(*fptr)(int p1, int p2)) 
{ 
    if(fptr != NULL) 
     fptr(p1, p2); 
} 
}; 

void dummyfunction(int p1, int p2) 
{ 
    cout << "inside dummyfunction " << endl; 
} 

YourClass yc; 

// using a dummyfunction as callback 
yc.callback(&dummyfunction); 

// using a lambda as callback 
yc.callback([&](int p1, int p2) { cout << "inside lambda callback function" << endl; }); 

// using a static member function 
yc.callback(&aClass::memberfunction);