绑定绑定函数作为参数

Question

我有一个类foo 有一个方法bar，它采用一些可调用的东西（函数指针/函子）。这个可调用的东西应该被传递给另一个方法doit作为绑定元素与第三个方法bar_cb方法。

#include <functional>
#include <iostream>

class foo {
public:
    template<typename T>
    void bar(T&& t) {
        std::cout << "bar\n";
        doit(std::bind(&foo::template bar_cb<T>, this, std::forward<T>(t)));
    }

    template<typename T>
    void doit(T&& t) {
        std::cout << "doit\n";
        t();
    }

    template<typename T>
    void bar_cb(T&& t) {
        std::cout << "bar_cb\n";
        t();
    }
};


void lala() {
    std::cout << "lala\n";
}

class functor {
public:
    void operator()() {
        std::cout << "functor::operator()\n";
    }
};


int main() {
    foo f;
    functor fn;
    f.bar(fn);
    f.bar(std::bind(lala));  // error

    return 0;
}

这适用于functors，但不适用于作为foo::bar 参数的绑定函数（在我的示例中为lala）。是否可以将一个不可知的类型传递给一个方法并在这个方法中将它作为参数绑定到另一个（如果可以的话）？

我知道我可以在函数周围包装一个仿函数（例如std::function），但由于我可以调用一个不可知的类型，我认为还有一种方法可以绑定它（我想我只是缺少一些简单的东西）。

Here 示例链接。

Answer 1

主要问题是您的bar_cb(T&&) 没有推导出模板参数，因为模板参数实际上是在使用&foo::template bar_cb<X> 和一些模板参数X 时指定的。但是，bind() 表达式将复制绑定函数，即它可能具有也可能不具有将被推导的类型。此外，std::bind()不会传递bind()-expression，而是调用它们！

最简单的解决方法是不使用std::bind()来绑定函数，而是使用lambda函数：

template<typename T>
void bar(T&& t) {
    std::cout << "bar\n";
    doit([=](){ this->bar_cb(t); });
}

这样做让编译器推断出bar_cb() 的更正参数类型（对于C++14，您可能希望使用捕获[this,t = std::forward<T>(t)]，尽管您的bar_cb() 仍然看不到右值）。

要通过另一个bind()-表达式传递一个已经bind()-表达式，而不是bind()，考虑内部bind()-表达式一个bind()-表达式，你需要让它看起来好像不是bind()-表达式。你可以用一个瘦函数包装器来做到这一点：

template <typename Fun>
class unbinder {
    Fun fun;
public:
    template <typename F>
    unbinder(F&& fun): fun(std::forward<F>(fun)) {}
    template <typename... Args>
    auto operator()(Args&&... args) const
        -> decltype(fun(std::forward<Args>(args)...)) {
        return fun(std::forward<Args>(args)...);
    }
};
template <typename Fun>
auto unbind(Fun&& fun)
    -> unbinder<Fun> {
    return unbinder<Fun>(std::forward<Fun>(fun));
}

由于bind() 表达式中存储的函数将通过左值传递，因此您需要为您的bar_cb() 声明一个不同的声明，但是：

template<typename T>
void bar_cb(T& t) {
    ...
}

这样，您可以使用

注册bind()-表达式

f.bar(unbind(std::bind(lala)));

如果你想使用f.bar(std::bind(lala))，你需要一个bar()的条件定义：如果它接收到bind()-表达式，它需要通过应用自动隐藏它是bind()-表达式的事实unbind() 或类似的东西：

template<typename T>
typename std::enable_if<!std::is_bind_expression<typename std::decay<T>::type>::value>::type
bar(T&& t) {
    std::cout << "bar (non-bind)\n";
    doit(std::bind(&foo::template bar_cb<T>, this, std::forward<T>(t)));
}
template<typename T>
typename std::enable_if<std::is_bind_expression<typename std::decay<T>::type>::value>::type
bar(T&& t) {
    std::cout << "bar (bind)\n";
    doit(std::bind(&foo::template bar_cb<unbinder<T>>, this, unbind(std::forward<T>(t))));
}