Question

这就是我目前所拥有的

void test(int& i, float& f) {}

template <class... Ts, class F>
void update(F&& f)
{
  //Use Ts here
}

int main()
{
  update<int, float>(test);
}

但我需要使用<int, float>明确调用update，因为我想将它用于元编程。

如果可以从函数

自动推导出来，那就太好了

void test(int& i, float& f) {}

template <class... Ts>
void update(std::function<void(Ts&...)> f)
{
   //use Ts here
}
int main()
{
  //error: no matching function for call to 'update'
  update(test);
}

Answer 1

只是提供转换过载：

#include <iostream>
#include <functional>

void test(int& i, float& f) {}


template <class... Ts>
void update(std::function<void(Ts&...)> f)
{
    //use Ts here
}

// this overload matches the function pointer and forwards the function
// pointer in a std::function as required
template<class... Ts>
void update(void (*fp)(Ts&...))
{
    update(std::function<void(Ts&...)>(fp));
}

int main()
{
    //error: no matching function for call to 'update'
    update(test);
}

Answer 2

当然你可以：）

考虑一下：

#include <functional>

int test(int& , float& ) { return 0;}
double test2(char* ) { return 0; }

template <class F>
void update(F&& )
{
  typedef typename F::result_type R;
}

template <class R, class... ARGS>
  auto make_function(R (*f)(ARGS...)) {
    return std::function<R (ARGS...)>(f);
}

int main()
{

  update(make_function(&test));
  update(make_function(&test2));
}

Answer 3

当参数是函数指针时，这很容易做到：只需添加此重载：

template <class R, class... Ts>
void update(R (*f)(Ts...)) {
    update(std::function<R(Ts...)>(f));
}

如果你得到任意的东西，就不可能做到：

struct foo {
    template <typename T0, Typename T1>
    void operator()(T0, T1);
};

要推断出哪些论点？

从泛型函数/ lambda中推导出函数参数

3 个答案: