std :: tr1 :: mem_fn वापसी प्रकार

Question

मैं इस का परिणाम रखना चाहता हूँ:

std::tr1::mem_fn(&ClassA::method); 

एक चर के अंदर, इस चर के प्रकार क्या है?

MagicalType fun = std::tr1::mem_fn(&ClassA::method); 

इसके अलावा, std::tr1::bind का परिणाम प्रकार क्या है:

कुछ इस तरह दिखेगा कि?

धन्यवाद!

Answer 1

std::tr1::mem_fn और std::tr1::bind दोनों के रिटर्न प्रकार अनिर्दिष्ट हैं।

आप एक std::tr1::function में std::tr1::bind का परिणाम स्टोर कर सकते हैं:

struct ClassA { 
    void Func() { } 
}; 

ClassA obj; 
std::tr1::function<void()> bound_memfun(std::tr1::bind(&ClassA::Func, obj)); 

तुम भी एक std::tr1::function में std::tr1::mem_fn का परिणाम स्टोर कर सकते हैं:

std::tr1::function<void(ClassA&)> memfun_wrap(std::tr1::mem_fn(&ClassA::Func)); 

Answer 2

mem_fn और bind की वापसी प्रकार है अनिर्दिष्ट। इसका मतलब है, तर्कों के आधार पर एक अलग प्रकार की वस्तु वापस आती है, और मानक विवरणों को निर्धारित नहीं करता है कि यह कार्यक्षमता कैसे कार्यान्वित की जानी चाहिए।

यदि आप यह जानना चाहते हैं कि किसी विशेष पुस्तकालय कार्यान्वयन (सैद्धांतिक हित के लिए, मुझे आशा है) के साथ किसी विशेष मामले में किस प्रकार का प्रकार है, तो आप हमेशा एक त्रुटि का कारण बन सकते हैं, और त्रुटि संदेश से प्रकार प्राप्त कर सकते हैं। E.g:

#include <functional> 

struct X 
{ 
    double method(float); 
}; 

int x = std::mem_fn(&X::method); 

9 Untitled.cpp cannot convert 'std::_Mem_fn<double (X::*)(float)>' to 'int' in initialization 

इस मामले में, ध्यान दें कि प्रकार का नाम आंतरिक उपयोग के लिए आरक्षित है। आपके कोड में, आपको किसी अग्रणी अंडरस्कोर (और पूंजी अक्षर) के साथ कुछ भी उपयोग नहीं करना चाहिए।

C++ 0x में, मुझे लगता है कि वापसी प्रकार होगा auto :)

auto fun = std::mem_fn(&ClassA::method); 

Answer 3

समारोह (आप इस प्रकार भी वापसी प्रकार देखें) निम्नलिखित तरीके से लागू किया जा सकता: आप इस कोशिश कर सकते हैं कोड का टुकड़ा http://webcompiler.cloudapp.net/। दुर्भाग्यवश, यह विविधता टेम्पलेट्स https://en.wikipedia.org/wiki/Variadic_template का उपयोग करता है जो सी ++ 11 मानक का हिस्सा हैं।

#include <iostream> 
#include <string> 

template <class R, class T, class... Args > class MemFunFunctor 
{ 
    private: 
    R (T::*mfp)(Args...); //Pointer to a member function of T which returns something of type R and taking an arbitrary number of arguments of any type 

public: 
    explicit MemFunFunctor(R (T::*fp)(Args...)):mfp(fp) {} 

    R operator()(T* t, Args... parameters) 
    { 
     (t->*mfp)(parameters...); 
    } 

}; 

template <class R,class T, class... Args> MemFunFunctor<R,T,Args... > my_mem_fn(R (T::*fp)(Args...)) 
{ 
    return MemFunFunctor<R,T,Args... >(fp); 
} 


class Foo //Test class 
{ 
    public: 
     void someFunction(int i, double d, const std::string& s) 
     { 
      std::cout << i << " " << d << " " << s << std::endl; 
     } 
}; 


int main() //Testing the above code 
{ 

    Foo foo; 
    auto f = my_mem_fn(&Foo::someFunction); 

    f(&foo, 4, 6.7, "Hello World!"); //same as foo.someFunction(4, 6.7, "Hello World!"); 

    return 0; 
}