Question

#include <type_traits>

#define FORWARD(arg)\
std::forward<decltype(arg)>(arg)

template<typename... Args>
constexpr bool AndL(Args&&... args)
{
    return (... && FORWARD(args));
}

template<typename... Args>
constexpr bool AndR(Args&&... args)
{
    return (FORWARD(args) && ...);
}

int main()
{
    bool* pb = nullptr;

    false && (*pb = true);       // ok at runtime.
    AndL(false, (*pb = true));  // error at runtime!
    AndR(false, (*pb = true));  // error at runtime!
}

传统的&&运算符支持短路评估，因此false && (*pb = true)在运行时可以正常运行，但以下两种情况都不行。

如何在fold expressions中提供短路评估？

Answer 1

这里的问题只是对实际发生的事情的误解。

如何在折叠表达式中提供短路评估？

在折叠表达式中可用。 (args && ... )遵循与(a && b && c && d)完全相同的规则。也就是说，d仅在a，b和c评估为真的时才会被评估。

这不是两种情况之间的实际差异。

false && (*pb = true);       // ok at runtime.
AndL(false, (*pb = true));   // error at runtime!

虽然折叠表达式与非折叠表达式完全相同，但这两个语句之间存在一个重要区别。第一个是语句表达式，第二个是函数调用。并且必须在正文开始之前评估所有函数参数。

所以第二个相当于：

auto&& a = false;
auto&& b = (*pb = true);
(FORWARD(a) && FORWARD(b));

导致问题的排序，而不是折叠表达式（注意：b可以在a之前评估）。

为了使这个透明，你真正需要的是懒惰的参数。这是几种语言的功能（例如Scala），但不是C ++中的功能。如果你需要懒惰，你可以做的最好的事情是将所有东西都包裹在lambda中：

template<typename... Args>
constexpr bool AndL(Args&&... args)
{
    return (... && FORWARD(args)());
}

AndL([]{ return false; }, [&]{ return *pb = true; });

然后你可以使这个任意复杂 - 也许只是“解开”那些可调用的类型，否则假设它们是bool：

template <class T, std::enable_if_t<std::is_invocable<T>::value, int> = 0>
bool unwrap(T&& val) { return std::forward<T>(val)(); }

template <class T, std::enable_if_t<std::is_convertible<T, bool>::value, int> = 0>
bool unwrap(T&& val) { return std::forward<T>(val); }

template<typename... Args>
constexpr bool AndL(Args&&... args)
{
    return (... && unwrap(FORWARD(args)));
}

AndL(false, [&]{ return *pb = true; });

但实际上，主要的一点是功能参数评估在函数体之前，问题不在于折叠表达式本身。

如何在“折叠表达式”中提供“短路评估”？

1 个答案: