c++ - SFINAE，如果实现了运算符则调用仿函数

Question

我有一个 std::tuple，它有一堆仿函数，用不同的参数实现回调。我想在编译时遍历元组并执行与参数兼容的仿函数:

假设我有一组仿函数:

struct functor_a { void operator()(const class_x&) {} };
struct functor_b { void operator()(const class_x&) {} void operator()(const class_y&) {} };
struct functor_c { void operator()(const class_x&) {} void operator()(const class_z&) {} };

给定一个包含它们的元组:

using tuple_type = std::tuple<functor_a, functor_b, functor_c>;

我想做这样的事情:

struct executor {

    template<typename message_type, typename... Type>
    static constexpr void exec(std::tuple<Types...>& tup, const message_type& msg) {
        exec(std::index_sequence_for<Types...>(), tup. msg);
    }

    template<typename message_type, std::size_t... Is>
    static void exec(std::index_sequence<Is...>, tuple_type& tup, const message_type& msg) {
        if constexpr (std::is_nothrow_invocable_v<typename std::tuple_element<Is, tuple_type>::type..., message_type>) {
            std::invoke(std::get<Is>(tup)..., msg);
        }
    }
}
};

为了做到这一点(或者使用 std::invoke):

auto tup = get_tuple();
executor::exec(tup, class_x()); // Call functor a, b, c
executor::exec(tup, class_y()); // Call functor b
executor::exec(tup, class_z()); // Call functor c

我在 constexpr 条件方面遇到一些问题，该条件始终被评估为 true，并且代码无法编译，因为它没有找到具有给定参数的运算符:

std::is_nothrow_invocable_v<typename std::tuple_element<Is, tuple_type>::type..., message_type>

Answer 1

您可以结合使用 std::apply、一些通用 lambda 和 fold expressions做一个单一的功能

template <typename Tuple, typename... Args>
constexpr void dispatch(Tuple&& tup, Args const&... args) 
{
    constexpr auto dispatch_helper = [] (auto&& func, auto&&...args)
    {
        if constexpr (std::is_invocable_v<decltype(func), decltype(args)...>)
            std::invoke(std::forward<decltype(func)>(func), std::forward<decltype(args)>(args)...);
    };

    std::apply([&](auto&&... funcs)
    {
        (dispatch_helper(std::forward<decltype(funcs)>(funcs), args...), ...);
    }, std::forward<Tuple>(tup));
}

Here是一个完整的例子。