如何在“折叠表达式”中也可以使用“短路评估”？

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; });

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