4

考虑一组函数，例如

template< class Fun >
void A( const Fun& )
{
}

template< class Fun >
void B( const Fun& )
{
}

template< class Fun >
void C( const Fun& )
{
}

旨在将函数类型作为参数。然后，这完全没问题：

template< class T >
void Func( const T& )
{
}

A( Func< int > );
B( Func< int > );
C( Func< int > );

现在我想摆脱重复int模板参数，所以我尝试了这个：

template< class T >
struct Helper
{
  template< template< class > class Fun >
  static void A( Fun< T >& f )
  {
    A( f );
  }

  template< template< class > class Fun >
  static void B( Fun< T >& f )
  {
    B( f );
  }

  ...
};

typedef Helper< int > IntHelper;
IntHelper::A( Func );  //error
IntHelper::B( Func );  //
IntHelper::C( Func );  //

但是这无法在 gcc 4.5.1 ( 'error: no matching function for call to 'Helper<int>::A(<unresolved overloaded function type>)') 和 MSVC10 ( cannot use function template 'void Func(const T &)' as a function argumentand could not deduce template argument for 'overloaded function type' from 'overloaded function type') 上编译。

有人可以确切地解释为什么，有没有办法解决这个问题？

编辑好的我明白为什么现在不可能了；对于包含解决方法的答案：在实际代码中有很多不同Func的 s，比如 100，而只有大约 6 个函数，如 A、B 和 C ......

4

4 回答 4

3

Func是一个函数模板，所以你不能将它作为值传递给函数。

您也不能将其作为模板模板参数传递，因为模板模板参数必须是类模板（而不是函数模板）。

您可以传递包装函数模板的模板模板参数（例如，从静态成员函数返回其实例化）：

template<class T> struct FuncHelper {
    static void (*f())(const T &) { return &(Func<T>); }
};
template<typename T>
struct Helper
{
  template< template< class > class Fun >
  static void A()
  {
    A( Fun<T>::f() );
  }
};
Helper<int>::A<FuncHelper>();
于 2012-07-25T14:28:20.913 回答
3

form template<class> class Fun，无论是作为声明还是作为模板模板参数（就像您拥有的那样），都是为类模板设计的，但Func事实并非如此。这是一个函数模板。那些具有 form template</*parameters*/> Ret foo(/*parameters*/)，并且它们不允许作为模板模板参数。

一般来说，函数模板不能像类模板那样被操纵。

在一种情况下，您可以避免传递模板参数的需要：

// Deduces that Func<int> is meant
void (*p)(int) = Func;

然后你可以传递p给A,B和C。

（同样，如果你有一个函数void f(void(*p)(int));，那么调用表单f(Func)就可以了。）

于 2012-07-25T14:32:43.340 回答
3

虽然可以使用类模板作为模板参数，例如

template <typename> class Foo;

template <template <typename> class C> void doit() { /* ...*/ };

doit<Foo>();

（语义上）不可能使用函数模板作为模板参数（没有“函数模板指针”）。通常的方法是使用函数对象，例如

template <typename T>
struct Func
{
  void operator()(T const &) const
  {
     /* ... */
  }
};


template <typename T>
struct helper
{
  template <template <typename> class F>
  static void A()
  {
    A(F<T>);
  }
  // etc
};

typedef helper<int> int_helper;

int_helper::A<Func>();
于 2012-07-25T14:42:21.953 回答
1

如果Func可以声明为带有auto类型参数的 lambda（使用C++14 的通用 lambdas），则 、 和 的定义A不需要B更改C，并且可以在无需指定参数类型的情况下调用：

auto Func = [](auto const&)
{
};

A(Func);
B(Func);
C(Func);

现场演示

于 2017-12-31T00:26:13.327 回答