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