Le gestionnaire d'exceptions générique

Fait partie de la section Logique et Flux du Journey C++ de Coddy — leçon 52 sur 56.

Parfois, votre programme peut rencontrer des erreurs inattendues qui ne correspondent pas aux types d'exceptions spécifiques que vous avez prévus. Le gestionnaire universel catch(...) fournit un filet de sécurité qui capture toute exception qui n'a pas été traitée par vos blocs catch plus spécifiques.

Le gestionnaire universel utilise trois points (...) au lieu de spécifier un type d'exception particulier. Il doit être placé après tous les autres blocs catch car le C++ les vérifie dans l'ordre :

try {
    // Code qui pourrait lever diverses exceptions
} catch (std::invalid_argument& e) {
    std::cout << "Invalid input!" << std::endl;
} catch (std::out_of_range& e) {
    std::cout << "Number too large!" << std::endl;
} catch (...) {
    std::cout << "An unexpected error occurred!" << std::endl;
}

Le gestionnaire générique (catch-all) sert de solution de repli pour tout type d'exception qui n'a pas été intercepté par les blocs précédents. C'est particulièrement utile lorsque vous travaillez avec du code qui pourrait lever des exceptions que vous n'avez pas anticipées, garantissant ainsi que votre programme ne plante pas à cause d'erreurs inattendues.

Bien que vous ne puissiez pas accéder aux détails spécifiques de l'exception dans un bloc catch-all, vous pouvez toujours fournir un message d'erreur générique et effectuer des opérations de nettoyage pour assurer le bon fonctionnement de votre programme.

Défi

Facile

Créez un programme qui démontre une gestion complète des exceptions en utilisant plusieurs blocs catch, y compris un gestionnaire universel (catch-all). Ce défi testera votre compréhension de la manière de gérer à la fois des types d'exceptions spécifiques et des erreurs inattendues qui ne rentrent pas dans les catégories prédéfinies.

Les entrées suivantes seront fournies :

Une chaîne testType représentant le type de test à effectuer ("string_convert", "math_operation", "array_access", ou "unknown_error")
Une chaîne value1 qui sera utilisée comme donnée principale pour l'opération
Une chaîne value2 qui sera utilisée comme donnée secondaire pour certaines opérations

Votre programme doit :

Créer une fonction nommée performTest qui prend trois paramètres de type chaîne de caractères
À l'intérieur de la fonction, utiliser une structure if-else pour gérer les différents types de tests :
Si testType est "string_convert" : utiliser std::stoi pour convertir value1 en un entier et l'afficher
Si testType est "math_operation" : convertir à la fois value1 et value2 en entiers en utilisant std::stoi, puis diviser value1 par value2 et afficher le résultat
Si testType est "array_access" : créer une chaîne "Programming", convertir value1 en un index entier en utilisant std::stoi, puis utiliser str.at(index) pour accéder au caractère à cet index et l'afficher. La méthode .at() lève automatiquement std::out_of_range si l'index est invalide — aucune vérification manuelle des limites n'est nécessaire
Si testType est "unknown_error" : lever une valeur entière 999
Dans la fonction principale, appeler performTest à l'intérieur d'un bloc try
Utiliser plusieurs blocs catch pour gérer les exceptions dans cet ordre exact :
Premier : std::invalid_argument& pour les conversions chaîne-vers-nombre invalides
Deuxième : std::out_of_range& pour les nombres trop grands ou les index de chaîne hors limites
Troisième : catch(...) comme gestionnaire universel pour tous les autres types d'exceptions

Utilisez le format de sortie exact suivant :

Pour les opérations réussies :

Success: [result_value]

Pour les différents types d'exceptions :

Invalid argument caught
Out of range caught
Unknown exception caught

N'oubliez pas que le gestionnaire universel catch(...) doit être placé en dernier car le C++ vérifie les blocs catch dans l'ordre. Ce gestionnaire interceptera tout type d'exception qui n'a pas été géré par les blocs catch spécifiques précédents, y compris l'exception entière levée dans le cas "unknown_error". Le gestionnaire universel offre un filet de sécurité pour les erreurs inattendues tout en permettant une gestion spécifique pour les types d'exceptions connus.

Aide-mémoire

Le gestionnaire universel catch(...) fournit un filet de sécurité qui capture toute exception non gérée par des blocs catch spécifiques.

Le gestionnaire universel utilise trois points (...) et doit être placé après tous les autres blocs catch car le C++ les vérifie dans l'ordre :

try {
    // Code that might throw various exceptions
} catch (std::invalid_argument& e) {
    std::cout << "Invalid input!" << std::endl;
} catch (std::out_of_range& e) {
    std::cout << "Number too large!" << std::endl;
} catch (...) {
    std::cout << "An unexpected error occurred!" << std::endl;
}

Le gestionnaire universel agit comme une solution de repli pour tout type d'exception qui n'a pas été capturé par les blocs précédents. Bien que vous ne puissiez pas accéder aux détails spécifiques de l'exception dans un bloc universel, vous pouvez fournir des messages d'erreur génériques et effectuer des opérations de nettoyage.

Essayez vous-même

#include <iostream>
#include <string>
#include <stdexcept>
using namespace std;

// TODO: Écrivez votre code ici - créez la fonction performTest

int main() {
    // Lire l'entrée
    string testType;
    string value1;
    string value2;
    
    cin >> testType;
    cin >> value1;
    cin >> value2;
    
    // TODO: Écrivez votre code ci-dessous - implémentez les blocs try-catch et appelez performTest
    
    return 0;
}