将带有模板化参数的仿函数传递给模板函数

Question

我正在编写一个以仿函数作为参数的函数。仿函数的调用运算符的参数是模板化的。我正在尝试做的一个非常简化的版本是：

#include <iostream>
#include <functional>
#include <array>

template <const size_t N>
using CVec = std::array<double,N>;

template<const size_t N>
using ode_fun = std::function<CVec<N>(const CVec<N>&)>;

template<const size_t N>
void step( const CVec<N>& x, ode_fun<N> sys)
{
  sys(x);
}

struct foo_t
{
  CVec<2>  operator()( const CVec<2>& x_in)
  {
    CVec<2> xdot;

    std::cout << "x_in: [" << x_in[0] << ", " << x_in[1] << "]\n";

    return xdot;
  }
  CVec<2> x;
};

int main()
{
  foo_t foo;
  foo.x[0] = -.5;
  foo.x[1] = 1.0f;

  CVec<2> x;
  x[0] = 12.0;
  x[1] = 23.2;

  step(x, foo);
}

然而在编译时，我得到这个错误：

temp_arg_subs_fail.cpp: In function ‘int main()’:
temp_arg_subs_fail.cpp:42:14: error: no matching function for call to ‘step(CVec<2>&, foo_t&)’
   step(x, foo);
              ^
temp_arg_subs_fail.cpp:12:6: note: candidate: template<long unsigned int N> void step(CVec<N>&, ode_fun<N>)
 void step( const CVec<N>& x, ode_fun<N> sys)
      ^~~~
temp_arg_subs_fail.cpp:12:6: note:   template argument deduction/substitution failed:
temp_arg_subs_fail.cpp:42:14: note:   ‘foo_t’ is not derived from ‘std::function<std::array<double, N>(const std::array<double, N>&)>’
   step(x, foo);
              ^

然而这有效：

#include <functional>
#include <iostream>

using my_fn = std::function<int(int, int)>;

void summer(int x, int y, my_fn fn)
{
  std::cout << "summer: " << fn(x,y) << std::endl;
}

struct foo_t
{
  int operator()(int x, int y)
  {
    return x + y + z;
  }    
  int z = 0;    
};

int main ()
{    
  foo_t foo;
  foo.z = 5;    

  summer(3,4,foo);

  return 0;
}

基本上，我能说出的两者之间的唯一区别是一个是模板化的，另一个不是。是因为第一个片段中的步骤函数只是一个模板，没有实例化还是其他什么？

Answer 1

问题是 step() 需要一个 ode_fun<N> 对象作为第二个参数（即 std::function<std::array<double, N>(std::array<double, N> const &)>）并且要推导 N。

但是如果你传递 foo，那是一个可以转换为 ode_fun<2> 的 foo_t 对象，但是（这就是重点）不是一个 ode_fun<2> 对象，编译器无法推导出 N 值。

您可以通过两种明显的方式解决问题。

(1) 传递一个 ode_fun<2> 对象给 step()

ode_fun<2>  foo2 { foo };

step(x, foo2);

(2) 或在 step() 中推导一个简单类型 F（如 "functional"），因此所有泛函都是可推导的

template<const size_t N, typename F>
void step( const CVec<N>& x, F sys)
{
  sys(x);
}

Is it because the step function in the first snippet is only a template and not instantiated or something else?

完全正确。

在您的非模板示例中，summer() 收到 std::function<int(int, int)>。

没有什么是可以推导出来的，因此，将一个 foo_t 对象传递给它，该对象不是 std::function<int(int, int)> 但可以转换为它，编译器将 foo 转换为 std::function<int(int, int)>.

将带有模板化参数的仿函数传递给模板函数

Passing functor with templated parameters to template function

templates

functor

c++11

template-argument-deduction

c++14