为什么非捕获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的类型作为模板传递（将其转换为合适的std:：function（在失去多态性的情况下–但是C lambda无论如何都不是参数多态的）），但是我有一个应用程序，我更希望不必将其值传递给构造函数（因为我想使用我的类的初始化本身作为模板参数，其中需要一个特定的构造函数签名）

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有一个已删除的默认构造函数。这对于捕获lambda来说当然是不可避免的，但是对于像我的示例中这样的简单对象，这对我来说没有多大意义：它们不需要引用任何局部变量。

是否有其他方法获得此功能，或者我是否必须将lambda old时髦地定义为命名类？

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

（当然，我想使用的lambda函数没有x那么简单→ x²，因此仅从几个标准函数类中进行选择是不够灵活的）

Answer 1

本杰明已经为你的案子提出了一个很好的解决办法。你可以用这个。

我的解决方案只是Benjamin答案的一个改进版本，您不必指定lambda参数类型。因此，与其写这封信：

make_selfCompose<int>(f)(4); //Benjamin's solution

你可以这样写：

make_selfCompose(f)(4); //improved - absence `int` template argument.

让make_selfCompose推导lambda参数类型本身。

对于此解决方案，让我们先编写函数\u traits类模板，如下所示：

#include <tuple>

template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())>
{};

template <typename C, typename R, typename... A>
struct function_traits<R(C::*)(A...) const>
{
   template <size_t i>
   struct arg
   {
      typedef typename std::tuple_element<i, std::tuple<A...>>::type type;
   };
};

然后这里是make_selfCompose的改进版本：

template<typename Fun> //<--- now it has one template parameter
selfCompose<typename function_traits<Fun>::template arg<0>::type, Fun>
make_selfCompose(Fun f)
{
  typedef typename function_traits<Fun>::template arg<0>::type InArg; //deduce it
  return selfCompose<InArg, decltype(f)>(f);
}

以下是测试程序：

int main() {
  auto f = [](int x){return x*x;};
  std::cout << make_selfCompose(f)(4)  //notice the relief here!
            << std::endl;
  return 0;
}

查看在线演示

希望有帮助。：-）

Answer 2

如果将selfCompose设置为多态，则无需显式传递参数类型或检查存储的函子类型。后者意味着它还能够处理多态函子。

template<typename Functor>
struct self_compose_type {
    // Omitting encapsulation for brevity
    Functor functor;

    // It is possible to overload operator() to deal
    // with all cv and ref qualifiers combinations
    template<typename... T>
    auto operator()(T&&... t)
    // Don't use std::result_of for the return type
    -> decltype( std::declval<Functor&>()(std::declval<T>()...) )
    { return functor(std::forward<T>(t)...); }
};

template<typename Functor>
self_compose_type<Functor>
self_compose(Functor&& functor)
{ return { std::forward<Functor>(functor) }; }

// C++03 style:
template<typename Functor>
self_compose_type<typename std::decay<Functor>::type>
make_self_compose(Functor&& functor)
{ return { std::forward<Functor>(functor) }; }

无需将运算符（）设为变量，如果愿意，可以将其设为只接受一个参数。

Answer 3

您可以遵循像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;
}