模板函数作为模板参数

Question

我只是搞不懂如何在C++中以一种通用的方式实现某种东西。有点复杂，让我一步一步地解释。

考虑这类守则：

void a(int) {
    // do something
}
void b(int) {
    // something else
}


void function1() {
    a(123);
    a(456);
}
void function2() {
    b(123);
    b(456);
}

void test() {
    function1();
    function2();
}

很容易注意到，function1和function2做同样的事情，唯一不同的部分是内部功能。

因此，我想使function成为通用的，以避免代码冗余。我可以使用函数指针或模板来完成它。现在让我选择后者。我的想法是，这是更好的，因为编译器肯定能够内联的函数-我是正确的吗？如果调用是通过函数指针进行的，编译器仍然可以内联吗？，这是一个附带的问题。

好，回到原点.带有模板的解决方案：

void a(int) {
    // do something
}
void b(int) {
    // something else
}

template<void (*param)(int) >
void function() {
    param(123);
    param(456);
}

void test() {
    function<a>();
    function<b>();
}

一切都好。但我遇到了一个问题:如果a和b本身就是泛型，我还能这样做吗？

template<typename T>
void a(T t) {
   // do something
}

template<typename T>
void b(T t) {
   // something else
}

template< ...param... > // ???
void function() {
    param<SomeType>(someobj);
    param<AnotherType>(someotherobj);
}

void test() {
    function<a>();
    function<b>();
}

我知道模板参数可以是以下内容之一：

• a类型，
• a模板类型，
• 类型的值。

这些似乎都不能掩盖我的处境。因此，我的主要问题是:如何解决这个问题，即在最后一个示例中定义function() ？

(是的，函数指针在这种情况下似乎是一种解决办法-前提是它们也可以内联-但我正在寻找这类问题的通用解决方案)。

Answer 1

为了解决模板的这个问题，您必须使用模板参数。不幸的是，您不能将模板函数作为类型传递，因为必须先实例化模板函数。但有一个解决办法与虚拟结构。下面是一个示例：

template <typename T>
struct a {

    static void foo (T = T ())
    {
    }

};

template <typename T>
struct b {

    static void foo (T = T ())
    {
    }

};

struct SomeObj {};
struct SomeOtherObj {};

template <template <typename P> class T>
void function ()
{
    T<SomeObj>::foo ();
    T<SomeOtherObj>::foo ();
}

int main ()
{
    function<a>();
    function<b>();
}

Answer 2

对于来自C++14的通用lambda，您可以这样做：

template<typename T> void a(T t) { /* do something */}
template<typename T> void b(T t) { /* something else */ }

template <typename F>
void function(F&& f) {
    f(someobj);
    f(someotherobj);
}

void test() {
    // For simple cases, auto&& is even probably auto or const auto&
    function([](auto&& t){ a(t); });
    function([](auto&& t){ b(t); });

    // For perfect forwarding
    function([](auto&& t){ a(std::forward<decltype(t)>(t)); });
    function([](auto&& t){ b(std::forward<decltype(t)>(t)); });
}

如果调用是通过函数指针发出的，

编译器仍然可以内联它们吗？

他们可以，但它确实更复杂，他们可能会更频繁地失败比函子或模板。

Answer 3

template < typename F >
void function(F f)
{
  f(123);
}

void a(int x) { ... }

struct b { void operator() (int x) { ... } };

void outer()
{
  function(&a);
  function(b());
}