将 SFINAE 与通用 lambda 一起使用

Question

通用 lambda 可以利用 “替换失败不是错误” 规则吗？示例

auto gL = 
    [](auto&& func, auto&& param1, auto&&... params) 
        -> enable_if_t< is_integral<
            std::decay_t<decltype(param1)>
        >::value>
    {
        // ...
    };

auto gL =  
     [](auto&& func, auto&& param1, auto&&... params) 
        -> enable_if_t< !is_integral<
            std::decay_t<decltype(param1)>
        >::value>
    {
        // ...
    };

是否有任何解决方法或计划将其包含在语言中？此外，由于通用 lambda 是底层的模板化函数对象，这不能完成是不是有点奇怪？

Answer 1

Lambda 是底层的函数对象。泛型 lambda 是带有模板 operator()s 的函数对象。

template<class...Fs>
struct funcs_t{};

template<class F0, class...Fs>
struct funcs_t<F0, Fs...>: F0, funcs_t<Fs...> {
  funcs_t(F0 f0, Fs... fs):
    F0(std::move(f0)),
    funcs_t<Fs...>(std::move(fs)...)
  {}
  using F0::operator();
  using funcs_t<Fs...>::operator();
};
template<class F>
struct funcs_t<F>:F {
  funcs_t(F f):F(std::move(f)){};
  using F::operator();
};
template<class...Fs>
funcs_t< std::decay_t<Fs>... > funcs(Fs&&...fs) {
  return {std::forward<Fs>(fs)...};
}

auto f_all = funcs( f1, f2 ) 生成的对象是 f1 和 f2 的重载。

auto g_integral = 
  [](auto&& func, auto&& param1, auto&&... params) 
    -> std::enable_if_t< std::is_integral<
        std::decay_t<decltype(param1)>
    >{}>
  {
    // ...
  };

auto g_not_integral =  
 [](auto&& func, auto&& param1, auto&&... params) 
    -> std::enable_if_t< !std::is_integral<
        std::decay_t<decltype(param1)>
    >{}>
{
    // ...
};

auto gL = funcs( g_not_integral, g_integral );

并调用 gL 将对两个 lambda 进行 SFINAE 友好的重载解析。

在funcs_t 的线性继承中，上面做了一些可以避免的虚假动作。在工业质量的库中，我可能会使用二进制而不是线性的继承（以限制模板的实例化深度和继承树的深度）。

---

顺便说一句，我知道 SFINAE 启用 lambda 有 4 个原因。

首先，使用新的std::function，您可以在多个不同的回调签名上重载一个函数。

第二，上面的技巧。

第三，柯里化一个函数对象，当它具有正确数量和类型的参数时，它会在其中进行评估。

第四，自动元组解包和类似的。如果我使用 continuation 传递样式，我可以询问传入的 continuation 是否会接受未打包的元组或未捆绑的未来等。

Answer 2

通用 lambda 只能有一个主体，因此 SFINAE 在这里用处不大。

一种解决方案是将调用打包到一个类中，该类可以存储结果并专门用于 void 返回类型，将 void 特殊处理封装在您的 lambda 之外。只需很少的开销，您就可以使用线程库工具来做到这一点：

auto gL = 
    [](auto&& func, auto&&... params)
    {
        // start a timer
        using Ret = decltype(std::forward<decltype(func)>(func)(
            std::forward<decltype(params)>(params)...));
        std::packaged_task<Ret()> task{[&]{
            return std::forward<decltype(func)>(func)(
                std::forward<decltype(params)>(params)...); }};
        auto fut = task.get_future();
        task();
        // stop timer and print elapsed time
        return fut.get(); 
    };

如果您想避免packaged_task 和future 的开销，编写自己的版本很容易：

template<class T>
struct Result
{
    template<class F, class... A> Result(F&& f, A&&... args)
        : t{std::forward<F>(f)(std::forward<A>(args)...)} {}
    T t;
    T&& get() { return std::move(t); }
};
template<>
struct Result<void>
{
    template<class F, class... A> Result(F&& f, A&&... args)
        { std::forward<F>(f)(std::forward<A>(args)...); }
    void get() {}
};

auto gL = 
    [](auto&& func, auto&&... params)
    {
        // start a timer
        using Ret = decltype(std::forward<decltype(func)>(func)(
            std::forward<decltype(params)>(params)...));
        Result<Ret> k{std::forward<decltype(func)>(func),
            std::forward<decltype(params)>(params)...};
        // stop timer and print elapsed time
        return k.get(); 
    };

Answer 3

SFINAE 的用途是在解析给定函数或模板时从候选集中移除重载或特化。在您的情况下，我们有一个 lambda - 这是一个带有单个 operator() 的函子。没有过载，因此没有理由使用 SFINAE¹。 lambda 是通用的，这使得它的operator() 成为函数模板这一事实并没有改变这一事实。

但是，您实际上不需要区分不同的返回类型。如果func 为给定的参数返回void，您仍然可以return 它。您只是不能将其分配给临时的。但你也不必这样做：

auto time_func = [](auto&& func, auto&&... params) {
    RaiiTimer t;
    return std::forward<decltype(func)>(func)(
        std::forward<decltype(params)>(params)...); 
};

只需编写一个RaiiTimer，其构造函数启动一个计时器，其析构函数将其停止并打印结果。无论func 的返回类型如何，这都会起作用。

如果您需要比这更复杂的东西，那么这是您应该prefer a functor over a lambda 的情况之一。

---

¹实际上，正如 Yakk 所指出的，SFINAE 仍然可以非常方便地检查您的函数是否是可调用周期，这不是您要解决的问题 - 所以在这种情况下，仍然不是很有帮助。