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
- WG21 P0208R0: Copy-Swap Helper (Motivation)
- WG21 N4950: Working Draft, Standard for Programming Language C++
- C++ working draft: Exception specifications [except.spec]
- C++ working draft: The std::terminate function [except.terminate]
- C++ working draft: noexcept operator [expr.unary.noexcept]
- C++ working draft: swap [utility.swap]