Comment gérer les exceptions dans les fonctions récursives C++ ?

La clé de la gestion des exceptions des fonctions récursives est de dérouler immédiatement la pile récursive, ce qui peut entraîner des fuites de mémoire et des plantages du programme. Les méthodes de gestion des exceptions incluent l'encapsulation de l'exception dans une variable locale, l'utilisation de l'encapsulation RAII ou l'utilisation de std::terminate() pour terminer la fonction. Par exemple, vous pouvez utiliser des exceptions encapsulées pour gérer les exceptions dans les fonctions récursives qui calculent des factorielles : if (n < 0) { throw std::runtime_error("La factorielle ne peut pas calculer les nombres négatifs"); }

Exception C++ gestion dans les fonctions récursives

Les fonctions récursives doivent être très prudentes lors de la gestion des exceptions, car une fois qu'une exception se produit, la pile récursive sera immédiatement déroulée, provoquant la destruction de toutes les variables locales non gérées, ce qui peut entraîner des fuites de mémoire inattendues et un programme s'écrase.

Méthodes de gestion

Il existe de nombreuses façons de gérer les exceptions dans les fonctions récursives :

1 Encapsuler les exceptions dans des variables locales

// 函数可以抛出 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. Utiliser le packaging RAII

RAII (l'acquisition des ressources est l'initialisation). peut libérer automatiquement des ressources lorsqu'une exception se produit. À l'aide d'un wrapper RAII personnalisé, vous pouvez obtenir un pointeur vers une ressource dans la liste d'arguments d'une fonction récursive et garantir que la ressource est libérée lorsque vous quittez la portée.

// 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. Utilisez la fonction de terminaison

La fonction de terminaison permet d'arrêter immédiatement les appels récursifs lorsqu'une exception se produit. Ceci peut être réalisé en appelant la fonction std::terminate() dans une fonction récursive, qui déroulera la pile et terminera le programme.

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

Cas pratique

Considérons une fonction récursive pour calculer la factorielle d'un nombre :

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

En utilisant la méthode d'encapsulation des exceptions dans des variables locales, les exceptions peuvent être gérées comme suit :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!