为什么我需要在这里指定模板化函数的模板参数类型？

Question

我有以下代码：

template <typename T>
void f1( T t )
{
    std::cout << "f1( " << t << " ) called." << endl;
}

template <typename T>
void f2( T t )
{
    std::cout << "f2( " << t << " ) called." << endl;
}

template <typename F, typename T>
void call( F && f, T t )
{
    f( t );
}

template <typename T>
void foo( T t )
{
    call( f1<T>, t ); // Why is <T> necessary?
                      // f1(t) is a valid expression!
    call( f2<T>, t );
}

void bar()
{
    foo( 1 );
}

在函数foo() 中我需要指定模板参数，即使f1(t) 是一个有效的表达式。这有点破坏我的代码中的一些可能性。我的问题：

1. 为什么需要指定模板参数？
2. 如何解决这个限制？ （允许使用 C++11 或 C++14）。

（顺便说一句：我目前使用的是 Visual Studio 2010，如果我不使用 <T>，则会收到错误 C2896。）

Answer 1

f1 不是函数，而是模板。您不能将模板作为函数参数传递。

f1<T>是一个函数，所以可以传递。

Answer 2

1.为什么我需要指定模板参数？

嗯，f1 不是一个对象，而是一个函数模板。您只能将对象传递给函数。

2。我该如何解决这个限制？ （允许使用 C++11 或 C++14）。

使用带有模板化operator() 的对象。只需将f1() 的定义替换为

struct { template <typename T> void operator()( T t )
{
    std::cout << "f1( " << t << " ) called." << endl;
} } f1;

同样适用于f2()。在 C++14 中你可以写得更好

static const auto f1 = []( auto t )
{
    std::cout << "f1( " << t << " ) called." << endl;
};

Answer 3

您可以尝试将模板函数 f1 和 f2 包装在非模板类中并传递实例（甚至类型），例如

struct F1
{
  template <typename T>
  void operator()(T t) const
  {
    std::cout << "F1::operator()(" << t << ") called" << std::endl;
  }
};

struct F2
{
  template <typename T>
  void operator()(T t) const
  {
    std::cout << "F2::operator()(" << t << ") called" << std::endl;
  }
};

template <typename F, typename T>
void call(F && f, T t)
{
  f(t);
}

template <typename T>
void foo(T t)
{
  static const F1 f1;
  static const F2 f2;
  call(f1, t);
  call(f2, t);
}

void bar()
{
  foo(1);
}

产生输出：

F1::operator()(1) 调用

F2::operator()(1) 调用

Answer 4

f1(t) 不是一个有效的表达式，因为没有函数f1。只有一个名为f1 的模板，可以在编译时从中生成函数f1<T>。

你所说的这个限制是编译时类型检查的直接后果。如果您在编译时知道 foo 的参数类型，则没有限制，因为您不能轻松添加它。如果你不知道参数的类型，你可能不得不使用派生类模型而不是模板驱动的想法。

Answer 5

有一种方法可以模仿传递函数模板（或重载集）作为一等值：通过将它们转换为函数对象来“具体化”它们。你的代码可以这样重写：

struct F1
{
  template <typename T>
  void operator ()( T t )
  {
    std::cout << "f1( " << t << " ) called." << endl;
  }
} f1;

struct F2
{
  template <typename T>
  void operator ()( T t )
  {
    std::cout << "f2( " << t << " ) called." << endl;
  }
} f2;

// Note that this function didn't change at all!
template <typename F, typename T>
void call( F && f, T t )
{
    f( t );
}
// Neither did this, expect that now you don't need the <T>
template <typename T>
void foo( T t )
{
    call( f1, t );
    call( f2, t );
}

void bar()
{
    foo( 1 );
    foo( 3.14 );
    foo( "Hello World" );
}

Answer 6

Angew 和Urzeit 已经给出了为什么它不起作用的解释。

我试图提供的是一种可能的解决方法来解决您的问题。但是，我无法准确判断这是否适合您的情况，因为 OP 提供的有关您的特定设计要求的信息有限。

第一步是将f1 和f2 转换为模板函子类：

template <typename T>
class f1 {
public:
  void operator ()( T t ) {
      std::cout << "f1( " << t << " ) called." << std::endl;
  }
};

（类似f2。）通过这种方式，您可以将f1（而不是f1<T>）作为模板模板参数传递给现在以这种方式定义的call：

template <template <typename> class F, typename T>
void call( T t )
{
    F<T> f;
    f( t );
}

注意F 是一个模板模板参数，它绑定到采用一个模板类型参数的模板类（例如f1）。

最后，foo 变成了这样：

template <typename T>
void foo( T t )
{
    call<f1>( t );
    call<f2>( t );
}

bar 和以前一样。