Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Gestion des erreurs : tentatives limitées et résultat de repli

La gestion des erreurs distingue la détection d’un échec du choix de la réponse. Un exemple déterministe avec std::expected illustre les échecs temporaires et permanents, les tentatives limitées, le repli et l’idempotence.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

std::expected<T, E>; std::unexpected{error_value}; result.has_value(); result.error(); *result; throw expression; try { /* ... */ } catch (const Exception& e) { /* ... */ }

Gérer une erreur, c’est signaler un échec et choisir une réponse explicite. En C++23, std::expected<T, E> contient une valeur ou une erreur. Vérifie has_value() avant *result et n’appelle error() qu’en cas d’erreur. Les exceptions utilisent throw et try/catch et peuvent passer la main à un gestionnaire correspondant. Aucun de ces mécanismes ne définit à lui seul la stratégie de récupération. Le site indiqué publie un brouillon évolutif, pas une spécification figée de C++23.

Échec temporaire ou permanent : un échec temporaire, comme une indisponibilité passagère, peut disparaître sans modifier la requête. Dans une stratégie de relance, un échec est permanent s’il est peu probable que retenter la même opération dans des conditions inchangées aide. Par exemple, une opération non prise en charge peut nécessiter une autre implémentation ou ne pas avoir de solution du tout. La distinction dépend du contrat de l’opération, pas automatiquement du type d’exception. Limiter les tentatives, c’est compter aussi la première : max_attempts = 3 permet au plus deux nouvelles tentatives. Arrête-toi en cas de succès, d’échec permanent ou de limite atteinte. Pour de vraies E/S, prévois aussi une échéance globale et des pauses entre les tentatives.

Idempotence : répéter la même opération a le même effet voulu que l’exécuter une fois, sans forcément donner la même réponse. Après un dépassement de délai, l’état peut déjà avoir changé. Ne relance pas à l’aveugle un paiement ou une autre opération à effets de bord : exige une garantie d’idempotence ou une déduplication des requêtes. Un résultat de repli est un résultat dégradé jugé acceptable, pas un succès de l’opération initiale. Si aucun repli n’est sûr, propage l’erreur.

L’exemple simule une lecture sans effets de bord. run(false) obtient 42 au troisième essai après deux échecs temporaires. run(true) s’arrête au premier échec permanent et conserve fallback à 7, comme si la limite était atteinte. L’attente est omise pour une démo déterministe. En production, garde une trace de la cause et du recours au repli : cet exemple n’est pas une stratégie de production complète.

Exemples

#include <expected>
#include <iostream>

enum class Error { transient, permanent };

std::expected<int, Error> fetch(int attempt, bool denied) {
    if (denied) return std::unexpected(Error::permanent);
    if (attempt < 3) return std::unexpected(Error::transient);
    return 42;
}

void run(bool denied) {
    constexpr int max_attempts = 3;
    constexpr int fallback = 7;
    int value = fallback;
    int attempts = 0;

    for (int attempt = 1; attempt <= max_attempts; ++attempt) {
        ++attempts;
        auto result = fetch(attempt, denied);
        if (result.has_value()) {
            value = *result;
            break;
        }
        if (result.error() == Error::permanent) break;
    }

    std::cout << "value=" << value << " attempts=" << attempts << '\n';
}

int main() {
    run(false);
    run(true);
}

Résultat

value=42 attempts=3
value=7 attempts=1

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources