Esiste qualcosa di simile a std :: function prima di C++ 11?

Question

Quale costrutto dovrebbe essere utilizzato come surrogato per std::function<> quando C++ 11 non è disponibile?
L'alternativa dovrebbe fondamentalmente consentire l'accesso alle funzioni dei membri privati ​​di una classe da un'altra classe come nell'esempio seguente (non vengono utilizzate altre funzionalità di std :: function). La classe Foo è fissa e non può essere modificata molto, ho solo accesso alla classe Bar.

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

C'è qualcosa di simile a std :: funzione prima di C++ 11?

Sì. C'è Boost.Function (boost::function<>), che recentemente è diventato parte della libreria standard C++ e ha fornito un'implementazione di riferimento per std::function<>; allo stesso modo, Boost.Bind (boost::bind<>()) è stato adottato dallo standard ed è diventato std::bind<>().

Si implementa una tecnica chiamata cancellazione di tipo portaoggetti richiamabili di qualsiasi tipo. Ecco una possibile implementazione illustrativo di come un tale modello di classe potrebbe essere definita da zero (non usare nel codice di produzione, questo è solo un esempio):

#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(); 
}