c++ - 为什么非捕获 lambda 不能默认构造，是否可以解决这个问题？

Question

可以使用 lambda 的类型作为模板参数，例如

template<typename InArg, typename Function>
class selfCompose {
  Function f;
 public:
  selfCompose(Function f): f(f) {}
  auto operator() (InArg x) -> decltype(f(f(x))) {
    return f(f(x));                              }
};

int main() {
  auto f = [](int x){return x*x;};
  std::cout << selfCompose<int, decltype(f)>(f)(4)  //  yields (4²)² = 256
            << std::endl;
  return 0;
}

但是，f 的这种双重使用有点多余。我们可以省略将 lambda 的 type 作为模板传递(将其转换为合适的 std::function (失去多态性——但 C++ lambda 无论如何都不是参数多态的) )，但是我有一个应用程序，我更希望不必将它的 value 传递给构造函数(因为我想使用我的类的初始化本身作为模板参数，其中一个特定的构造函数需要签名)。我希望它像这样工作

template<class InArg, class Function>
class selfCompose {
  Function f;
 public:
  selfCompose() {}  // default constructor for f
  auto operator() (InArg x) -> decltype(f(f(x))) {
    return f(f(x));                              }
};

int main() {
  auto f = [](int x){return x*x;};
  std::cout << selfCompose<int, decltype(f)>()(4) << std::endl;
  return 0;
}

但这不能编译，因为 lambda 有一个删除的默认构造函数。这对于 捕获 lambdas 来说当然是不可避免的，但是对于像我示例中的简单的 lambdas，这对我来说没有多大意义:它们不需要引用任何局部变量。

有没有其他方法可以获得此功能，还是我必须求助于将 lambda 定义为命名类的老式方式？

struct myFun {
  auto operator() (int x) -> int {return x*x;}
};

(当然，我想使用的 lambda 函数相当不像 x → x² 这样简单，所以只需从几个标准函数类中选择不够灵活)

Answer 1

您可以按照 make_pair 和 make_shared 等函数的示例:

template<typename InArg, typename Function>
selfCompose<InArg, Function> make_selfCompose(Function f)
{
  return selfCompose<InArg, decltype(f)>(f);
}

int main() {
  auto f = [](int x){return x*x;};
  std::cout << make_selfCompose<int>(f)(4)
            << std::endl;
  return 0;
}