9

通用 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 是底层的模板化函数对象，这不能完成是不是有点奇怪？

4

3 回答 3

10

Lambda 是底层的函数对象。通用 lambda 是带有模板的函数对象operator()。

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 个原因。

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

二、以上招数。

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

第四，自动元组解包等。如果我使用的是延续传递风格，我可以询问传递的延续，它是否会接受解包的元组，或者未来的解包等。

于 2015-07-06T20:42:54.607 回答
2

SFINAE 的用途是在解析给定函数或模板时从候选集中移除重载或特化。在您的情况下，我们有一个 lambda - 它是一个带有单个operator(). 没有过载，因此没有理由使用 SFINAE 1。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' 的返回类型如何，这都将起作用。

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

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

于 2015-07-06T19:52:46.040 回答
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(); 
    };

如果您想避免 and 的开销，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(); 
    };
于 2015-07-06T20:09:26.010 回答