2

我有一个类，其构造函数定义如下：

LambdaJSONVisitor();
LambdaJSONVisitor(boost::function<void (const Value &)> f);
LambdaJSONVisitor(boost::function<void (const Object &)> f);
LambdaJSONVisitor(boost::function<void (const KeyValuePair &)> f);
LambdaJSONVisitor(boost::function<void (const Array &)> f);

我正在尝试构建一个像这样的对象：

LambdaJSONVisitor setNodeIDVisitor([&](const JSONAPI::Value &val) -> void
{
    ...
});

当我尝试编译它时，我收到以下编译器错误：

4>netmodel\CNetworkAlarmBuilder.cpp(60): error C2668: 'JSONAPI::LambdaJSONVisitor::LambdaJSONVisitor' : ambiguous call to overloaded function
4>          C:\workspace\client\projects\JSONParser\API/LambdaJSONVisitor.h(21): could be 'JSONAPI::LambdaJSONVisitor::LambdaJSONVisitor(boost::function<Signature>)'
4>          with
4>          [
4>              Signature=void (const JSONAPI::Array &)
4>          ]
4>          C:\workspace\client\projects\JSONParser\API/LambdaJSONVisitor.h(20): or       'JSONAPI::LambdaJSONVisitor::LambdaJSONVisitor(boost::function<Signature>)'
4>          with
4>          [
4>              Signature=void (const JSONAPI::KeyValuePair &)
4>          ]
4>          C:\workspace\client\projects\JSONParser\API/LambdaJSONVisitor.h(19): or       'JSONAPI::LambdaJSONVisitor::LambdaJSONVisitor(boost::function<Signature>)'
4>          with
4>          [
4>              Signature=void (const JSONAPI::Object &)
4>          ]
4>          C:\workspace\client\projects\JSONParser\API/LambdaJSONVisitor.h(18): or       'JSONAPI::LambdaJSONVisitor::LambdaJSONVisitor(boost::function<Signature>)'
4>          with
4>          [
4>              Signature=void (const JSONAPI::Value &)
4>          ]
4>          while trying to match the argument list '(`anonymous-namespace'::<lambda1>)'

是否可以将 lambda 作为参数传递给这样的重写构造函数？如果是这样，我做错了什么，我应该如何更改代码以使其工作？我正在使用 Visual Studio 2010。

谢谢

4

2 回答 2

3

只有当有派生类型时它才起作用示例这可以通过创建对象并将其转换为正确的类型来解决，例如

auto lambda = [&](const C&) {};
Func f(static_cast<std::function<void(const C&)>>(lambda));

或不创建对象

Func f(static_cast<std::function<void(const C&)>>(
[&](const C&) {});

例子

于 2013-04-05T09:42:58.353 回答
2

使用一些胶水代码，您可以让编译器找出 lambda 的参数类型并调用相应的构造函数，而无需显式转换。但是，您唯一需要的是至少为您的访问者提供一个移动构造函数。

第一步：制作一个“模板化”的构造函数。我想， LambdaJSONVisitor 不能改变，所以你需要一个辅助函数：

template <class Arg>
LambdaJSONVisitor createLJV_Arg(std::function<void(const Arg&)> f)
{ return LambdaJSONVisitor(f); }

您现在可以通过显式提供模板参数来调用该函数：

LambdaJSONVisitor v = createLJV_Arg<Value>( [](Value const&){} );
                                 // ^-- explicitly state the type

第二步：创建一个模板元编程函数，确定 lambda 的参数类型并将其显式传递给第一个函数。示例可以在这里找到：

template <class F>
LambdaJSONVisitor createLJV(F&& f)
{
   typedef boost::function_types::parameter_types<decltype(&F::operator())>::type args_t;
   typedef boost::mpl::at<args_t, boost::mpl::int_<1>>::type arg1_t;

   return createLJV_Arg<arg1_t>(std::forward<F>(f));
}

然后就

LambdaJSONVisitor v = createLJV( [](Value const&){} );

当然，如果您可以修改LambdaJSONVisitor，则只给它一个模板化构造函数，并在其中进行 lambda 的参数类型推导。

于 2013-04-05T10:21:56.210 回答