Question

我使用以下代码获得了最新版本的clang和gcc的错误：

int main() {
    auto lambda = [] (auto = [] {}) {};
    lambda();
}

Clang给出错误：

prog.cc: In function 'int main()':
prog.cc:3:12: error: no match for call to '(main()::<lambda(auto:1)>) ()'
     lambda();
            ^
prog.cc:2:35: note: candidate: template<class auto:1> main()::<lambda(auto:1)>
     auto lambda = [] (auto = [] {}) {};
                                   ^
prog.cc:2:35: note:   template argument deduction/substitution failed:
prog.cc:3:12: note:   couldn't deduce template parameter 'auto:1'
     lambda();
            ^

为什么这会失败？

Answer 1

auto的类型推导不考虑默认参数。

Answer 2

由于lambdas对于仿函数是 sugar ，问题在于模板函数无法在此默认上下文中推导出模板参数（auto）。

通过考虑这些语句，可以将lambda简化为functor结构级别：

§5.1.2/ 3 [expr.prim.lambda]

lambda-expression的类型（也是闭包对象的类型）是一个唯一的，未命名的非联合类类型[...]

§5.1.2/ 5 [expr.prim.lambda]

[...]对于通用lambda，闭包类型有一个公共内联函数调用操作符成员模板（14.5.2），其template-parameter-list由一个发明类型组成 lambda的parameter-declaration-clause中每次出现auto的template-parameter，按照出现的顺序排列。 [...]

因此，lambda的类型等同于这个函子类型：

struct unnamed
{
    template<typename Auto1>
    auto operator()(Auto1 = []{})
    {
    }
};

然后您的用法相当于：

int main() {
    auto lambda = unnamed();
    lambda();
}

§14.8.2.5/ 5 [temp.deduct.type] 中指定的{（1}}类型无法在此上下文中推断：

未推断的上下文是：

[...]

- 在具有默认参数的函数参数的参数类型中使用的模板参数   在正在进行参数推断的调用中使用。

Answer 3

模板函数（或方法）不会从其默认参数中推断出它们的类型参数，而带有auto参数的闭包只是一个带有模板方法的对象。

这使得模板函数的默认lambda有点烦人。

一种方法是键入erase调用一个对象，而不是存储它，如下所示：

#include <utility>
#include <type_traits>
#include <memory>

template<class Sig>
struct function_view;

template<class R, class...Args>
struct function_view<R(Args...)>{
  void* state;
  R(*f)(void*, Args&&...);

  template<class F, class=std::enable_if_t<std::is_convertible<std::result_of_t<F&(Args...)>,R>{}>>
  function_view( F&& fin ):
    state(const_cast<void*>(static_cast<void*>(std::addressof(fin)))),
    f( [](void* state, Args&&...args)->R{
      F&& f = std::forward<F>(*static_cast<std::decay_t<F>*>(state));
      return f(std::forward<Args>(args)...);
    })
  {}
  function_view( R(*fin)(Args...) ):
    state(fin),
    f( fin?+[](void* state, Args&&...args)->R{
      R(*f)(Args...) = static_cast<R(*)(Args...)>(state);
      return f(std::forward<Args>(args)...);
    }:nullptr)
  {}
  explicit operator bool(){return f;}
  function_view():state(nullptr),f(nullptr){}
  function_view(std::nullptr_t):function_view(){}
  R operator()(Args...args)const{
    return f(state, std::forward<Args>(args)...);
  }
};
template<class...Args>
struct function_view<void(Args...)>{
  void* state;
  void(*f)(void*, Args&&...);

  template<class F, class=std::result_of_t<F&(Args...)>>
  function_view( F&& fin ):
    state(const_cast<void*>(static_cast<void*>(std::addressof(fin)))),
    f( [](void* state, Args&&...args){
      F&& f = std::forward<F>(*static_cast<std::decay_t<F>*>(state));
      f(std::forward<Args>(args)...);
    })
  {}
  function_view( void(*fin)(Args...) ):
    state(fin),
    f( fin?+[](void* state, Args&&...args){
      void(*f)(Args...) = static_cast<void(*)(Args...)>(state);
      f(std::forward<Args>(args)...);
    }:nullptr)
  {}

  explicit operator bool(){return f;}
  function_view():state(nullptr),f(nullptr){}
  function_view(std::nullptr_t):function_view(){}
  void operator()(Args...args)const{
    f(state, std::forward<Args>(args)...);
  }
};

int main() {
  auto f = [] (function_view<void()> x=[]{}) {
    x();
  };
  f();
}

由于这只适用于函数指针，并且我对gcc内联简单函数指针有很好的经验，因此它可能没有std::function那么高的性能影响。与std::function不同，不涉及虚拟表或堆分配。

live example

对于非lambda，你可以这样做：

template<class X=function_view<void()>>
void f( X&& x=[]{} ) {
  x();
}

如果你通过则推断是一个参数，并且如果你没有，则成为一个无功能。你也可以这样做：

struct do_nothing {
  template<class...Args>
  void operator()(Args&&...)const{}
};

template<class X=do_nothing>
void f( X&& x=do_nothing{} ) {
  x();
}

可能更容易优化。

Lambda作为默认参数失败

3 个答案: