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

Question

说我有

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)，这主要是明确指定这些占位符的丑陋之处。

将 lambda 用作 [=](std::string str){callbackNHandler(str);} 也很丑陋，因为您必须指定回调接受的每个变量。

如果我可以只使用 &Main::callback1Handler 就好了，就像在 Main 类示例中一样，或者 &Main::callback1Handler，this，这更灵活一些，因为您可以指定 Main 的实例指针。

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

Answer 1

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)...);
  };
}

和第一个一样简短，和第二个一样强大。