std::is_constant_evaluated (3) - Linux Manuals

std::is_constant_evaluated: std::is_constant_evaluated

NAME

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