क्या सी ++ 11 से पहले std :: function के समान कुछ है?

Question

सी ++ 11 उपलब्ध नहीं होने पर std::function<> के लिए सरोगेट के रूप में किस निर्माण का उपयोग किया जाना चाहिए?
वैकल्पिक रूप से नीचे एक उदाहरण के रूप में एक वर्ग के निजी सदस्य कार्यों तक पहुंचने की अनुमति देनी चाहिए जैसे कि नीचे दिए गए उदाहरण (std :: function की अन्य विशेषताओं का उपयोग नहीं किया जाता है)। कक्षा फू तय है और ज्यादा नहीं बदला जा सकता है, मेरे पास केवल कक्षा बार तक पहुंच है।

class Foo { 
    friend class Bar; // added by me, rest of the class is fixed 
    private: 

    void doStuffFooA(int i); 
    void doStuffFooB(int i); 
}; 

class Bar { 
    public: 

    Bar(Foo foo, std::function< void (const Foo&, int) > func) { 
    myFoo = foo; 
    myFooFunc = func; 
    }; 

    private: 

    doStuffBar(const &Foo foo) { 
    myFooFunc(foo, 3); 
    } 

    Foo myFoo; 
    std::function< void (const Foo&, int) > myFooFunc; 
} 

int main() { 

    Foo foo(...); 

    Bar barA(foo, &Foo::doStuffFooA); 

    Bar barB(foo, &Foo::doStuffFooB); 
    ... 
} 

Answer 1

वहाँ से पहले सी ++ 11 :: समारोह एसटीडी कुछ इसी तरह है?

हाँ। Boost.Function (boost::function<>) है, जो हाल ही में सी ++ मानक लाइब्रेरी का हिस्सा बन गया है और std::function<> के लिए संदर्भ कार्यान्वयन प्रदान किया गया है; इसी प्रकार, Boost.Bind (boost::bind<>()) मानक द्वारा अपनाया गया था और std::bind<>() बन गया।

यह किसी भी प्रकार की कॉल करने योग्य वस्तुओं को रखने के लिए टाइप एरर नामक एक तकनीक लागू करता है। यहाँ एक संभव है, कैसे इस तरह के एक वर्ग टेम्पलेट खरोंच से परिभाषित किया जा सकता है की निदर्शी कार्यान्वयन (उत्पादन कोड में उपयोग नहीं करते हैं, यह सिर्फ एक उदाहरण है):

#include <memory> 

template<typename T> 
struct fxn { }; 

template<typename R, typename... Args> 
struct fxn<R(Args...)> 
{ 

public: 

    template<typename F> 
    fxn(F&& f) 
     : 
     _holder(new holder<typename std::decay<F>::type>(std::forward<F>(f))) 
    { } 

    R operator() (Args&&... args) 
    { _holder->call(std::forward<Args>(args)...); } 

private: 

    struct holder_base 
    { virtual R call(Args&&... args) = 0; }; 

    template<typename F> 
    struct holder : holder_base 
    { 
     holder(F&& f) : _f(std::forward<F>(f)) { } 
     R call(Args&&... args) { return _f(std::forward<Args>(args)...); } 
     F _f; 
    }; 

    std::unique_ptr<holder_base> _holder; 
}; 

#include <iostream> 

int main() 
{ 
    fxn<void()> f = [] { std::cout << "hello"; }; 
    f(); 
}