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

CKTIS / C++

Segurança perante exceções em C++: garantias básica, forte e no-throw

A garantia básica admite alterações parciais num estado válido; a forte exclui alterações observáveis após uma exceção, e a garantia no-throw impede a propagação de exceções para o código chamador.

Versão: ISO C++23; implementation support may vary

Sintaxe

void update_basic(State& live, bool fail);
void update_strong(State& live, bool fail);
void commit(State& live, State& staged) noexcept;

// Copy-and-swap inside update_strong:
State staged = live;
update_basic(staged, fail);
commit(live, staged);

// Inside commit, check the selected swap expression without evaluating it:
static_assert(noexcept(std::swap(live, staged)));

Garantia básica (basic). Se uma exceção sair da operação, não há fugas de recursos e mantêm-se os invariantes dos objetos abrangidos pelo contrato. Válido não significa inalterado: a primeira de duas atualizações pode continuar visível se a segunda lançar uma exceção.

Garantia forte (strong). Se uma exceção sair da operação, o estado abrangido pelo contrato é, do ponto de vista observável, igual ao anterior à chamada. Em caso de sucesso, o estado pode mudar. Com copy-and-swap, cria-se uma cópia independente e fazem-se nela as alterações que podem lançar exceções. Se a preparação lançar uma exceção, o original permanece intacto. Só depois de a preparação ter sucesso se confirma o resultado com uma troca que tem de ser bem-sucedida sem lançar exceções. O objeto temporário fica com o estado anterior e liberta-o ao ser destruído, sem lançar exceções.

Garantia no-throw. Se as pré-condições forem cumpridas, nenhuma exceção chega ao código chamador. A operação pode capturar exceções internamente ou assinalar uma falha de outra forma, por exemplo através de um código de erro. O especificador noexcept não valida a implementação nem repõe o estado. Se uma exceção tentar sair de uma função noexcept, é invocado std::terminate. O operador noexcept(expr) verifica se a expressão é potencialmente capaz de lançar uma exceção, sem a avaliar.

Verifica os pressupostos. std::swap não está incondicionalmente livre de exceções: verifica a sobrecarga selecionada e as suas pré-condições. Uma cópia superficial que partilha estado mutável, ou um efeito externo irreversível durante a preparação, pode quebrar a garantia forte.

Exemplos

#include <iostream>
#include <utility>

struct State {
    int first;
    int second;
};

struct InjectedFailure {};

void update_basic(State& live, bool fail) {
    live.first = 10;
    if (fail) {
        throw InjectedFailure{};
    }
    live.second = 20;
}

void commit(State& live, State& staged) noexcept {
    static_assert(noexcept(std::swap(live, staged)));
    std::swap(live, staged);
}

void update_strong(State& live, bool fail) {
    State staged = live;
    update_basic(staged, fail);
    commit(live, staged);
}

void print(const char* label, const State& state) {
    std::cout << label << ": " << state.first << ' ' << state.second << '\n';
}

int main() {
    State basic{1, 2};
    State strong{1, 2};

    try {
        update_basic(basic, true);
    } catch (const InjectedFailure&) {
        print("basic failure", basic);
    }

    try {
        update_strong(strong, true);
    } catch (const InjectedFailure&) {
        print("strong failure", strong);
    }

    update_strong(strong, false);
    print("strong success", strong);
}

Resultado

basic failure: 10 2
strong failure: 1 2
strong success: 10 20

Ambos os objetos começam em `1 2`. A exceção provocada após a primeira escrita deixa `basic` no estado válido `10 2`. Em `update_strong`, só `staged` muda, pelo que `strong` conserva `1 2`. Sem a exceção provocada, `commit` aplica `10 20`.

Lições relacionadas

  • C++ · Lição 15 · Avançado · Versão: 3

Fontes