Contents
V1080. Call of 'std::is_constant_evaluated' function always returns the same value.
The diagnostic rule warns that the 'std::is_constant_evaluated' function's return value has no ability to ever change. This may lead to unreachable code.
This rule covers two cases:
- The function is called in the context, that is always the compile-time context, and returns 'true'.
- The function is called in the context, that is always the runtime context, and returns 'false'.
Example: we need to write a function that would contain two versions of one algorithm - one version for compile-time, the other version for runtime. We'll use the 'std::is_constant_evaluated' function to differentiate between these two implementations.
#include <type_traits>
constexpr void foo()
{
constexpr auto context = std::is_constant_evaluated();
//....
if (context)
{
// compile-time logic
}
else
{
// runtime logic
}
}Here the 'std::is_constant_evaluated' function always returns 'true'. The 'else' branch contains unreachable code.
The opposite situation may happen if we remove the 'costexpr' specifier from the 'context' variable and from the 'foo' function.
#include <type_traits>
void foo()
{
auto context = std::is_constant_evaluated();
//....
if (context)
{
// compile-time logic
}
else
{
// runtime logic
}
}Here the 'context' variable is always 'false'. The code becomes unreachable as early as the 'then' branch.
The 'std::is_constant_evaluated' always returns 'true' if called in one of the following locations:
- inside 'static_assert';
- inside the 'consteval' function;
- inside the 'if constexpr' condition.
The 'std::is_constant_evaluated' always returns 'true' if called here:
- inside a function that is not marked with the 'constexpr' / 'consteval' specifiers.
This diagnostic is classified as:
Was this page helpful?
