在C++ 11之前是否有類似於std :: function的東西？

Question

當C++ 11不可用時，應該使用什麼構造作爲std::function<>的代理？
替代方案應該基本上允許從下面的例子中訪問另一個類的一個類的私有成員函數（不使用std :: function的其他功能）。 Foo類是固定的，不能改變太多，我只能訪問類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

是否有類似的std之前C++ 11 ::功能的東西嗎？

是。有Boost.Function（boost::function<>），最近成爲C++標準庫的一部分，並提供了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(); 
}