为了完整起见，这里有一个零努力的解决方案。

template <typename... T> 
void execute (T&&... t)
{
    (t(),...);
}

int main()
{
    int a = 42, b = 0;
    // this
    execute([&](){f0();}, [&](){f1(a);}, [&](){f2(a,b);});
    // or this
    execute(std::bind(f0), std::bind(f1, a), std::bind(f2, a, b));
}

字符串

我提出了以下解决方案。谁能告诉我这是否有效？

#include <tuple>
#include <iostream>

void f0() {
  std::cout << "f0:" << std::endl;
}

void f1(int a) {
  std::cout << "f1: " << a << std::endl;
}

void f2(int a, int b) {
  std::cout << "f2: " << a << "," << b << std::endl;
}

template <typename... Tuples>
void execute(Tuples &&... tuples) {
  (std::apply(std::get<0>(tuples), std::get<1>(tuples)), ...);
}

int main() {
  execute(std::forward_as_tuple(f0, std::forward_as_tuple()),
          std::forward_as_tuple(f1, std::forward_as_tuple(1)),
          std::forward_as_tuple(f2, std::forward_as_tuple(3, 4)));
}

字符串

这里有一个工作解决方案，它使用std::tuple实现了一个模板化的类，它模仿了您的建议。

#include <iostream>
#include <utility>
#include <vector>
#include <tuple>

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

void f1(int a) {
    std::cout << "f1: " << a << '\n';
}

void f2(int a, int b) {
    std::cout << "f2: " << a + b << '\n';
}

void f3(const std::string a, int b) {
    std::cout << "f3: " << a << " ** " << b << '\n';
}

template <typename T1, typename... Ts>
std::tuple<Ts...> unshift_tuple(const std::tuple<T1, Ts...>& tuple)
noexcept
{
    return std::apply(
        [](auto&&, const auto&... args) {
            return std::tie(args...);
        },
        tuple
    );
}

template <typename Callable, typename... Params>
void call(const std::tuple<Callable, Params...>& t) noexcept {
    const auto f = std::get<0>(t); 
    const auto args = unshift_tuple(t);
    std::apply(f, args);
}

template <typename... Params>
class Execute {
public:
    Execute(std::tuple<Params...>&& t) : m_fs(t) { }
    
    void execute() noexcept {
        iterate_over_functions<0>(m_fs);
    }
    
private:
    template <std::size_t I, typename... Ts>
    void iterate_over_functions(const std::tuple<Ts...>& t) noexcept {
        if constexpr (I < sizeof...(Ts)) {
            call(std::get<I>(t));
            iterate_over_functions<I + 1>(t);
        }
    }
    
private:
    std::tuple<Params...> m_fs;
};

int main() {
    Execute f(
        std::make_tuple(
            std::make_tuple(f0),
            std::make_tuple(f1, 1),
            std::make_tuple(f2, 1, 2),
            std::make_tuple(f3, "Stack Overflow!", 2)
        )
    );
    
    f.execute();
}

字符串
注意：我需要remember如何取消元组的移位，并使用std::apply调用一个函数，该函数使用std::tuple中的值作为参数。