如何使构造函数接受std :: function也接受方法指针

时间:2015-03-10 23:26:31

标签: c++ c++11 std-function

说我有

class Foo
{
public:
    Foo(std::function<void(std::string)> callback1,
        std::function<void(int)> callback2) :
        callback1(callback1), callback2(callback2)
    {
    }

private:
    std::function<void(std::string)> callback1;
    std::function<void(int)> callback2
}

我可以在使用普通函数

的情况下轻松构建它
void callback1Handler(std::string)
{
    // i'm a potato
}

void callback2Handler(int)
{
    // i'm a teapot
}

int main()
{
    Foo foo(callback1Handler, callback2Handler);

    return 0;
}

但如果我使用课程,那么事情会变得复杂。

我希望能够做the Addendum of this answer does

之类的事情
class Main
{
public:
    Main()
    {
        Foo foo(&Main::callback1Handler, &Main::callback2Handler);
    }

    void callback1Handler(std::string)
    {
        // i'm a potato
    }

    void callback2Handler(int)
    {
        // i'm a teapot
    }
}

但显然不会编译。为了使其工作,需要使用std::bind或lambdas,或其他。

我想尽量避免std::bind(&Main::callbackNHandler, this, std::placeholders::_1, ..., std::placeholders::_N)的丑陋,这主要是明确规定这些占位符的丑陋。

将lambdas用作[=](std::string str){callbackNHandler(str);}也很难看,因为你必须指定回调接受的每个变量。

如果我可以使用&Main::callback1Handler,就像在Main类示例中那样,或者&Main::callback1Handler, this,这会更灵活,因为您可以指定实例指针Main

请注意,Foo构造函数必须保持不变,callback1callback2成员变量也必须保持不变。但是,您可以重载Foo构造函数,将重载转换方法指针(或其他任何您要接受的内容)指向std::function并将它们存储在callback1&amp; {{1 }}

2 个答案:

答案 0 :(得分:4)

template<class T, class R, class...Args>
std::function<R(Args...)> method( T* t, R(T::*m)(Args...) ){
  return [=](Args&&...args)->R{
    return (t->*m)(std::forward<Args>(args)...);
  };
}

然后method( instance, &Main::callback1Handler )应该有效,直到拼写错误。

在C ++ 14中变得更简单。

上面做了不必要的类型擦除:辅助类型而不是lambda可以避免这种情况。

template<class T, class Sig>
struct method_t;
template<class T, class R, class... Args>
struct method_t<T,R(Args...)> {
  T* t;
  R(T::*m)(Args...);
  template<class...Ts>
  R operator()(Ts&&...ts)const{
    return (t->*m)(std::forward<Ts>(ts)...);
  }
};

template<class T, class R, class...Args>
method_t<T, R(Args...)> method( T* t, R(T::*m)(Args...) ){
  return {t, m};
}

具有相同的签名。它甚至可以存储在std::function<R(Args...)>中。上述优点是,如果std::function的签名不完全匹配,或者根本不使用std::function,则不会产生不必要的开销。

缺点是代码的3倍。

在C ++ 14中我们可以做到:

template<class T, class R, class...Args>
auto method( T* t, R(T::*m)(Args...) ){
  return [=](auto&&...args)->R{
    return (t->*m)(decltype(args)(args)...);
  };
}

与第一个一样简短,与第二个一样强大。

答案 1 :(得分:2)

  

将lambdas用作[=](std::string str){callbackNHandler(str);}也很难看,因为你必须指定回调接受的每个变量。

C ++ 14泛型lambdas解决了这个问题:

[this](auto... args){ callback1Handler(args...); }

对于C ++ 11,您可以编写一个可以像这样使用的简单实用程序:

    Foo foo(simple_bind(&Main::callback1Handler, this),
            simple_bind(&Main::callback2Handler, this));

这将被定义为这样的函数模板:

template<typename T, typename F>
SimpleBinder<T, F>
simple_bind(F T::* memfn, T* that)
{ return { that, memfn }; }

类型SimpleBinder<T, F>只是:

template<typename T, typename F>
struct SimpleBinder
{
  T* m_this;
  F T::*  m_memfn;

  template<typename... Args>
    void operator()(Args&&... args)
    { (m_this->*m_memfn)(std::forward<Args>(args)...); }
};

这不是完全通用的实用程序(例如,它不会对成员函数的返回类型执行任何操作,始终返回void,但这可以满足您的要求,其中这两个std::function对象都返回void,但它解决了将任意成员函数与this指针相关联,然后用一组参数调用它的问题。

虽然SimpleBind对象似乎接受任何参数,但实际上如果你试图用不与它绑定的成员函数兼容的参数调用它,你会得到一个讨厌的编译器错误。同样,这不是问题,因为您存储它的std::function对象将确保只传递正确类型的参数。