C++17：将多个可调用对象及其参数一起传递

Question

我想要编写一个函数（如果相关的话，使用C++17标准），它可以接受多个可调用对象及其参数，并在一个循环中执行它们。同时，我希望避免任何中间数据复制。

例如：

假设我们有三个函数 f0、f1 和 f2，它们需要不同数量的输入参数：

void f0() {
    // f0 的实现
}
void f1(int a) { 
    // f1 的实现
}
void f2(int a, int b) {
    // f2 的实现
}

我正在寻找一种方法，将上述所有函数以及示例输入参数一起传递给一个类或另一个函数（比如 Execute）。一个示例接口可能如下所示：

int main() {
    // 如果 Execute 是一个类
    Execute exec({f0}, {f1, 4}, {f2, 1, 2});

    // 上述代码的结果是一系列函数调用
    // 1. f0()
    // 2. f1(4)
    // 3. f2(1, 2)
}

我的问题是：如何才能实现这个目标并避免任何中间数据复制？

OMG Ponies · Answer

以下是根据您的建议实现的一个使用 std::tuple 的模板类工作示例：

#include 
#include 
#include 
#include 

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

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

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

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

// 移除元组第一个元素并将剩余元素重新打包成新元组
template 
std::tuple unshift_tuple(const std::tuple& tuple)
noexcept
{
    return std::apply(
        [](auto&&, const auto&... args) {
            return std::tie(args...);
        },
        tuple
    );
}

// 使用元组中的元素作为参数调用可调用对象
template 
void call(const std::tuple& t) noexcept {
    const auto& f = std::get<0>(t); 
    const auto args = unshift_tuple(t);
    std::apply(f, args);
}

// 执行器类，接受多个函数及参数
template 
class Execute {
public:
    Execute(std::tuple&& t) : m_fs(std::move(t)) { }
    
    void execute() noexcept {
        iterate_over_functions<0>(m_fs);
    }
    
private:
    // 递归调用函数
    template 
    void iterate_over_functions(const std::tuple& t) noexcept {
        if constexpr (I < sizeof...(Ts)) {
            call(std::get(t));
            iterate_over_functions(t);
        }
    }
    
private:
    std::tuple m_fs;
};

int main() {
    Execute e(
        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)
        )
    );
    
    e.execute();
}

注意：为了从元组中获取参数并使用 std::apply 调用函数，需要了解如何移除元组的第一个元素并将剩余元素重新打包成新元组。这个解决方案中，您正确地实现了这一点，并创建了一个能够按照指定顺序执行多个函数的 Execute 类。

laurent · Answer

您提出的解决方案如下：

#include 
#include 

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;
}

// 模板函数execute，用于执行传入的可调用对象及其参数
template 
void execute(Tuples&&... tuples) {
  (std::apply(std::get<0>(tuples), std::get<1>(tuples)), ...);
}

int main() {
  execute(
      std::forward_as_tuple(f0, std::make_tuple()), // 创建包含f0和空元组的元组
      std::forward_as_tuple(f1, std::make_tuple(1)), // 创建包含f1和单个参数的元组
      std::forward_as_tuple(f2, std::make_tuple(3, 4))); // 创建包含f2和两个参数的元组
}

这个解决方案是有效的，但需要对传入的参数进行一些调整以使其正常工作。在 main 函数中，当向 execute 函数传递参数时，需要使用 std::make_tuple 来创建包含实际参数值的元组，而不是直接传递 std::forward_as_tuple()。因此，应修改为：

int main() {
  execute(
      std::forward_as_tuple(f0, std::make_tuple()), // 现在包含一个空参数元组
      std::forward_as_tuple(f1, std::make_tuple(1)), // 正确包含f1的参数
      std::forward_as_tuple(f2, std::make_tuple(3, 4))); // 正确包含f2的参数
}

jgauffin · Answer

为了提供一个更简洁的解决方案，您可以使用C++17的折叠表达式（fold expression）来直接执行一系列lambda表达式或者通过std::bind绑定后的函数对象：

#include 

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

int main()
{
    int a = 42, b = 0;
    // 使用lambda表达式封装函数调用
    execute([&]() { f0(); }, [&]() { f1(a); }, [&]() { f2(a, b); });

    // 或者使用std::bind绑定函数参数
    execute(std::bind(f0), std::bind(f1, a), std::bind(f2, a, b));
}