Why if constexpr fails to bypass constexpr evaluation?

Question

I'm building a static loop for type dispatching using macros. Here is what I achieved so far.

#define LOOP(n, f)                                            \
    static_assert(n <= 8 && "static loop size should <= 8");  \
    do {                                                      \
        if constexpr (n >= 8)                                 \
            f(std::integral_constant<size_t, n - 8>());       \
        if constexpr (n >= 7)                                 \
            f(std::integral_constant<size_t, n - 7>());       \
        if constexpr (n >= 6)                                 \
            f(std::integral_constant<size_t, n - 6>());       \
        if constexpr (n >= 5)                                 \
            f(std::integral_constant<size_t, n - 5>());       \
        if constexpr (n >= 4)                                 \
            f(std::integral_constant<size_t, n - 4>());       \
        if constexpr (n >= 3)                                 \
            f(std::integral_constant<size_t, n - 3>());       \
        if constexpr (n >= 2)                                 \
            f(std::integral_constant<size_t, n - 2>());       \
        if constexpr (n >= 1)                                 \
            f(std::integral_constant<size_t, n - 1>());       \
    } while (0);

template <typename T> constexpr size_t tupleSize(T&) { return tuple_size_v<T>; }

int main() {
    auto t = std::make_tuple(1, "string", 0.2, 3, 1, 1, 1);
    LOOP(tupleSize(t), [&](auto i) { cout << std::get<i>(t) << endl; });
    return 0;
}

And the godbolt link https://godbolt.org/z/GcMZI3

The question is, why do the first four branches fail the compilation?

Realted: https://stackoverflow.com/questions/46512248/why-doesnt-an-if-constexpr-make-this-core-constant-expression-error-dissappear - Same as in my question, yours is not dependent. Matter of fact, it's not even a template. — StoryTeller - Unslander Monica, Dec 30 '18 at 13:03
what's the `#define`? the whole LOOP should become empty because of that. — apple apple, Dec 30 '18 at 13:04
@appleapple - Scroll the code right. The `\ ` breaks are there. — StoryTeller - Unslander Monica, Dec 30 '18 at 13:05
@StoryTeller Oh! thanks, maybe it's better to put it closer. — apple apple, Dec 30 '18 at 13:07
BTW, `static_assert` accepts a second string literal argument. No need to do the same trick as with the C assert macro. You can just write this `static_assert(n <= 8, "static loop size should <= 8");` — StoryTeller - Unslander Monica, Dec 30 '18 at 13:13
What about consistency with the rest of the C++ literate world? I mean granted, it's not terribly hard to understand, but I doubt I'll be the last reviewer to bring it up. 2c anyways. — StoryTeller - Unslander Monica, Dec 30 '18 at 13:21

Vittorio Romeo · Accepted Answer · 2018-12-30T13:16:52.873

Do not use a macro, use a function template instead. if constexpr works by discarding the non-taken branch depending on the current instantiation of a template.

template <std::size_t n, typename F>
void loop(F&& f)
{
    static_assert(n <= 8 && "static loop size should <= 8");
    if constexpr (n >= 8)
        f(std::integral_constant<size_t, n - 8>());
    if constexpr (n >= 7)
        f(std::integral_constant<size_t, n - 7>());
    if constexpr (n >= 6)
        f(std::integral_constant<size_t, n - 6>());
    if constexpr (n >= 5)
        f(std::integral_constant<size_t, n - 5>());
    if constexpr (n >= 4)
        f(std::integral_constant<size_t, n - 4>());
    if constexpr (n >= 3)
        f(std::integral_constant<size_t, n - 3>());
    if constexpr (n >= 2)
        f(std::integral_constant<size_t, n - 2>());
    if constexpr (n >= 1)
        f(std::integral_constant<size_t, n - 1>());
}

Usage:

int main() {
    constexpr auto t = std::make_tuple(1, "string", 0.2, 3);
    loop<tupleSize(t)>([&](auto i) { cout << std::get<i>(t) << endl; });
    return 0;
}

live example on godbolt.org

From cppreference:

If a constexpr if statement appears inside a templated entity, and if condition is not value-dependent after instantiation, the discarded statement is not instantiated when the enclosing template is instantiated.

Outside a template, a discarded statement is fully checked. if constexpr is not a substitute for the #if preprocessing directive

Cool, but it fails when I do a nested loop. https://la.wentropy.com/Zxe1 — Amos, Dec 30 '18 at 13:17
Replace the second `tupleSize(t)` with `4` and it works. `clang` works as well. Seems to be a gcc bug — Vittorio Romeo, Dec 30 '18 at 13:20
Opened follow-up question: https://stackoverflow.com/questions/53978006/constexpr-function-with-unused-reference-argument-gcc-vs-clang — Vittorio Romeo, Dec 30 '18 at 13:29
I've also posted another follow-up to this, https://stackoverflow.com/questions/53978098/invalid-explicitly-specified-argument-for-template-parameter-which-is-constexpr — Amos, Dec 30 '18 at 13:42

Why if constexpr fails to bypass constexpr evaluation?

1 Answers1