CKTIS / C++
Gestione degli errori: tentativi limitati e risultato di ripiego
La gestione degli errori separa il rilevamento di un fallimento dalla scelta di come reagire. Un esempio deterministico con std::expected illustra errori transitori e permanenti, tentativi limitati, ripiego e idempotenza.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
std::expected<T, E>; std::unexpected{error_value}; result.has_value(); result.error(); *result; throw expression; try { /* ... */ } catch (const Exception& e) { /* ... */ }Gestire gli errori significa segnalare un fallimento e scegliere una risposta esplicita. In C++23, std::expected<T, E> contiene un valore o un errore. Controlla has_value() prima di usare *result e chiama error() solo in stato di errore. Le eccezioni usano throw e try/catch e possono cedere il controllo a un gestore corrispondente. Nessuno dei due meccanismi definisce da solo una strategia di recupero. Il sito indicato pubblica una bozza in evoluzione, non una specifica definitiva di C++23.
Errore transitorio o permanente: un errore transitorio, come un’indisponibilità momentanea, può sparire senza modificare la richiesta. In una strategia che prevede nuovi tentativi, un errore è permanente se non ci si aspetta che ritentare la stessa operazione a condizioni invariate serva. Per esempio, un’operazione non supportata può richiedere un’implementazione diversa oppure non avere alcuna soluzione. La distinzione dipende dal contratto dell’operazione, non automaticamente dal tipo di eccezione. Il limite dei tentativi include il primo: max_attempts = 3 consente al massimo due nuovi tentativi. Fermati in caso di successo, errore permanente o limite raggiunto. Per l’I/O reale, considera anche una scadenza complessiva e pause tra i tentativi.
Idempotenza significa che ripetere la stessa operazione ha lo stesso effetto voluto di una sola esecuzione, ma non dà per forza la stessa risposta. Dopo un timeout, l’operazione potrebbe aver già cambiato lo stato. Non ripetere alla cieca pagamenti o altre operazioni con effetti collaterali: serve una garanzia di idempotenza o la deduplicazione delle richieste. Un risultato di ripiego è un esito degradato accettato esplicitamente, non un successo dell’operazione originale. Se nessun ripiego è sicuro, propaga l’errore.
L’esempio simula una lettura senza effetti collaterali. run(false) ottiene 42 al terzo tentativo dopo due errori transitori. run(true) si ferma al primo errore permanente e mantiene fallback a 7, come accadrebbe esaurendo i tentativi. L’attesa è omessa per rendere la demo deterministica. In produzione, conserva causa e uso del ripiego: l’esempio non è una strategia di produzione completa.
Esempi
#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);
}
Risultato
value=42 attempts=3 value=7 attempts=1
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.