将SFINAE与通用lambdas一起使用

Question

泛型lambdas能利用“替换失败不是错误”规则吗？例子

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

SFINAE的用途是在html" target="_blank">解析给定的函数或模板时，从候选集中删除重载或专门化。在您的例子中，我们有一个lambda -它是一个带有单个< code >操作符()的函子。没有重载，所以没有理由使用SFINAE¹。lambda是泛型的，这使得它的< code>operator()成为一个函数模板，但这并没有改变这个事实。

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

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

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

如果你需要比这更复杂的东西，那么这就是你应该更喜欢函子而不是lambda的情况之一。

^{1 个}实际上，正如Yak所指出的，SFINAE仍然可以非常方便地检查你的函数是否是可调用的周期，这不是你试图解决的问题 - 所以在这种情况下，仍然不是很有帮助。

Answer 2

一个泛型lambda只能有一个体，所以SFINAE在这里没有多大用处。

一种解决方案是将调用打包到一个类中，该类可以存储结果并专门处理< code>void返回类型，将< code>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(); 
    };

如果您想避免＜code＞packaged_task＜/code＞和＜code＞future＜/code＞的开销，可以很容易地编写自己的版本：

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

lambda是引擎盖下的功能对象。泛型lambda是带有模板操作符（）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)...};
}

< code>auto f_all = funcs( f1，f2 )生成一个对象，该对象是< code>f1和< code>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启用lambdas有4个原因。

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

二、以上招数。

第三，在函数对象具有正确数量和类型的 args 时进行计算，从而查询函数对象。

第四，自动元组解包等。如果我使用延续传递方式，我可以询问传入的延续是否接受解包的元组，或者将来解包的元组，等等。