Gestion des erreurs en C++ : try/catch et techniques avancées

Gestion des erreurs en C++ : de try/catch aux approches modernes

Le mécanisme des exceptions en C++ est un outil puissant, mais qui nécessite une compréhension approfondie. Alors que l'utilisation de base de try/catch est connue de la plupart des développeurs, la gestion professionnelle des erreurs inclut bien plus : des garanties de sécurité des exceptions aux stratégies alternatives sans exceptions. Dans cet article, nous analyserons les techniques avancées de gestion des erreurs en C++ moderne.

1. Garanties de sécurité des exceptions : le fondement d'un code fiable

Toute fonction pouvant lever une exception doit fournir l'une des trois garanties de sécurité suivantes :

\n
• Garantie de base (Basic Guarantee) : en cas d'exception, les invariants de l'objet sont préservés, il n'y a pas de fuite de ressources. L'objet peut se trouver dans un état imprévisible mais valide.
\n
• Garantie forte (Strong Guarantee) : l'opération est soit entièrement exécutée, soit l'état du programme reste inchangé (atomicité). Elle est obtenue via l'idiome copy-and-swap.
\n
• Garantie sans exception (Noexcept Guarantee) : la fonction ne lève jamais d'exceptions. Essentielle pour les destructeurs, les opérations de déplacement et les opérations utilisées dans les conteneurs.
\n

// Exemple de garantie forte via copy-and-swap\nclass Vector {\n    int* data;\n    size_t sz, cap;\npublic:\n    void push_back(int value) {\n        if (sz == cap) {\n            // 1. Création d'une copie\n            Vector tmp(*this);\n            // 2. Modification de la copie (peut lever une exception)\n            tmp.reserve(cap * 2);\n            // 3. Échange (noexcept !)\n            swap(tmp);\n        }\n        data[sz++] = value;  // noexcept\n    }\n    \n    void swap(Vector& other) noexcept {\n        std::swap(data, other.data);\n        std::swap(sz, other.sz);\n        std::swap(cap, other.cap);\n    }\n};

2. RAII comme base de la gestion des ressources

L'idiome RAII (Resource Acquisition Is Initialization) ne se limite pas aux pointeurs intelligents. C'est un principe fondamental permettant d'éviter les fuites de ressources lors des exceptions :

\n
• La ressource est acquise dans le constructeur
\n
• Elle est libérée dans le destructeur (qui est par défaut noexcept)
\n
• Une exception dans le destructeur est un UB (comportement indéfini)
\n

// Wrapper RAII pour un descripteur de fichier\nclass FileDescriptor {\n    int fd;\npublic:\n    explicit FileDescriptor(const char* path) \n        : fd(open(path, O_RDONLY)) {\n        if (fd == -1) throw std::runtime_error("Échec de l'ouverture du fichier");\n    }\n    \n    ~FileDescriptor() noexcept {\n        if (fd != -1) close(fd);\n    }\n    \n    // Interdiction de la copie, autorisation du déplacement\n    FileDescriptor(FileDescriptor&& other) noexcept : fd(other.fd) {\n        other.fd = -1;\n    }\n};

3. Alternatives modernes aux exceptions : std::optional et std::expected

Toutes les erreurs ne doivent pas être traitées via des exceptions. Pour les erreurs attendues (saisie incorrecte, absence de données), il est préférable d'utiliser des types wrappers :

#include <optional>\n#include <expected>  // C++23\n\n// std::optional — pour les valeurs optionnelles\nstd::optional<int> safe_divide(int a, int b) {\n    if (b == 0) return std::nullopt;\n    return a / b;\n}\n\n// std::expected — pour les erreurs avec information (C++23)\nstd::expected<double, std::string> sqrt_checked(double x) {\n    if (x < 0) return std::unexpected("Entrée négative");\n    return std::sqrt(x);\n}\n\n// Utilisation\nauto result = safe_divide(10, 0);\nif (result) {\n    std::cout << *result;\n} else {\n    std::cout << "Division par zéro";\n}

4. noexcept : spécification et optimisations

Le spécificateur noexcept n'est pas qu'une simple documentation. Il impacte les performances et