C++ 是否将任何函数作为模板参数传递？

我正在寻找一种将泛型（显然是constexpr）函数传递给模板的方法。它必须能够在不使用lambda的情况下获取任意数量的参数。这就是我到目前为止所做的：

template<typename T, T(*FUNC)()> struct CALL
{
    static inline constexpr decltype(FUNC()) EXEC()
    {
        return FUNC();
    }
};

模板结构调用
{
静态内联constexpr decltype（FUNC（））EXEC（）
{
返回FUNC（）；
}
};

但是，这仅在传递的函数不带参数时有效。有没有办法让模板接受任何constexpr函数？传递std:：函数似乎不起作用。

---

我想关键是可变模板参数，但我不知道在这种情况下如何利用它们

如果我正确理解您试图实现的目标，您可以使用模板函数而不是带有静态函数的模板类：

#include <iostream>

template<typename T, typename... Ts>
constexpr auto CALL(T (*FUNC)(Ts...), Ts&&... args) -> decltype(FUNC(args...))
{
    return FUNC(std::forward<Ts>(args)...);
}

constexpr double sum(double x, double y)
{
    return (x + y);
}

int main()
{
    constexpr double result = CALL(sum, 3.0, 4.0);
    static_assert((result == 7.0), "Error!");
    return 0;
}

#包括
模板
constexpr自动调用（T（*FUNC）（Ts…），Ts&&…args）->decltype（FUNC（args…）
{
返回函数（std:：forward（args）…）；
}
constexpr双和（双x，双y）
{
返回（x+y）；
}
int main（）
{
constexpr double result=调用（sum，3.0，4.0）；
静态断言（（结果==7.0），“错误！”）；
返回0；
}

为什么要挂断

constexpr

？为什么您认为它是相关的/必要的？您不可能允许调用者传入任何函数并期望您的代码对它做任何有用的事情。必须有一些限制。您准备好调用需要20个参数的函数了吗？需要特定于平台的数据类型的函数如何？你所问的问题比它所解决的问题还要多。@为什么不呢？我所要做的就是将参数也传递给模板。我只是不知道怎么做。@ildjarn你说的“挂断”是什么意思？@cyberpunk:ildjarn问为什么

constexpr

与你的问题相关。@cyberpunk:你想在编译时调用该函数吗？您将函数指针作为非类型模板参数传递，因此指针在编译时已经可用，因此不需要

constepr

。它仍将在运行时调用。但是，您认为这对什么场景有用？我感觉你在问一个可能的解决方案，而不是你的实际问题。谢谢，但我真的需要使用constepxr函数吗？这背后的全部思想是强制在编译时对constexpr函数求值。我之所以使用模板类，是因为模板必须在编译时求值，而constexpr函数也可以在运行时调用。那么，有没有一种方法可以只使用模板类来实现您的解决方案呢？当您说模板必须在编译时“评估”时，我认为您有点混淆了。模板在编译时被“实例化”，这是不同的。在实例化过程中不会执行任何代码，只有generated@cyberpunk_：是的，如果你想执行编译时代码（=计算），你必须使用constexpr函数。@AndyProwl我知道他想实现什么，不是这样，他希望将模板非类型参数作为参数传递给一个函数，该函数的返回在获取它之前会传递给一个constexpr，所有这些都是为了强制constexpr函数的编译时代码执行（=求值），而不是通过初始化一个带有函数返回的constexpr变量来执行。他在追根究底=D@chico：我相信你，但我也不明白你的解释：）无论如何，我的观点是，在模板实例化过程中，没有代码被执行，甚至没有

constepr

函数的代码。模板元编程确实允许以代码生成的形式（更确切地说是在过程中）进行一些计算，但这就像另一种语言，更类似于函数式编程而不是常规过程式编程。在任何情况下，它都不会执行作为模板参数传入的任何函数体，甚至不会执行

constepr

函数体

template<int... I>
struct with
{
    template<int F(decltype(I)...)>
    struct call
    {
        static constexpr int value = F(I...);
    };
};

constexpr int f(int i) {return i;}
constexpr int g(int i, int j) {return i + j;}

int main()
{
    int u = with<0>::call<f>::value;
    constexpr int v = with<0, 1>::call<g>::value;
}

#include <iostream>

template<typename T, T... v>
struct with
{
    template<typename R, R f(decltype(v)...)>
    struct call
    {
        static constexpr R value = f(v...);
    };
};

#define AT_COMPILATION(f, x, ...) with<decltype(x), x, ##__VA_ARGS__>::call<decltype(f(x, ##__VA_ARGS__)), f>::value

constexpr long f(long i) {return i;}
constexpr double g(int i, int j) {return static_cast<double>(i) / j;}

int main()
{
    constexpr double u = with<long, 0L>::call<decltype(f(0L)), f>::value;

    std::cout << with<int, 5, 2>::call<double, g>::value << std::endl;

    constexpr double v = AT_COMPILATION(f, 0L);

    std::cout << AT_COMPILATION(g, 5, 2) << std::endl;
}