CKTIS / C++
Tratamento de erros: limite de tentativas e resultado alternativo
O tratamento de erros separa a deteção de uma falha da decisão sobre o que fazer a seguir. Um exemplo determinístico com std::expected ilustra falhas transitórias e permanentes, limites de tentativas, resultados alternativos e idempotência.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
std::expected<T, E>; std::unexpected{error_value}; result.has_value(); result.error(); *result; throw expression; try { /* ... */ } catch (const Exception& e) { /* ... */ }Tratar erros consiste em assinalar uma falha e escolher uma resposta explícita. Em C++23, std::expected<T, E> contém um valor ou um erro. Verifica has_value() antes de usar *result e chama error() apenas em estado de erro. As exceções usam throw e try/catch e podem passar o controlo a um tratador compatível. Nenhum mecanismo define por si só uma política de recuperação. O sítio indicado publica um rascunho em evolução, não uma especificação fixa de C++23.
Falha transitória ou permanente: uma falha transitória, como uma indisponibilidade temporária, pode desaparecer sem alterar o pedido. Numa política de repetição de tentativas, uma falha é permanente se não for de esperar que repetir a mesma operação nas mesmas condições ajude. Por exemplo, uma operação não suportada pode exigir outra implementação ou não ter solução. A distinção depende do contrato da operação, não automaticamente do tipo de exceção. O limite de tentativas inclui a primeira: max_attempts = 3 permite repeti-la até duas vezes. Para em caso de sucesso, falha permanente ou limite atingido. Para E/S real, considera também um prazo global e pausas entre tentativas.
Idempotência significa que repetir a mesma operação tem o mesmo efeito pretendido que executá-la uma vez, sem implicar uma resposta idêntica. Se o tempo de espera se esgotar, a operação pode já ter alterado o estado. Não repitas às cegas pagamentos nem outras operações com efeitos secundários: exige uma garantia de idempotência ou a deduplicação de pedidos. Um resultado alternativo é um resultado degradado que se aceita expressamente, não um sucesso da operação original. Se não houver alternativa segura, propaga o erro.
O exemplo simula uma leitura sem efeitos secundários. run(false) obtém 42 à terceira tentativa após duas falhas transitórias. run(true) para na primeira falha permanente e mantém fallback em 7, tal como se atingisse o limite. A espera é omitida para que a demonstração seja determinística. Em produção, regista a causa e o uso da alternativa: o exemplo não é uma política de produção completa.
Exemplos
#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);
}
Resultado
value=42 attempts=3 value=7 attempts=1
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.