# std::is_constant_evaluated

From cppreference.com
< cpp‎ | types

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

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/is_constant_evaluated&oldid=108687"