使用通用函数指针参数化函数模板的巧妙方法

Question

考虑以下情况：我有

int bar1();
double bar2();

我想要：

foo<bar1>(); // calls bar1, then uses its result.
foo<bar2>(); // calls bar2, then uses its result.

编写模板foo()的简单方法是使用附加参数：

template <typename T, T (*f)()> void foo () {
  // call f, do something with result
}

这行得通，但我需要做丑陋的语法：

foo<decltype(bar1()), bar1>(); // calls bar1, then uses its result

我想写一些漂亮的东西，就像上面一样，只是foo<bar1>。

附：请不要建议在运行时接受参数。我只需要使用函数指针进行编译时参数化。

附：抱歉忘了提：我正在寻找 C++14 解决方案。 C++17 受到赞赏，我对 C++17 解决方案的答案表示赞同，但项目现在使用 C++14 构建，我无法在最近的将来更改它。

Answer 1

为了得到

foo<bar1>();

你需要来自 C++17 的 template<auto>。看起来像

int bar1() { return 1; }
double bar2() { return 2.0; }

template<auto function> void foo() { std::cout << function() << "\n"; }

int main()
{
    foo<bar1>();
    foo<bar2>();
}

哪些输出

1
2

Live Example

在 C++17 之前你必须指定类型，因为非类型模板参数的类型没有自动推导。

Answer 2

因此，我将尝试给出我在 14 中所知道的最佳答案。基本上，解决此问题的一个好方法（恕我直言）是将函数指针“提升”为 lambda。这允许您以更惯用的方式编写 foo 来接受可调用对象：

template <class F>
void foo(F f);

您仍然可以获得最佳性能，因为 lambda 的类型是唯一的，因此它是内联的。不过，您可以更轻松地将 foo 与其他东西一起使用。所以现在我们必须把我们的函数指针变成一个硬编码的 lambda 来调用它。我们在这方面所能做的最好的事情就是从这个问题中得出的：Function to Lambda。

template <class T>
struct makeLambdaHelper;

template <class R, class ... Args>
struct makeLambdaHelper<R(*)(Args...)>
{
  template <void(*F)(Args...)>
  static auto make() {
    return [] (Args ... args) {
      return F(std::forward<Args>(args)...);
    };
  }
};

我们这样使用它：

auto lam = makeLambdaHelper<decltype(&f)>::make<f>();

为了避免重复提及，我们可以使用宏：

#define FUNC_TO_LAMBDA(f) makeLambdaHelper<decltype(&f)>::make<f>()

你可以这样做：

foo(FUNC_TO_LAMBDA(bar1)); 

现场示例：http://coliru.stacked-crooked.com/a/823c6b6432522b8b

Answer 3

我正在寻找 C++14 解决方案。 C++17 受到赞赏，我对 C++17 解决方案的答案表示赞同，但项目现在使用 C++14 构建，我无法在最近的将来更改它。

不幸的是，您的要求从 C++17 开始有效。

如果你想使用确切的语法

foo<bar1>();

我认为这在 C++14 中是不可能的。

但是，如果您接受稍微不同的语法...我知道宏是邪恶的，但是...如果您接受调用 foo() as

FOO(bar1)();

你可以定义宏

#define FOO(f) foo<decltype(f()), f>

一个完整的工作示例

#include <iostream>

#define FOO(f) foo<decltype(f()), f>

int bar1 ()
 { std::cout << "bar1()" << std::endl; return 0; }

double bar2 ()
 { std::cout << "bar2()" << std::endl; return 1.0; }

template <typename T, T (*f)()>
void foo ()
 { f(); }

int main()
 {
   FOO(bar1)(); // print bar1()
   FOO(bar2)(); // print bar2()
 }

Answer 4

好的，所以您特别要求 bar1 和 bar2 成为函数，但是如果您愿意放宽该约束，而是允许它们成为具有实现所需行为的静态成员函数的类，您可以做以下方式，甚至不需要 C++11 -

struct bar1 {
  static int f() { return 42; }
};

struct bar2 {
  static double f() { return 3.14159; }
};

template<typename bar>
void foo()
{
  double x = bar::f();
  std::cout << x << std::endl;
}

int main(int argc, char* const argv[])
{
  foo<bar1>();
  foo<bar2>();
}

Answer 5

这个怎么样？

template<typename F>
auto foo(F* f)
{
    return f();
}

int bar() { return 1; }

int main()
{
    return foo(bar);
}