How to handle exceptions in C++ recursive functions?

The key to recursive function exception handling is to immediately unwound the recursive stack, which may cause memory leaks and program crashes. Methods for handling exceptions include encapsulating the exception into a local variable, using RAII wrapping, or using std::terminate() to terminate the function. For example, you can use encapsulated exceptions to handle exceptions in a recursive function that calculates factorial: if (n < 0) { throw std::runtime_error("Factorial cannot be calculated as a negative number"); }

C Exception handling in recursive functions

Recursive functions need to be extra careful when handling exceptions, because once an exception occurs, the recursive stack will be unwound immediately, resulting in All unhandled local variables are destroyed, possibly causing unexpected memory leaks and program crashes.

Handling methods

There are many ways to handle exceptions in recursive functions:

1. Encapsulate exceptions into local variables

// 函数可以抛出 std::runtime_error 异常
void recursive_function(int remaining_depth) {
  if (remaining_depth <= 0) {
    return;
  }
  
  // 封装异常到本地变量中
  try {
    // 存在异常抛出的代码
    ...
  } catch (const std::runtime_error& e) {
    // 对异常进行处理（可选）
  }
  
  // 递归调用自身
  recursive_function(remaining_depth - 1);
}

2. Use RAII packaging

RAII (resource acquisition is initialization) packaging can automatically release resources when an exception occurs. Using a custom RAII wrapper, you can get a pointer to a resource in the argument list of a recursive function and guarantee the resource is released when exiting the scope.

// RAII 包装器，在析构时释放资源
struct ResourceWrapper {
  ResourceWrapper() {
    // 获取资源
  }
  ~ResourceWrapper() {
    // 释放资源
  }
};

void recursive_function(int remaining_depth, ResourceWrapper& resources) {
  if (remaining_depth <= 0) {
    return;
  }

  // 使用资源并处理异常（可选）
  try {
    ...
  } catch (...) {
    // 处理异常（可选）
  }
  
  // 递归调用自身
  recursive_function(remaining_depth - 1, resources);
}

3. Use the termination function

The termination function allows recursive calls to be stopped immediately when an exception occurs. This can be achieved by calling the std::terminate() function within a recursive function, which will unwound the stack and terminate the program.

void recursive_function(int remaining_depth) {
  if (remaining_depth <= 0) {
    return;
  }
  
  // 存在异常抛出的代码
  ...
  
  // 异常发生时终止程序
  std::terminate();
  
  // 递归调用自身
  recursive_function(remaining_depth - 1);
}

Practical case

Consider a recursive function used to calculate the factorial of a number:

int factorial(int n) {
  if (n == 0) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

Use the method of encapsulating exceptions into local variables, you can Handle exceptions as follows:

int factorial(int n) {
  if (n < 0) {
    throw std::runtime_error("阶乘不能计算负数");
  }
  
  if (n == 0) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

The above is the detailed content of How to handle exceptions in C++ recursive functions?. For more information, please follow other related articles on the PHP Chinese website!