调用 constexpr 函数的给定重载时触发编译时错误

Question

I am writing custom variadic template that performs lookup in compile-time map.

The problem is, I want to trigger compile-time error each time the value is not found in that map - preferably with descriptive error message.

example code:

template<key_t k, class pair, class... pairs>
static constexpr value_t get_local(std::tuple<pair, pairs...>)
{
    return (pair::key == k) ? pair::value : get_local<k>(std::tuple<pairs...>{});
}

template<key_t k> static constexpr value_t get_local(std::tuple<>)
{
    // Trigger error!
}

I can leave get_local undefined in the second part of code, and it actually triggers linker error, but that is not falling into category of "descriptive error message".

Static asserts, I believe, would be of no use here.

I am using C++ 17

Answer 1

And immediate drop in solution is to delete the overload:

template<key_t k> static constexpr value_t get_local(std::tuple<>) = delete;

This will provide the somewhat descriptive message that we try to use a base case that doesn't exist.

Alternatively, with a static assertions in place:

template<key_t k> struct always_false { static constexpr bool value = false; };

template<key_t k> static constexpr value_t get_local(std::tuple<>)
{
    static_assert(always_false<k>::value, "Hit bad case!");
    return std::declval<value_t>();
}

The always_false utility is needed to make the assertion condition dependent, so the template is not ill-formed; no diagnostic required, as static_assert(false, ...) would make it.

Mind you, that you instantiate this overload yourself in your own conditional operator:

(pair::key == k) ? pair::value : get_local<k>(std::tuple<pairs...>{});

When you hit the case of a tuple with a single element. Both "branches" of the conditional expression must be valid. Best handle it conditionally with an if constepxr :

if constexpr (pair::key == k) return pair::value;
else                          return get_local<k>(std::tuple<pairs...>{});

Since you did indicate pair::key == k can be evaluated in a constant expression.