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 un moyen structuré de détecter et de répondre aux erreurs d'exécution. En programmation orientée objet, les exceptions s'intègrent naturellement aux hiérarchies de classes, vous permettant de créer des types d'erreurs significatifs qui transportent le contexte de 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: " << e.what() << "\n";
    }
    
    std::cout << "Balance: " << account.getBalance() << "\n";
}

La bibliothèque standard C++ fournit une hiérarchie de classes d'exception dont la racine est std::exception. Les classes dérivées courantes incluent 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 retourne un message d'erreur.

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

Défi

Facile

Construisons une calculatrice de division sécurisée 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 lance des exceptions significatives en cas de problème, puis gère ces exceptions de manière appropriée dans votre programme principal.

Vous organiserez votre code sur trois fichiers :

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

Incluez également une méthode safeSqrt(double value) qui retourne la racine carrée de la valeur. Si la valeur est négative, lancez une std::runtime_error avec le message "Cannot compute square root of negative number". Vous devrez inclure <cmath> pour la fonction sqrt.
Calculator.cpp : Implémentez les méthodes déclarées dans votre fichier d'en-tête. Assurez-vous d'inclure les en-têtes nécessaires (<stdexcept> et <cmath>) et de vérifier les conditions avant d'effectuer les opérations.
main.cpp : Lisez trois entrées (chacune sur une ligne séparée) :
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 à l'intérieur d'un bloc try. Si l'opération réussit, affichez "Result: " suivi de la valeur. Si une exception est capturée, affichez "Error: " suivi du message provenant 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 démontrer que le programme continue de s'exécuter 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 les erreurs avec élégance en capturant les exceptions et en affichant des messages significatifs, puis continue l'exécution. Ce modèle permet de garder votre gestion d'erreurs propre et votre logique principale concentrée sur le cas nominal.

Aide-mémoire

La gestion des exceptions en C++ 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 par throw, et les blocs catch gèrent des types d'exceptions spécifiques :

try {
    // Code susceptible de lever une exception
    account.withdraw(150.0);
} catch (const std::runtime_error& e) {
    std::cout << "Error: " << e.what() << "\n";
}

Lever des exceptions à partir de méthodes de classe :

void withdraw(double amount) {
    if (amount > balance) {
        throw std::runtime_error("Insufficient funds");
    }
    balance -= amount;
}

La bibliothèque standard C++ fournit des classes d'exception basées sur std::exception. Les types courants incluent :

std::runtime_error - pour les problèmes d'exécution
std::logic_error - pour les erreurs de programmation
std::invalid_argument - pour les arguments invalides

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épile (stack unwinding) - les destructeurs sont appelés pour tous les objets locaux pendant que le programme recherche un bloc catch correspondant, garantissant un nettoyage approprié.

Incluez <stdexcept> pour utiliser les classes d'exception standard.

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 l'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
    // - Intercepter les exceptions et afficher "Error: " suivi du message d'exception (utiliser what())
    // - Après le try-catch, toujours afficher "Calculation complete"
    
    
    return 0;
}