Question

前段时间，我遇到了如何将bind返回的一个callable（称之为A）传递给另一个函数（称之为B）的问题，该函数需要一个参数，该参数是指向from的函数的指针。我发现bind返回的可调用A有一个非常复杂的类型，因此放弃了我的方法。

然后我在功能标题中学习了'function'，听起来好像它可以解决我的问题。然而，经过几次尝试，我再次被挫败！也许你可以帮忙吗？以下是一些不起作用的代码：

#include <iostream>
#include <functional>  //Library for "bind" and "function"                                                                                                                                     
#include <cmath>
using namespace std;
using namespace std::placeholders;  //for _1, _2, _3 ...                                                                                                                                       

//praboloid function                                                                                                                                                                           
int parab(int x, int y)  {
  return pow(x,2) + pow(y,2);
}

//Take an integer and a pointer to a function                                                                                                                                                  
int funk(int a, int (*f)(int) )  {
  return (*f)(a);
}

int main()  {
  auto f = bind(parab, _1, 0); // Bind the second value to 0                                                                                                                                  
  function<int (int)> fp = f;

  //Any of the following lines creates and error                                                                                                                                               

  function<int (*)(int)> fp = f; //Error!                                                                                                                                                      
  funk(-5, f);  //Error!                                                                                                                                                                       
  funk(-5, &f); //Error!                                                                                                                                                                       
  funk(-5, fp); //Error!
  funk(-5 &fp); //Error!                                                                                                                                                                   

  return 0;
}

我想做的就是首先使用bind创建一个新的callable，然后将该绑定函数作为参数发送给另一个函数。如果可能的话，我不想处理bind返回的凌乱类型。

我愿意采用其他方法来解决这个问题。

Answer 1

尝试auto f = [](int n) -> int { return parab(n, 0); };

这应该与funk(-5, f)一起使用（因为非捕获闭包可以转换为函数指针）。

bind和function有他们的位置，但他们并不总是最佳选择。

Answer 2

std::function获取int并返回int的类型为std::function<int(int)>而不是std::function<int(*)(int)>。

其次，std::function无法转换为函数指针。如果您想将funk传递给int funk(int a, std::function<int(int)>)，请将std::function的界面更改为template，或将其设为未知类型的[]参数。

第三，如果你使用无状态lambda，那么可以将它传递给一个带有函数指针的函数。无状态lambda是lambda类型，什么都不捕获 - 方括号中没有{{1}}。在这种情况下，绑定表达式可以重写为无状态lambda，因为绑定是编译时已知值。

Answer 3

f不是int (*f)(int)。它是未指定类型的仿函数。但它可以作为一种功能使用。所以只需在funk

中获取任何内容

template<typename F>
int funk(int a, F f)  {
  return f(a);
}

“绑定”和“功能”引发的麻烦

3 个答案: