初始化在三元运算符中捕获lambda

Question

我想用以下方式创建一个lambda:

auto l1 = condition ?
          [](){ return true; } :
          [number](){ return number == 123; };

但是,我收到了错误:

operands to ?: have different types ‘main()::<lambda()>’ and ‘main()::<lambda()>’

显然,类型似乎是相同的.我想,number只捕获一个lambdas可能是一个问题,但我得到了同样的错误:

//check if capturing number in both lambdas would help
auto l2 = condition ?
          [number](){ return true; } :
          [number](){ return number == 123; };
//maybe the first lambda capture was optimised out? let's make sure:
auto l3 = condition ?
          [number](){ return number != 123; } :
          [number](){ return number == 123; };

我知道我可以通过其他方式(下面)这样做,但我想知道这种行为的原因是什么.它是使用GCC6.3.1编译的,启用了C++ 14.

//compiles      
auto l4 = condition ?
          [](const int){ return true; } :
          [](const int number){ return number == 123; };

Answer 1

每lambda表达式具有独特的类型(即,闭合类型,这是一个独特的无名非工会非聚合类型),即使采用相同的签名和功能体; 编译器只是不能推导出声明的变量的三元条件运算符的公共类型auto,两个闭包类型完全无关.

你可以std::function改用.例如

std::function<bool()> l1;
if (condition)
     l1 = [](){ return true; };
else
     l1 = [number](){ return number == 123; };

因为l4,请注意,带有空捕获列表的lambda表达式可以隐式转换为相应的函数指针.在这种情况下,它们都可以转换为相同的函数指针类型(即bool(*)(int)),然后可以推导出它作为三元条件运算符的常见类型和类型l4.

Answer 2

如果你真的想使用条件运算符,你可以这样做:

auto l1 = condition
          ? std::function<bool()>{[](){ return true; }}
          : std::function<bool()>{[number](){ return number == 123; }};

在C++ 17中,由于类模板参数推导,这可以简化:

auto l1 = condition
          ? std::function{[](){ return true; }}
          : std::function{[number](){ return number == 123; }};

Answer 3

C++ 中的 lambda 是实现函子契约的局部类的实例。我的意思是，operator() 等。这些类是不相关的并且具有不同的类型。

你的代码相当于

struct l1 {
  bool operator () const {
    return true;
  }
};

struct l2 {
  private int number_:
  l2(int number): number_(number){}

  bool operator () const {
    return number_ == 123;
  }
};

int number = ???
auto l3 = condition ? l1 : l2(number);