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

CKTIS / C++

Seguridad frente a excepciones: garantías y copy-and-swap

Las garantías de seguridad frente a excepciones especifican qué estado queda tras fallar una operación: un estado válido, uno sin cambios o ninguna excepción propagada. Copy-and-swap puede ofrecer la garantía fuerte al preparar una copia antes de confirmar un cambio.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

T& operator=(const T& other) { T temporary(other); swap(temporary); return *this; }
void swap(T& other) noexcept;

La seguridad frente a excepciones describe el contrato de una operación, no solo el uso de try y catch. La garantía básica (basic guarantee) conserva las invariantes de los objetos y evita fugas de recursos, pero permite que los valores cambien después de una excepción. La garantía fuerte (strong guarantee) también promete que una operación fallida no produce efectos dentro del alcance de su contrato: o bien termina por completo o deja ese estado sin cambios.

La garantía de no lanzamiento (no-throw) significa que una operación no propaga excepciones. Escribir noexcept por sí solo no demuestra que la gestión de errores sea correcta: si una excepción intenta salir de esa función, se invoca std::terminate en lugar de deshacer los cambios. Las garantías se documentan para cada operación; la mera presencia de un catch no las establece.

Copy-and-swap aplica la seguridad fuerte a la asignación: primero construye temporary y después confirma el cambio mediante un swap que no lanza excepciones. Si falla la copia, el destino aún no se ha modificado. Tras el intercambio, el objeto temporal contiene el estado anterior y lo libera al destruirse. Esta técnica requiere copiar sin modificar el original, realizar un intercambio que no lance excepciones y destruir de forma segura. El coste puede incluir una copia y una asignación de memoria adicionales; los efectos externos, como escribir en un archivo, no se deshacen automáticamente.

RAII vincula los recursos a la duración de vida de los objetos: durante el desenrollado de la pila se destruyen los objetos locales ya construidos. Los destructores deberían limpiar sin propagar excepciones. Si una excepción sale de un destructor invocado como parte del desenrollado de la pila, se llama a std::terminate. En cambio, si el código de limpieza llama en su flujo normal a un destructor que puede lanzar excepciones, un catch dentro de ese mismo código puede capturar una excepción de ese destructor, aunque aún se esté desenrollando la pila a causa de la excepción original. El estándar exige destructores que no lancen excepciones en la biblioteca estándar. Las fuentes proporcionadas son un borrador de estándar en evolución, no un texto C++23 inmutable.

Identificadores de referencia incluidos en esta entrada: Basic, strong and no-throw guarantees; copy-and-swap.

Ejemplos

#include <iostream>

struct CopyFailure {};

class Value {
    int number_;
public:
    inline static bool fail_copy = false;

    explicit Value(int number) noexcept : number_(number) {}

    Value(const Value& other) : number_(other.number_) {
        if (fail_copy) throw CopyFailure{};
    }

    void swap(Value& other) noexcept {
        int old = number_;
        number_ = other.number_;
        other.number_ = old;
    }

    Value& operator=(const Value& other) {
        Value temporary(other);
        swap(temporary);
        return *this;
    }

    int get() const noexcept { return number_; }
};

int main() {
    Value target(7), source(42);
    Value::fail_copy = true;
    try {
        target = source;
    } catch (const CopyFailure&) {
        std::cout << "after failure: " << target.get() << '\n';
    }
    Value::fail_copy = false;
    target = source;
    std::cout << "after success: " << target.get() << '\n';
}

Resultado

after failure: 7
after success: 42

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes