> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ Constexpr Lambda
A `constexpr` lambda is a lambda expression whose invocation can be evaluated during compile-time constant evaluation. Introduced in C++17, it allows the compiler to declare the generated closure type's `operator()` as a `constexpr` member function, enabling the lambda to participate in constant expressions.
## Syntax
The `constexpr` specifier is placed after the parameter list and mutable specifier (if any), but before the trailing return type and body.
```cpp theme={"dark"}
auto lambda = [captures](parameters) constexpr -> return_type {
// body
};
```
## Implicit vs. Explicit `constexpr`
In C++17 and later, lambdas are **implicitly** `constexpr`. The compiler automatically treats the lambda's `operator()` as `constexpr` if its body satisfies the requirements of a constant expression.
Providing the `constexpr` keyword **explicitly** declares the `operator()` as `constexpr`. Prior to C++23, this mandated that the lambda must be valid in at least one constant expression context. As of C++23 (via proposal P2448R2), this strict diagnostic requirement is removed. The compiler will accept the explicit `constexpr` definition even if no valid constant expression context exists, though the function still cannot be evaluated at compile-time if the evaluated path executes non-constexpr operations.
```cpp theme={"dark"}
// Implicit constexpr: Valid in constant expressions
auto implicit_add = [](int a, int b) { return a + b; };
static_assert(implicit_add(2, 3) == 5);
// Explicit constexpr
auto explicit_square = [](int x) constexpr { return x * x; };
constexpr int val = explicit_square(4);
```
## Technical Requirements
For a lambda's invocation to be successfully evaluated at compile-time, its generated `operator()` must adhere to standard `constexpr` function constraints during evaluation:
1. **Literal Types:** All parameters and return types must be literal types.
2. **Valid Operations:** The execution path evaluated at compile-time cannot perform operations invalid in a constant expression, such as calling non-`constexpr` functions or executing inline assembly.
3. **Control Flow and State (C++23 Relaxations):** Prior to C++23, `goto` statements, labels, and definitions of `static` or `thread_local` variables were strictly prohibited within the lambda body. As of C++23 (via proposal P2242R3), these constructs are permitted in the definition, provided the specific control flow path evaluated during constant evaluation does not actually execute or initialize them.
4. **Memory Allocation:** In C++20 and later, transient `constexpr` allocations (`new`/`delete`) are permitted provided the memory is dynamically allocated and deallocated within the same constant evaluation context.
## Capture Semantics in Constant Expressions
When a lambda captures variables, the resulting closure object contains data members corresponding to those captures. For a stateful lambda to be invoked in a constant expression:
* The captured variables must be literal types.
* The closure object variable itself must be declared `constexpr` so that it is usable in constant expressions. Merely initializing the closure object with a constant expression is insufficient if the closure has state.
* If capturing by reference, the referenced object must have static storage duration or otherwise be usable in a constant expression.
```cpp theme={"dark"}
constexpr int multiplier = 10;
// The closure object itself must be declared constexpr
// to be usable in the static_assert below.
constexpr auto multiply = [multiplier](int x) constexpr {
return x * multiplier;
};
static_assert(multiply(5) == 50); // Valid
```
## C++20 Addition: `consteval` Lambdas
While `constexpr` implies the lambda *can* be evaluated at compile-time, C++20 introduced the `consteval` specifier for lambdas to create **immediate functions**. A `consteval` lambda *must* be evaluated at compile-time; any attempt to invoke it in a runtime context results in a compilation error.
```cpp theme={"dark"}
auto strict_compile_time = [](int x) consteval {
return x * 2;
};
constexpr int a = strict_compile_time(10); // OK
int b = 5;
// int c = strict_compile_time(b); // Error: 'b' is not a constant expression
```
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
