如何存储和调用可变参数函数和值向量？

Question

在Python中，可以存储具有不同数量参数的函数指针，并将参数存储在列表中，然后解压列表并调用该函数，如下所示：

\n

def Func(x1, x2):\n   return x1+x2\nArgList = [1.2, 3.22]\nMyClass.Store(Func)\nMyClass.FuncPtr(*ArgList)\n

\n

在c++中是否可以做类似的事情？

\n

例如，将具有可变数量的输入和值的函数存储在 a 中，std::vector并通过该向量调用函数指针？

\n

我不想将参数列表定义为向量。

\n

Answer 1

在c++中是否可以做类似的事情？

如果您在编译时知道参数（类型），当然可以！

例如，类似于/类似于@Evg建议的内容，将其设为Funcvariadic -generic-lambda ，并在c++17的支持下std::apply（对于未来的读者），您可以这样做。

（参见演示）

#include <iostream>
#include <utility> // std::forward
#include <tuple>   // std::apply

constexpr auto func_lambda = [](auto&&... args) {
     return (std::forward<decltype(args)>(args) + ...); // fold expression
};

int main() 
{
   std::cout << std::apply(func_lambda, std::make_tuple(1, 2, 3));  // prints 6!
   return 0;
}

现在，根据您的python演示代码，您可以将上述想法打包到类模板中。在这里，您可以避免使用std::function，因为Func将会是您传递的 lambda ，并且可以存储为编译器推导的 lambda unspecified type。

（参见在线演示）

#include <iostream>
#include <utility> // std::forward
#include <tuple>   //std::apply, std::make_tuple

// `Func` as variadic-generic-lambda
constexpr auto func_lambda = [](auto&&... args) noexcept {
   return (std::forward<decltype(args)>(args) + ...);
};

template<typename Func>
class MyClass final
{
   Func mFunction;
public:
   explicit MyClass(Func func)  // Store: pass the lambda here!
      : mFunction{ func }
   {}

   template<typename... Args>  // to execute the `Func` with `Args`! 
   constexpr auto execute(Args&&... args) const noexcept
   { 
      return std::apply(mFunction, std::make_tuple(std::forward<Args>(args)...));
   }
};

int main() 
{
   MyClass myClass{ func_lambda };         // MyClass.Store(Func)
   std::cout << myClass.execute(1.2, 2.82, 3);  // MyClass.FuncPtr(*ArgList)
   return 0;
}

输出：

7.02