std::is_constant_evaluated (3) Linux Manual Page

std::is_constant_evaluated – std::is_constant_evaluated

Synopsis

Defined in header <type_traits>
constexpr bool is_constant_evaluated() noexcept; (since C++20)
Detects whether the function call occurs within a constant-evaluated context. Returns true if the evaluation of the call occurs within the evaluation of an expression or conversion that is manifestly constant-evaluated; otherwise returns false.
The following expressions (including conversions to the destination type) are manifestly constant-evaluated:
* Where a constant expression is grammatically required, including:
      * array_bounds
      * the dimensions in new-expressions other than the first
      * bit-field_lengths
      * enumeration_initializers
      * alignments
      * case_expressions
      * non-type template_arguments
      * expressions in noexcept_specifications
      * expressions in static_assert_declarations
      * expressions in conditional_explicit_specifiers
* conditions of constexpr_if_statements
* immediate_invocations
* constraint expressions in concept definitions, nested_requirements, and requires_clauses
* initializers of variables that are usable in constant expressions, including:
      * initializers of constexpr_variables
      * initializers of variables with reference type or const-qualified integral or enumeration type, when the initializers are constant_expressions
* initializers of static and thread local variables, when all subexpressions of the initializers (including constructor calls and implicit conversions) are constant_expressions (that is, when the initializers are constant_initializers)
To test the last two conditions, compilers may first perform a trial constant evaluation of the initializers. It is not recommended to depend on the result in this case.

int y;

const int a = std::is_constant_evaluated() ? y : 1;

// Trial constant evaluation fails. The constant evaluation is discarded.

// Variable a is dynamically initialized with 1
const int b = std::is_constant_evaluated() ? 2 : y;

// Constant evaluation with std::is_constant_evaluation() == true succeeds.

// Variable b is statically initialized with 2

Parameters

(none)

Return value

true if the evaluation of the call occurs within the evaluation of an expression or conversion that is manifestly constant-evaluated; otherwise false

Notes

When directly used as the condition of static_assert_declaration or constexpr_if_statement, std::is_constant_evaluated() always returns true.

Example

 This section is incomplete
 Reason: no example