Gestion des exceptions en POO

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 81 sur 104.

La gestion des exceptions en C++ fournit une manière structurée de détecter les erreurs d’exécution et d’y répondre. En programmation orientée objet, les exceptions s’intègrent naturellement aux hiérarchies de classes, ce qui vous permet de créer des types d’erreur pertinents qui fournissent un contexte sur ce qui s’est mal passé.

Le mécanisme de base utilise trois mots-clés : try, throw et catch. Le code susceptible d’échouer est placé dans un bloc try, les erreurs sont signalées avec throw, et les blocs catch gèrent des types d’exceptions spécifiques :

#include <iostream>
#include <stdexcept>

class BankAccount {
    double balance;
public:
    BankAccount(double b) : balance(b) {}
    
    void withdraw(double amount) {
        if (amount > balance) {
            throw std::runtime_error("Insufficient funds");
        }
        balance -= amount;
    }
    
    double getBalance() const { return balance; }
};

int main() {
    BankAccount account(100.0);
    
    try {
        account.withdraw(150.0);
    } catch (const std::runtime_error& e) {
        std::cout << "Error: "lt;< e.what() << "\n";
    }
    
    std::cout << "Balance: " << account.getBalance() << "\n";
}

La bibliothèque standard C++ fournit une hiérarchie de classes d’exceptions ayant std::exception comme classe racine. Les classes dérivées courantes comprennent std::runtime_error pour les problèmes d’exécution et std::logic_error pour les erreurs de programmation. Toutes les exceptions standard fournissent une méthode what() qui renvoie un message d’erreur.

Lorsqu’une exception est levée, la pile se déroule : les destructeurs sont appelés pour tous les objets locaux tandis que le programme recherche un bloc catch correspondant. Cela garantit un nettoyage approprié même lorsque des erreurs surviennent, ce qui explique pourquoi RAII et la gestion des exceptions fonctionnent si bien ensemble.

Défi

Facile

Construisons une calculatrice de division sûre qui démontre la gestion des exceptions dans un contexte orienté objet. Vous allez créer une classe Calculator qui effectue des opérations de division et lève des exceptions explicites lorsqu'un problème survient, puis gérer ces exceptions correctement dans votre programme principal.

Vous allez organiser votre code sur trois fichiers :

Calculator.h : définissez votre classe Calculator qui effectue des opérations mathématiques avec une gestion appropriée des erreurs.
Votre Calculator doit disposer d'une méthode divide(double numerator, double denominator) qui renvoie le résultat de la division. Cependant, si le dénominateur est nul, elle doit lever une std::runtime_error avec le message Division by zero. Si le numérateur ou le dénominateur est négatif, elle doit lever une std::invalid_argument avec le message Negative values not allowed.

Incluez également une méthode safeSqrt(double value) qui renvoie la racine carrée de la valeur. Si la valeur est négative, levez une std::runtime_error avec le message Cannot compute square root of negative number. Vous devrez inclure <cmath> pour utiliser la fonction sqrt.
Calculator.cpp : implémentez les méthodes déclarées dans votre fichier d'en-tête. Veillez à inclure les en-têtes nécessaires (<stdexcept> et <cmath>) et à vérifier les conditions avant d'effectuer les opérations.
main.cpp : lisez trois entrées (chacune sur une ligne distincte) :
1. Type d'opération : soit divide, soit sqrt
2. Premier nombre (double)
3. Deuxième nombre (double) : utilisé uniquement pour la division, ignoré pour sqrt
Créez un objet Calculator et effectuez l'opération demandée dans un bloc try. Si l'opération réussit, affichez Result: [value]. Si une exception est interceptée, affichez Error: [message], où le message provient de la méthode what() de l'exception.

Après le bloc try-catch (qu'une exception se soit produite ou non), affichez Calculation complete pour montrer que le programme continue son exécution après la gestion des exceptions.

Par exemple, avec les entrées divide, 10 et 2 :

Result: 5
Calculation complete

Avec les entrées divide, 10 et 0 :

Error: Division by zero
Calculation complete

Avec les entrées divide, -5 et 2 :

Error: Negative values not allowed
Calculation complete

Avec les entrées sqrt, 16 et 0 :

Result: 4
Calculation complete

Avec les entrées sqrt, -9 et 0 :

Error: Cannot compute square root of negative number
Calculation complete

Remarquez comment le programme gère correctement les erreurs en interceptant les exceptions et en affichant des messages explicites, puis poursuit son exécution. Ce modèle permet de conserver une gestion des erreurs claire et de garder votre logique principale concentrée sur le chemin nominal.

Essayez vous-même

#include <iostream>
#include <string>
#include "Calculator.h"

using namespace std;

int main() {
    // Lire les entrées
    string operation;
    double num1, num2;
    
    cin >> operation;
    cin >> num1;
    cin >> num2;
    
    // Créer un objet Calculator
    Calculator calc;
    
    // TODO: Utiliser un bloc try-catch pour effectuer l'opération
    // - Si operation est "divide", appeler calc.divide(num1, num2)
    // - Si operation est "sqrt", appeler calc.safeSqrt(num1)
    // - En cas de succès, afficher "Result: " suivi du résultat
    // - Capturer les exceptions et afficher "Error: " suivi du message d'exception (utiliser what())
    // - After the try-catch, always print "Calculation complete"
    
    
    return 0;
}