惰性评估是否有效/可优化？

Question

我发现惰性评估有很多用途，例如优化工具（例如matrices）。

另一个用途是语法糖。但是在我以运行时开销为代价让我的代码看起来更干净之前，编译器知道如何优化这种东西吗？还是应该只在潜在开销比不使用惰性评估更快时才使用它？

以下是我的意思的一个例子。这不是我的实际用例，只是 non-lazy 与 lazy eval 的简单版本。

// original
template < class out,
           class in >
out && lazy_cast( in && i )
{
    return ( out && )( i );
}

// usage
char c1 = 10;
int c2 = lazy_cast< int >( c1 );

// lazy
template < class in >
class C_lazy_cast
{
public:
    in && i;

    template < class out && >
    operator out &&( )
    {
        return ( out && )( i );
    }
};

template < class in >
C_lazy_cast< in > lazy_cast( in && i )
{
    return { std::forward< in >( i ) };
}

// usage
char c1 = 10;
int c2 = lazy_cast( c1 );

为了完整起见，关于 MSVC、GCC 和 clang 的信息应该足够了。

Answer 1

编译器可以做的比你想象的要多得多。 我不确定您在示例中要做什么，但请考虑following piece of code：

template <typename TLazyChar>
struct lazyUpperImpl{
    TLazyChar in;
    lazyUpperImpl(TLazyChar in_):in(in_){}
    char constexpr operator()(){
        auto c = in();
        if (c >= 'a' && c <= 'z'){
            c = c - 'a' + 'A';
        }
        return c;
    }
};

template <typename TLazyNumeric>
struct lazyAdd5Impl{
    TLazyNumeric in;
    lazyAdd5Impl(TLazyNumeric in_):in(in_){}
    int constexpr operator()(){
        return in() + 5;
    }
};

template <typename Tout, typename TLazyIn>
struct lazyCastImpl {
    TLazyIn in;
    lazyCastImpl(TLazyIn in_):in(in_){}

    Tout constexpr operator()(){
        return static_cast<Tout>(in());
    }
};

template <typename Tout, typename TLazyIn>
auto constexpr lazyCast(TLazyIn in){
    return lazyCastImpl<Tout, TLazyIn>(in);
}

template <typename TLazyChar>
auto constexpr lazyUpper(TLazyChar in){
    return lazyUpperImpl<TLazyChar>(in);
}

template <typename TLazyNumeric>
auto constexpr lazyAdd5(TLazyNumeric in){
    return lazyAdd5Impl<TLazyNumeric>(in);
}

int foo(int in){
    auto lazyInt = [in](){return in;};
    auto x =
        lazyAdd5(
            lazyCast<int>(
                lazyUpper(
                    lazyCast<char>(lazyInt)
                )
            )
        ) ();

    return x;
}

int main(){
    return foo(109);
}

使用gcc 10.2、clang 10.0.1 和msvc 19.24，foo 的代码变成了一组简单的指令 - 有条件地减去 26 并始终加 5。

例如msvc生成的程序集是：

    movzx   eax, cl
    cmp     cl, 97                      ; 00000061H
    jl      SHORT $LN26@foo
    cmp     cl, 122                     ; 0000007aH
    jg      SHORT $LN26@foo
    lea     eax, DWORD PTR [rcx-32]
$LN26@foo:
    movsx   eax, al
    add     eax, 5
    ret     0

msvc 的输出可以说是三者中最不复杂（因此最容易理解）的。

此外，如果您从编译时已知的输入值开始，则会内联到单个 return new_value 指令。

请注意，在上面的示例中，编译器无法避免 if 条件，并且“lazyCast”只是一个空操作。

Here 是另一个有趣的例子，其中两个if 语句和两个数学表达式被简单地抵消了。

对于真正的程序，实际效率很难/不可能从汇编中预测 - 它取决于执行程序的机器，以及这台机器所处的状态（例如，它是否同时运行不同的程序？）。即使这样，您也需要运行测试以确保哪些行效果最好。

当然，最好是主观的。您需要决定是否更喜欢优化运行时间（可能会进一步细分）、可执行文件的大小或电源要求？

这需要大量的学习才能做到正确，但您可以放心，有一些非常有才华的人以解决这些问题为生，而且他们通常做得很好。