我正在尝试使用 lambda 代替函数指针传递,但 VS2010 似乎无法转换它。我试过像这样使用 std::function 但它崩溃了,我不知道我这样做是否正确!
#include <windows.h>
#include <conio.h>
#include <functional>
#include <iostream>
#include <concrt.h>
void main()
{
std::function<void(void*)> f = [](void*) -> void
{
std::cout << "Hello\n";
};
Concurrency::CurrentScheduler::ScheduleTask(f.target<void(void*)>(), 0);
getch();
}
令我感到奇怪的是,编译器无法将这样的 lambda 转换为简单的函数指针,因为它不捕获任何变量 - 即使它捕获了变量,我也想知道可以做什么。
每个 lambda 的类型是否唯一?所以我可以修改一个模板函数,使用 lambda 的类型作为模板参数来生成一个唯一的静态函数,该函数可以被调用并有望被优化掉?
已更新
以下似乎可行,但安全吗?
#include <windows.h>
#include <conio.h>
#include <iostream>
#include <concrt.h>
template<typename Signature>
struct Bind
{
static Signature method;
static void Call(void* parameter)
{
method(parameter);
}
};
template<typename Signature>
Signature Bind<Signature>::method;
template<typename Signature>
void ScheduleTask(Signature method)
{
Bind<Signature>::method = method;
Concurrency::CurrentScheduler::ScheduleTask(&Bind<Signature>::Call,0);
}
void main()
{
ScheduleTask
(
[](void*)
{
std::cout << "Hello";
}
);
ScheduleTask
(
[](void*)
{
std::cout << " there!\n";
}
);
getch();
}
再次更新
所以在给予的帮助下我想出了更短的:
template<typename Signature>
void (*LambdaBind(Signature))(void*)
{
struct Detail
{
static void Bind(void* parameter)
{
Signature method;
method(parameter);
}
};
return &Detail::Bind;
}
这可用于将不带 void(*)(void*)
闭包的 lambda 包装到等效的函数指针中。看来在 VS2010 的更高版本中这将变得不必要。
那么如何让它在带闭包的 lambda 中工作呢?
再次更新!
适用于 VS2010 中的闭包 - 虽然不知道它是否“安全”...
template<typename Signature>
struct Detail2
{
static std::function<void(void*)> method;
static void Bind(void* parameter)
{
method(parameter);
}
};
template<typename Signature>
std::function<void(void*)> Detail2<Signature>::method;
template<typename Signature>
void (*LambdaBind2(Signature method))(void*)
{
Detail2<Signature>::method = method;
return &Detail2<Signature>::Bind;
}
最佳答案
This feature of lambda's was added after VS2010 implemented them, so they don't exist in it yet.
这是一个可能的通用解决方法,非常未经测试:
#include <functional>
#include <iostream>
namespace detail
{
// helper specializations,
// define forwarding methods
template <typename Lambda, typename Func>
struct lambda_wrapper;
#define DEFINE_OPERATOR \
typedef decltype(&call) function_type; \
operator function_type(void) const \
{ \
return &call; \
}
template <typename Lambda, typename C, typename R>
struct lambda_wrapper<Lambda, R (C::*)(void) const>
{
static R call(void)
{
Lambda x;
return x();
}
DEFINE_OPERATOR
};
template <typename Lambda, typename C, typename R,
typename A0>
struct lambda_wrapper<Lambda, R (C::*)(A0) const>
{
static R call(A0&& p0)
{
Lambda x;
return x(std::forward<A0>(p0));
}
DEFINE_OPERATOR
};
// and so on
#undef DEFINE_OPERATOR
}
// wraps a lambda and provides
// a way to call it statically
template <typename Lambda>
struct lambda_wrapper :
detail::lambda_wrapper<Lambda, decltype(&Lambda::operator())>
{};
template <typename Lambda>
lambda_wrapper<Lambda> wrap_lambda(const Lambda&)
{
return lambda_wrapper<Lambda>();
}
int main(void)
{
auto l = [](){ std::cout << "im broked :(" << std::endl; };
std::function<void(void)> f = wrap_lambda(l);
f();
}
如果任何部分令人困惑,请告诉我。
关于C++0x Lambda 到 VS 2010 中的函数指针,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/3351280/