Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Seguridad ante excepciones en C++: garantías básica, fuerte y no-throw

La garantía básica admite cambios parciales en un estado válido; la fuerte no deja cambios observables tras una excepción, y la garantía no-throw impide que la excepción llegue al código llamador.

Versión: ISO C++23; implementation support may vary

Sintaxis

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)));

Garantía básica (basic). Si una excepción sale de la operación, no se pierden recursos y se mantienen los invariantes de los objetos cubiertos por el contrato. Válido no significa intacto: la primera de dos actualizaciones puede seguir siendo visible si la segunda lanza una excepción.

Garantía fuerte (strong). Si una excepción sale de la operación, el estado cubierto por el contrato es, a efectos observables, el mismo que antes de la llamada. Si la operación tiene éxito, sí puede modificarlo. Con copy-and-swap, se crea una copia independiente y se realizan en ella los cambios que pueden lanzar excepciones. Si la preparación lanza una excepción, el original queda intacto. Solo cuando la preparación tiene éxito se confirma el resultado mediante un intercambio que debe completarse sin lanzar excepciones. El objeto temporal se queda con el estado anterior y lo libera al destruirse, sin lanzar excepciones.

Garantía no-throw. Si se cumplen las precondiciones, ninguna excepción llega al código llamador. La operación puede capturar excepciones internamente o comunicar un fallo de otra forma, por ejemplo mediante un código de error. El especificador noexcept no valida la implementación ni recupera el estado. Si una excepción intenta salir de una función noexcept, se invoca std::terminate. El operador noexcept(expr) comprueba si la expresión puede lanzar una excepción según las reglas del lenguaje, sin evaluarla.

Comprueba los supuestos. std::swap no está libre de excepciones en todos los casos: comprueba la sobrecarga seleccionada y sus precondiciones. Una copia superficial que comparta estado mutable o un efecto externo irreversible durante la preparación puede romper la garantía fuerte.

Ejemplos

#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 objetos empiezan con `1 2`. La excepción provocada tras la primera escritura deja `basic` en el estado válido `10 2`. En `update_strong` solo cambia `staged`, por lo que `strong` conserva `1 2`. Sin la excepción provocada, `commit` aplica `10 20`.

Lecciones relacionadas

  • C++ · Lección 15 · Avanzado · Versión: 3

Fuentes