CKTIS / C++
Foutafhandeling: beperkt opnieuw proberen en terugvalresultaat
Bij foutafhandeling staan het vaststellen van een fout en de keuze wat je daarna doet los van elkaar. Een deterministisch voorbeeld met std::expected illustreert tijdelijke en permanente fouten, beperkt opnieuw proberen, terugval en idempotentie.
Versie: 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) { /* ... */ }Bij foutafhandeling meld je dat iets is mislukt en kies je expliciet hoe je reageert. In C++23 bevat std::expected<T, E> een waarde of een fout. Controleer has_value() vóór *result en roep error() alleen aan als er een fout is. Excepties gebruiken throw en try/catch en kunnen de besturing overdragen aan een passende handler. Geen van beide mechanismen bepaalt zelf het herstelbeleid. De genoemde site publiceert een ontwerp dat nog verandert, geen vastgelegde C++23-specificatie.
Tijdelijke of permanente fout: een tijdelijke fout, zoals kortdurende onbeschikbaarheid, kan verdwijnen zonder het verzoek aan te passen. Bij het bepalen of je opnieuw moet proberen, geldt een fout als permanent als je niet verwacht dat het helpt om dezelfde bewerking onder ongewijzigde omstandigheden te herhalen. Zo kan een niet-ondersteunde bewerking een andere implementatie vereisen, of kan er helemaal geen oplossing zijn. Het contract van de bewerking bepaalt het onderscheid, niet automatisch het exceptietype. Beperkt opnieuw proberen telt ook de eerste poging mee: max_attempts = 3 laat hoogstens twee herpogingen toe. Stop bij succes, een permanente fout of het bereiken van de limiet. Houd bij echte I/O ook rekening met een totale deadline en pauzes tussen pogingen.
Idempotentie betekent dat herhaling van dezelfde bewerking hetzelfde beoogde effect heeft als één uitvoering, maar niet per se hetzelfde antwoord geeft. Na een time-out kan de toestand al veranderd zijn. Herhaal betalingen of andere bewerkingen met neveneffecten niet blind: eis gegarandeerde idempotentie of deduplicatie van verzoeken. Een terugvalresultaat is bewust aanvaard als minder goed resultaat, geen succes van de oorspronkelijke bewerking. Geef de fout door als geen terugvaloptie veilig is.
Het voorbeeld simuleert lezen zonder neveneffecten. run(false) krijgt na twee tijdelijke fouten bij de derde poging 42. run(true) stopt bij de eerste permanente fout en behoudt fallback op 7, net als bij het bereiken van de limiet. Voor een deterministische demo is wachten weggelaten. Leg in productie de oorzaak en het gebruik van de terugval vast; dit voorbeeld is geen volledig productiebeleid.
Voorbeelden
#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);
}
Resultaat
value=42 attempts=3 value=7 attempts=1
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.