C++20. is_constant_evaluated() vs if constexpr

Question

Here is example from cppreference:

constexpr double power(double b, int x)
{
if (std::is_constant_evaluated() && !(b == 0.0 && x < 0)) {
    // A constant-evaluation context: Use a constexpr-friendly algorithm.
    if (x == 0)
        return 1.0;
    double r = 1.0, p = x > 0 ? b : 1.0 / b;
    auto u = unsigned(x > 0 ? x : -x);
    while (u != 0) {
        if (u & 1) r *= p;
        u /= 2;
        p *= p;
    }
    return r;
} else {
    // Let the code generator figure it out.
    return std::pow(b, double(x));
}
}

As you can see std::is_constant_evaluated(). My question is why can't we use if constexpr here to check if the function call occurs within a constant-evaluated context?

Are you asking why `if constexpr` can't be used instead of `if` here? — HolyBlackCat, Dec 23 '19 at 15:20
@rudolfninja: What do you think that condition is doing? And what would, in your mind, an equivalent `if constexpr` condition would look like? — Nicol Bolas, Dec 23 '19 at 15:27
Related question: [std::is\_constant\_evaluated behavior](https://stackoverflow.com/questions/54251530/stdis-constant-evaluated-behavior) — Evg, Dec 23 '19 at 16:00

Nicol Bolas · Answer 1 · 2019-12-23T16:09:02.413

The question which is_constant_evaluated() is asking is exactly spelled out in its name: "is this expression being evaluated within constant expression evaluation?" A function declared constexpr may or may not be executed as part of constant expression evaluation. So calling that function within such a context may return different values depending on how the implementation calls it.

However, the condition of if constexpr must be a constant expression, regardless of what function it happens to be in. And therefore, executing is_constant_evaluated() within if constexpr's condition will always yield true.

You cannot use is_constant_evaluated with if constexpr's condition or any other explicitly constexpr context. Well, you can, but it probably won't return the result that you're actually interested in.

What this code is ultimately doing is creating two versions of the function: one which is optimized for runtime execution and the other which is optimized for compile-time execution. That requires having a condition that tests which version needs to be called.

score 1 · Answer 2 · answered Dec 23 '19 at 15:28

The whole purpose of std::is_constant_evaluated is to be able to dispatch between run time and compile time in your if statement.

If you were to use if constexpr, then you would already be in a constant expression and the condition will always be true.

Instead you use a regular if and if you are in a constant expression you'll get the if part at compile time and if not you'll get the else part at run time.

score 0 · Answer 3 · answered Dec 23 '19 at 15:42

0

cppreference already answers your question:

When directly used as the condition of static_assert declaration or constexpr if statement, std::is_constant_evaluated() always returns true.

answered Dec 23 '19 at 15:42

Kane

5,595
1
18
27

C++20. is_constant_evaluated() vs if constexpr

3 Answers3