WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Fehlerbehandlung: begrenzte Wiederholungen und Ersatzwert

Fehlerbehandlung trennt das Erkennen eines Fehlers von der Entscheidung, wie es weitergeht. Ein deterministisches Beispiel mit std::expected erklärt vorübergehende und dauerhafte Fehler, begrenzte Wiederholungen, Ersatzwerte und Idempotenz.

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

Syntax

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

Fehlerbehandlung bedeutet, einen Fehlschlag zu melden und eine klare Reaktion zu wählen. In C++23 enthält std::expected<T, E> einen Wert oder einen Fehler. Prüfe vor *result mit has_value(), ob ein Wert vorliegt, und rufe error() nur im Fehlerzustand auf. Ausnahmen nutzen throw und try/catch und können die Ausführung an einen passenden Handler übergeben. Keiner der Mechanismen legt selbst fest, wie Fehler aufgefangen werden. Die angegebene Website veröffentlicht einen fortlaufend bearbeiteten Entwurf, keine festgeschriebene C++23-Spezifikation.

Vorübergehende und dauerhafte Fehler: Ein vorübergehender Fehler, etwa kurzzeitige Nichtverfügbarkeit, kann ohne Änderung der Anfrage verschwinden. Für die Wiederholungsstrategie gilt ein Fehler als dauerhaft, wenn ein erneuter Versuch derselben Operation unter unveränderten Bedingungen voraussichtlich nicht hilft. Eine nicht unterstützte Operation kann beispielsweise eine andere Implementierung erfordern, oder es gibt gar keine Lösung. Maßgeblich ist der Vertrag der Operation, nicht automatisch der Ausnahmetyp. Begrenzte Wiederholungen zählen den ersten Versuch mit: max_attempts = 3 erlaubt höchstens zwei Wiederholungen. Beende die Versuche bei Erfolg, dauerhaftem Fehler oder erreichtem Limit. Berücksichtige bei echtem I/O auch eine Gesamtfrist und Pausen zwischen den Versuchen.

Idempotenz heißt: Dieselbe Operation mehrfach auszuführen hat denselben beabsichtigten Effekt wie eine Ausführung, liefert aber nicht zwingend dieselbe Antwort. Nach einer Zeitüberschreitung kann sich der Zustand bereits geändert haben. Wiederhole Zahlungen oder andere Aktionen mit Nebenwirkungen nicht blind: Verlange garantierte Idempotenz oder eine Deduplizierung der Anfragen. Ein Ersatzwert ist ein bewusst akzeptiertes, eingeschränktes Ergebnis, kein Erfolg der ursprünglichen Operation. Ist kein Ersatz sicher, gib den Fehler weiter.

Das Beispiel simuliert einen Lesezugriff ohne Nebenwirkungen. run(false) erhält nach zwei vorübergehenden Fehlern im dritten Versuch 42. run(true) stoppt beim ersten dauerhaften Fehler und behält fallback (7), ebenso wie beim Erreichen des Limits. Für die deterministische Demo entfallen Wartezeiten. Halte im Produktivbetrieb Ursache und Ersatznutzung fest; das Beispiel ist keine vollständige Strategie dafür.

Beispiele

#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);
}

Ergebnis

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

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen