constexpr and consteval with Lambdas

Yes, you can use both constexpr and consteval with lambda functions in C++20 and later. This feature allows you to create powerful compile-time computations with the convenience of lambda syntax. Let's explore how to use them:

constexpr Lambdas

By default, all lambda functions in C++17 and later are implicitly constexpr if possible. This means if all the operations inside the lambda are allowed in a constant expression, the lambda will be constexpr.

1#include <iostream>
2
3int main() {
4  constexpr auto square = [](int x) {
5    return x * x;
6  };
7  constexpr int result = square(5);
8  std::cout << "5 squared is: " << result;
9}

15 squared is: 25

You can also explicitly declare a lambda as constexpr:

1constexpr auto cube = [](int x) constexpr {
2  return x * x * x;
3};

This example demonstrates two important points about constexpr and lambdas:

1. The constexpr before auto tells the compiler that the lambda object itself should be a compile-time constant. This means the lambda can be used in contexts that require constant expressions, such as template arguments or array sizes.
2. The constexpr after the parameter list ([](int x) constexpr) explicitly declares that the lambda's function call operator should be constexpr. This ensures that the lambda can be called in constant expressions.

While the second constexpr is often redundant (as lambdas are implicitly constexpr when possible), explicitly declaring it can serve as documentation and will cause a compilation error if the lambda body isn't actually eligible to be constexpr.

Here's an expanded example to illustrate these points:

1#include <iostream>
2#include <array>
3
4int main() {
5  // Lambda object is constexpr
6  // function call operator is implicitly constexpr
7  constexpr auto square = [](int x) {
8    return x * x;
9  };
10
11  // Lambda object is constexpr
12  // function call operator is explicitly constexpr
13  constexpr auto cube = [](int x) constexpr {
14    return x * x * x;
15  };
16
17  // Use in a constant expression (array size)
18  std::array<int, square(3)> arr1;
19  std::array<int, cube(3)> arr2;
20
21  std::cout << "arr1 Size: " << arr1.size() << '\n';
22  std::cout << "arr2 Size: " << arr2.size() << '\n';
23
24  // Use in another constant expression
25  constexpr int result1 = square(4);
26  constexpr int result2 = cube(4);
27
28  std::cout << "4 squared: " << result1 << '\n';
29  std::cout << "4 cubed: " << result2 << '\n';
30}

1arr1 Size: 9
2arr2 Size: 27
34 squared: 16
44 cubed: 64

In this example, both square() and cube() can be used in constant expressions, such as array sizes and constexpr variable initializations. The difference in their declaration is mostly a matter of style and explicitness.

consteval Lambdas

C++20 introduces the ability to create consteval lambdas. These are guaranteed to be evaluated at compile-time.

1// A consteval lambda example
2auto add = [](int a, int b) consteval {
3  return a + b;
4};
5
6int main() {
7  // This is fine
8  constexpr int a{1}, b{2};
9  add(5, 3);
10
11  // This will be a compilation error
12  int c{3}, d{4};
13  add(c, d);
14}

1error: call to immediate function is not a constant expression
2note: see usage of 'c'

Using Lambdas in Template Arguments

One powerful use of constexpr and consteval lambdas is in template arguments:

1#include <iostream>
2
3template <auto Func>
4consteval int apply(int x) {
5  return Func(x);
6}
7
8int main() {
9  // constexpr lambda for squaring a number
10  constexpr auto square = [](int x) constexpr {
11    return x * x;
12  };
13
14  std::cout << "Square of 5: " << apply<square>(5);
15
16  // consteval lambda for cubing a number
17  constexpr auto cube = [](int x) consteval {
18    return x * x * x;
19  };
20  std::cout << "\nCube of 3: " << apply<cube>(3);
21}

1Result: 25
2Result: 27

Remember, when using constexpr or consteval with lambdas, all captured variables must be known at compile-time. Also, the lambda body must only contain operations that are allowed in a constant expression.

These features open up new possibilities for metaprogramming and compile-time computations, allowing you to write more expressive and efficient code.