Exceptions in constexpr and consteval

Handling exceptions in constexpr and consteval functions is a bit tricky because these functions are designed for compile-time evaluation. Let's explore the rules and best practices:

Basic Rules

• Prior to C++20, constexpr functions were not allowed to throw exceptions.
• In C++20 and later, constexpr functions can throw exceptions, but only during runtime execution.
• consteval functions (introduced in C++20) cannot throw exceptions at all.

Exception Handling in C++20 constexpr Functions

In C++20, you can use try-catch blocks in constexpr functions, but they will only have an effect during runtime execution:

1#include <iostream>
2#include <stdexcept>
3
4constexpr int divide(int a, int b) {
5  if (b == 0) {
6    throw std::runtime_error("Division by zero");
7  }
8  return a / b;
9}
10
11int main() {
12  constexpr int result1 = divide(10, 2);
13  std::cout << "Result1: " << result1 << '\n';
14
15  try {
16    // Runtime error that will be caught:
17    int result2 = divide(10, 0);
18    std::cout << "Result2: " << result2 << '\n';
19  } catch (const std::exception& e) {
20    std::cout << "Caught exception: "
21      << e.what() << '\n';
22  }
23
24  // This would cause a compile-time error:
25  // constexpr int result3 = divide(10, 0);
26}

1Result1: 5
2Caught exception: Division by zero

Compile-Time Error Handling

For true compile-time error handling, you should use techniques that result in compilation failures rather than runtime exceptions:

1#include <iostream>
2#include <type_traits>
3
4template <int A, int B>
5struct SafeDivide {
6  static_assert(B != 0, "Division by zero");
7  static constexpr int value = A / B;
8};
9
10int main() {
11  constexpr int result1 = SafeDivide<10, 2>::value;
12  std::cout << "Result1: " << result1 << '\n';
13
14  // This would cause a compile-time error:
15  // constexpr int result2 = SafeDivide<10, 0>;
16}

1Result1: 5

Using std::is_constant_evaluated()

You can use std::is_constant_evaluated() to have different behavior at compile-time and runtime:

1#include <iostream>
2#include <stdexcept>
3#include <type_traits>
4
5constexpr int safeDivide(int a, int b) {
6  if (std::is_constant_evaluated()) {
7    // Avoid exception at compile-time
8    return b != 0 ? a / b : 0;
9  } else {
10    if (b == 0) {
11      throw std::runtime_error("Division by zero");
12    }
13    return a / b;
14  }
15}
16
17int main() {
18  constexpr int result1 = safeDivide(10, 2);
19  std::cout << "Result1: " << result1 << '\n';
20
21  // This is 0, not an error
22  constexpr int result2 = safeDivide(10, 0);
23  std::cout << "Result2: " << result2 << '\n';
24
25  try {
26    // This throws at runtime
27    int result3 = safeDivide(10, 0);
28    std::cout << "Result3: " << result3 << '\n';
29  } catch (const std::exception& e) {
30    std::cout << "Caught exception: " << e.what();
31  }
32}

1Result1: 5
2Result2: 0
3Caught exception: Division by zero

consteval Functions

Remember, consteval functions must be evaluated at compile-time and cannot throw exceptions:

1consteval int alwaysCompileTime(int x) {
2  // This function can't use try-catch
3  // or throw exceptions
4  return x * 2;
5}

In summary, while C++20 allows exceptions in constexpr functions during runtime, it's often better to design your compile-time code to avoid exceptions altogether.

Use techniques like static assertions, SFINAE, or compile-time if-constexpr statements to handle errors at compile-time. For consteval functions, focus on designs that don't require exception handling.