如何实现可接收多模板函数及参数的统一调用类？

我希望实现一个类，它可以接收多个可调用对象（函数指针、lambda、重载operator()的类等），将它们存储在tuple中，然后使用传入的参数调用所有对象（假设每个对象都可被该参数调用）。同时我希望通过模板接口封装，让调用者仅知晓函数所需的参数类型及返回类型（仅bool特化时需要返回类型）。

尝试实现的代码如下：

template<typename Ret, typename... Args>
class MultiCall
{
public:
    virtual void operator()(Args... args_) = 0;
};

template<typename Ret, typename... Args, typename... Fs>
class MultiCallImpl : public MultiCall<Ret, Args...>
{
public:
    MultiCallImpl(Fs... fs_) :
        m_funcs(fs_)
    {
    }

    virtual void operator()(Args... args_) override
    {
        ((std::get<Fs>(m_funcs)(args_...)), ...);
    }

private:
    std::tuple<Fs...> m_funcs;
};

当前问题：如果移除Ret和Args，代码可以正常编译，但保留其中任意一个时，编译器无法推导函数类型，且提示Args位于可变参数模板中间。想知道是否可以修改代码实现需求？

核心问题是模板参数推导规则限制：当模板参数列表中存在多个可变参数包时，编译器无法自动推导靠前的参数包（比如Args...），因为它无法确定参数包的边界。可以通过以下两种方式解决：

方式1：带多态接口的实现（保留基类） #

通过工厂函数分离显式指定的参数（Ret、Args）和自动推导的可调用对象类型，解决参数包推导冲突：

#include <tuple>
#include <utility>
#include <memory>
#include <type_traits>

// 基类：定义统一接口，明确返回值和参数类型
template<typename Ret, typename... Args>
class MultiCall
{
public:
    virtual Ret operator()(Args... args_) = 0;
    virtual ~MultiCall() = default;
};

// 实现类：存储可调用对象并执行调用逻辑
template<typename Ret, typename... Args, typename... Fs>
class MultiCallImpl : public MultiCall<Ret, Args...>
{
public:
    MultiCallImpl(Fs&&... fs_) : m_funcs(std::forward<Fs>(fs_)...) {}

    Ret operator()(Args... args_) override
    {
        // 根据返回值类型分支处理
        if constexpr (std::is_void_v<Ret>)
        {
            // void类型：依次调用所有可调用对象
            ((std::get<Fs>(m_funcs)(std::forward<Args>(args_)...)), ...);
            return;
        }
        else if constexpr (std::is_same_v<Ret, bool>)
        {
            // bool特化：短路逻辑，只要有一个返回false就终止
            return ((std::get<Fs>(m_funcs)(std::forward<Args>(args_)...)) && ...);
        }
        else
        {
            // 其他返回类型：示例为忽略返回值，可根据需求自定义
            ((std::get<Fs>(m_funcs)(std::forward<Args>(args_)...)), ...);
            return Ret{};
        }
    }

private:
    std::tuple<Fs...> m_funcs;
};

// 工厂函数：显式指定Ret和Args，自动推导可调用对象类型
template<typename Ret, typename... Args, typename... Fs>
auto make_multi_call(Fs&&... fs)
{
    return std::make_unique<MultiCallImpl<Ret, Args..., Fs...>>(std::forward<Fs>(fs)...);
}

使用示例：

#include <iostream>

void func1(int a) { std::cout << "func1: " << a << "\n"; }
auto func2 = [](int a) { std::cout << "func2: " << a << "\n"; };

struct Func3 {
    void operator()(int a) { std::cout << "func3: " << a << "\n"; }
};

int main() {
    // void返回类型的多调用器
    auto mc = make_multi_call<void, int>(func1, func2, Func3{});
    (*mc)(42);
    
    // bool返回类型的多调用器（短路逻辑）
    auto mc_bool = make_multi_call<bool, int>(
        [](int a) { return a > 0; },
        [](int a) { return a < 100; }
    );
    std::cout << "bool result: " << (*mc_bool)(42) << "\n";
    return 0;
}

方式2：无多态的轻量实现 #

如果不需要多态接口，可以去掉虚基类，简化模板设计：

#include <tuple>
#include <utility>
#include <type_traits>

template<typename Ret, typename... Args, typename... Fs>
class MultiCall
{
public:
    MultiCall(Fs&&... fs) : m_funcs(std::forward<Fs>(fs)...) {}

    Ret operator()(Args... args_)
    {
        if constexpr (std::is_void_v<Ret>)
        {
            ((std::get<Fs>(m_funcs)(std::forward<Args>(args_)...)), ...);
        }
        else if constexpr (std::is_same_v<Ret, bool>)
        {
            return ((std::get<Fs>(m_funcs)(std::forward<Args>(args_)...)) && ...);
        }
        else
        {
            ((std::get<Fs>(m_funcs)(std::forward<Args>(args_)...)), ...);
            return Ret{};
        }
    }

private:
    std::tuple<Fs...> m_funcs;
};

// 工厂函数辅助推导
template<typename Ret, typename... Args, typename... Fs>
auto make_multi_call(Fs&&... fs)
{
    return MultiCall<Ret, Args..., Fs...>(std::forward<Fs>(fs)...);
}

使用方式与方式1一致，这种实现没有虚函数开销，更轻量。

关键说明 #

1. 工厂函数的作用：通过显式指定Ret和Args，让编译器自动推导可调用对象的类型Fs，避免多个可变参数包的推导冲突。
2. 编译期分支：利用if constexpr在编译期区分不同返回值的逻辑，满足bool特化需求，同时兼容void和其他类型。
3. 完美转发：使用std::forward保证可调用对象的移动/拷贝语义正确，减少不必要的性能损耗。

内容的提问来源于stack exchange，提问作者SavedowW