我可以使用 std::bind* 编写函数吗？

Question

我正在使用 C++20 进行函数式编程并编写类似的内容：

template <class OuterFn, class InnerFn, class... Args>
concept Composable =
    std::invocable<OuterFn, std::invoke_result_t<InnerFn, Args...>>;

template <class OuterFn, class InnerFn>
constexpr auto
compose(OuterFn&& outer, InnerFn&& inner)
{
    return [
        out = std::forward<OuterFn>(outer),
        in = std::forward<InnerFn>(inner)
    ]<class... Args>(Args && ... args)
        requires Composable<OuterFn, InnerFn, Args...>
    {
        using std::invoke, std::forward;
        return invoke(out, invoke(in, forward<Args>(args)...));
    };
}

template <class OuterFn, class InnerFn>
constexpr auto
operator*(OuterFn&& outer, InnerFn&& inner)
{
    using std::forward;
    return compose(forward<OuterFn>(outer), forward<InnerFn>(inner));
}

template <class... RestFn>
constexpr auto
compose(RestFn&&... rest)
{
    return (std::forward<RestFn>(rest) * ...);
}

这是工作，但我想通过使用 std::bind* 而不是 lambda 来重构两个参数的 compose。 也许您有想法我该如何做到这一点，或者我不能这样做的原因？

问题是如何检索内部函数的参数。

std::bind(outer, std::bind_front(inner));

我通过类比尝试了可变参数模板参数（以及数百万个其他变体）

std::bind(outer, std::bind(inner, _1));

对于一个论点，但它不起作用。

附注对不起我的英语）

Answer 1

当您提供代码时，似乎可以按照您的要求进行操作。 这是您要求的示例（如果我理解正确的话）：

#include <functional>
using namespace std::placeholders;

double mulF(const double x, const double y) { return x * y; }
double addTen(const double x) { return x + 10; }

int main() {
    static const std::function<double(const double, const double)> mulCb = std::bind(mulF, _1, _2);
    static const std::function<double(const double)> addTenCb = std::bind(addTen, _1);

    const std::function<double(const double, const double)> composed = std::bind(addTenCb, std::bind(mulCb, _1, _2)); // together as you asked

    std::cout << "Output: " << composed(5, 3) << std::endl; // Output 25 (5 * 3 + 10).

    return 0;
}