Czy istnieje coś podobnego do std :: function before C++ 11?

Question

Jaki konstrukt powinien być użyty jako surogat dla std::function<>, gdy C++ 11 jest niedostępny?
Alternatywa powinna zasadniczo umożliwiać dostęp do prywatnych funkcji składowych jednej klasy z innej klasy, jak w poniższym przykładzie (inne funkcje funkcji std :: nie są używane). Klasa Foo jest stała i nie można jej zmienić zbyt wiele, mam dostęp tylko do paska klasy.

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

Czy jest coś podobnego do std :: funkcję przed C++ 11?

Tak. Istnieje funkcja Boost.Function (boost::function<>), która ostatnio stała się częścią Standardowej Biblioteki C++ i dostarczyła implementację referencyjną dla std::function<>; podobnie, Boost.Bind (boost::bind<>()) został przyjęty przez Standard i stał się std::bind<>().

Implementuje technikę o nazwie typu wymazanie do przechowywania obiektów wymienialnych dowolnego typu. Tutaj jest to możliwe, ilustrujące realizacja jak taki szablon klasy można zdefiniować od podstaw (nie używać w kodzie produkcyjnym, jest to tylko przykład):

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