Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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.

Fontes