指定一个成员函数如在C ++ 11回调(Specifying a member function a

我有以下几点：

typedef std::function<bool (const std::string&)> SomethingCoolCb;

class ClassA
{
public:
    void OnSomethingCool(const SomethingCoolCb& cb)
    {
        _cb = cb;
    }

private:
    SomethingCoolCb _cb;
};

class ClassB
{
public:
    ClassB();
    bool Juggle(const std::string& arg);

private:
    ClassA _obj;
};

我想指定ClassB的::杂耍（）成员函数作为回调ClassB的:: _ OBJ。将正确的方法做，在C ++ 11（ClassB中的构造函数）：

ClassB::ClassB()
{
    _obj.OnDoSomethingCool(
        [&](const std::string& arg) -> bool
        {
            return Juggle(arg);
        });
}

据我所知，编译器会做一个std ::函数对象了上述拉姆达代码。因此，当回调被调用，它会调用的std ::功能::运算符（）成员，然后它会调用ClassB的::杂耍（），而不是直接（）调用ClassB的::戏法。除非我弄错了在幕后发生了什么，这一切似乎有点效率低下。有没有更好的办法？

只使用std::function ，如果你真的需要多态函数。否则，使它成为一个模板。

要适应一个成员函数的仿函数使用std::mem_fn然后bind对象到第一个参数，产生的仿函数可以作为你的回调。

样品：

#include <string>
#include <functional>

template<typename F>
class ClassA
{
public:
    ClassA(F f) : _cb(f) {}

private:
    F _cb;
};

class ClassB
{
public:
    ClassB() 
  : _obj(std::bind(&ClassB::Juggle, this, 
                   std::placeholders::_1)) 
  {}
  bool Juggle(const std::string& arg) {return true;}
private:
    ClassA<decltype(std::bind(
                      std::declval<bool (ClassB::*)(const std::string&)>()
                      , std::declval<ClassB*>()
                      , std::placeholders::_1
                      ) ) > _obj;
};

int main()
{
  ClassB b;
  return 0;
}

这在被可怕丑陋的成本侧步的功能成本。