Visual Studio 2012 中的 std::function 目标方法

Question

我有以下代码：

#include <functional>

//...

typedef int (*Myfun)(int);
std::function<int (int)> fn0([](int a)->int {
    return -a;
});
std::cout << "val == " << fn0(3) << std::endl; //"val == -3"
Myfun *fptr = fn0.target<Myfun>(); //fptr is NULL!!
std::cout << "val == " << (*fptr)(3) << std::endl; //Access violation error

实际上，这段代码是来自MSDN 的代码，略有改动：使用 lambda 代替普通函数。

为什么调用fn0.target<Myfun>()返回NULL？

当我声明一个常规函数时

int neg(int val) { 
    return (-val); 
}

然后写std::function<int (int)> fn0(neg);，似乎一切正常，但是 lambda 没有被正确处理。

Answer 1

typedef int (*Myfun)(int); 中的Myfun 类型与函数目标的类型无关，它是执行表达式[](int a)->int { return -a; } 产生的闭包对象的唯一、未命名类型

尝试执行std::cout << fn0.target_type().name() << '\n'; 自己看看。

当你用int neg(int val) { return (-val); } 声明一个函数时，neg 的类型正好是Myfun（在函数到指针的转换之后，发生在std::function<int(int)> fn0(neg)），这就是为什么std::function::target() 能够返回一个指向它的指针。

Answer 2

Cubbi 解释了为什么您的代码不起作用——lambda 不是函数指针。

现在，普通的 lambda 可以转换为函数指针。那么您是否真的想强制进行这种转换？

template<typename F>
struct as_pointer_t {
  F f;
  template<typename R, typename... Args>
  operator type<R(*)(Args...)>() const { return {f}; }
  template<typename R, typename... Args>
  operator std::function<R(Args...)>() const { return (R(*)(Args...))f; }
};
template<typename F>
as_pointer_t<F> as_pointer( F&& f ) { return {std::forward<F>(f)}; }

现在我们可以这样做了：

int main() {
  typedef int (*Myfun)(int);
  std::function<int (int)> fn0(as_pointer([](int a)->int {
    return -a;
  }));
  std::cout << "val == " << fn0(3) << std::endl; //"val == -3"
  Myfun *fptr = fn0.target<Myfun>(); //fptr is no longer NULL!!
  std::cout << "val == " << (*fptr)(3) << std::endl;
}

并且您的代码按预期工作。但是，只有当您的 lambda 没有捕获任何内容时，上述内容才会编译。

如果您的目标是将捕获的 lambda 转换为函数指针，则不能。您可以将状态存储在全局变量中，并在非捕获 lambda 中使用它。您还可以将捕获的 lambda 转换为函数指针和 void* 对。

我编写的代码采用编译时索引将void* 注入列表（以及使用可选类型而不是void*），并生成所述一对void* 和函数指针。一般情况很棘手——具体情况（比如第一个参数）要容易得多。

template<typename T> using type=T;

template<typename F, typename X=void*>
struct callback_t {
  F f;
  operator X() { return X(&f); }
  template<typename R, typename...Args>
  operator type<R(*)(X, Args...)>() const {
    return []( X x, Args... args )->R {
      F* f = (F*)(x);
      return (*f)(std::forward<Args>(args)...);
    };
  }
};
template<typename X=void*, typename F>
callback_t<F,X> make_callback( F f ) {
  return {std::forward<F>(f)};
}

使用：

typedef void(*pfun)(void*, int);
void call_pfun( pfun f, void* p) {
  for (int i = 0; i < 3; ++i)
    f( p, i );
}
int main()
{
  int y = 7;
  auto callback = make_callback([y]( int x ) { std::cout << x+y << "\n"; });
  call_pfun( callback, callback );
}

live example.