递归 lambda 返回时的 gcc 4.9 内部编译器错误

Question

我有一小段代码可以在 clang repo head (3.5) 中编译，但在 gcc 4.9 repo head 中编译得不好。虽然这看起来像一个 gcc 错误，但在向 bugzilla 发送垃圾邮件之前，我想问你是否

1. 这是有效的 c++1y 代码（处于当前草稿状态） - 仅仅因为 clang 编译它，它没有理由成为正确的代码，并且
2. 如果有人可以重现此错误。

使用clang编译运行sn-p的代码在这里：

http://coliru.stacked-crooked.com/a/acc691b9a407d6f2

但是使用

g++-4.9 -o main main.cpp -std=c++1y

给我前面提到的内部编译器错误：http://pastebin.com/3fqV7xzC

没有它读取的长转储：

g++-4.9 -o main main.cpp -std=c++1y main.cpp: 在'composer::operator()(Func&&, Funcs&& ...):: [with auto:2 = float; Func = main(int, const char*)::; Funcs = {main(int, const char*)::}]': main.cpp:33:88: 从这里需要

main.cpp:19:41: internal compiler error: in retrieve_specialization, at cp/pt.c:1042
    return f(c(std::forward<Funcs>(fs)...)(v));
                                         ^

为了完整起见，这里是 sn-p（完整的 main.cpp）

#include <iostream>
#include <utility>

template <typename... Funcs>
struct composer;

template <>
struct composer<> {
    auto operator()() {
        return [&] (auto v) { return v; };
    }
};

template <typename Func, typename... Funcs>
struct composer<Func, Funcs...> {
    auto operator()(Func&& f, Funcs&&... fs) {
        composer<Funcs...> c;
        return [&] (auto v) {
            return f(c(std::forward<Funcs>(fs)...)(v));
        };
    }
};

template <typename... Funcs>
auto compose(Funcs&&... fs) {
    composer<Funcs...> c;
    return c(std::forward<Funcs>(fs)...);
}


int main (int argc, char const* argv[]) {
    float v = 3.5f;
    auto t = compose([] (auto v) { return v >= 3; }, [] (auto v) { return int(v-0.5); })(v);
    std::cout << std::boolalpha << t << "\n";
    auto f = compose([] (auto v) { return v > 3; }, [] (auto v) { return int(v-0.5); })(v);
    std::cout << std::boolalpha << f << "\n";
}

编辑：奖金！我根本不喜欢该代码 - 如果有人有更好且可能更快的方法来执行此操作，请考虑启发我...

编辑 2 有谁知道如何让 coliru（或类似服务）使用 g++ 4.9？

Answer 1

您的代码不是有效的 C++1y，至少在执行时不是。

您通过引用捕获变量，然后退出定义它们的范围，然后调用使用所述变量的 lambda。

现在，c 的状态从未使用过，但 operator() 调用仍然是 UB。

同样，虽然您的引用是对超出当前范围的数据的引用，但不能保证捕获的是原始变量而不是本地引用。实现本地捕获的一种方法是捕获指向本地堆栈帧的指针，并通过所述堆栈帧的编译时静态偏移量访问变量：当您退出堆栈帧时，这样的读取会产生垃圾。 （这会将[&] lambda 的大小减少到单个指针，这是一个非常好的优化！在某些机器上，通过指针的偏移量访问数据很快。）

一般来说，如果您的闭包（或其副本）将超过当前范围，请不要通过引用（尤其是通过全局引用）捕获。 return 语句上的按全局引用捕获确实应该生成警告。

修复该 UB，您的代码看起来有效。在 C++1y 中，您可以通过-move 或 -forward 捕获。

如果没有 C++1y 编译器，这里是一个尝试：

#include <iostream>
auto compose() {
  return [](auto&& x) { return std::forward<decltype(x)>(x); };
}

template<typename F>
auto compose( F&& f ) {
  return std::forward<F>(f);
}

template<typename F1, typename F2>
auto compose( F1&& f1, F2&& f2 ) {
  return [lhs = std::forward<F1>(f1), rhs = std::forward<F2>(f2)]( auto&& x ) {
    return lhs( rhs( std::forward<decltype(x)>(x) ) );
  };
}

template<typename F0, typename... Fs>
auto compose( F0&& f0, Fs&&... fs ) {
  static_assert( sizeof...(Fs) > 1, "other overrides should have handled this case!  What went wrong?" );
  return compose(
    std::forward<F0>(f0),
    compose(
      std::forward<Fs>(fs)...
    )
  );
}

int main() {
  auto a = compose( [](bool b){return !b;}, [](double d){ return d<3.0; } );
  std::cout << a(2.0) << "," << a(3.0) << "\n";
  return 0;
}

它也恰好是非 lambda 类型的。