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

CKTIS / C++

Segurança face a exceções: garantias e copy-and-swap

As garantias de segurança face a exceções especificam o estado que permanece após a falha de uma operação: um estado válido, um estado inalterado ou nenhuma exceção propagada. Copy-and-swap pode oferecer a garantia forte ao preparar uma cópia antes de confirmar uma alteração.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

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

A segurança face a exceções descreve o contrato de uma operação, e não apenas a utilização de try e catch. A garantia básica (basic guarantee) preserva os invariantes dos objetos e evita fugas de recursos, mas permite que os valores se alterem após uma exceção. A garantia forte (strong guarantee) promete ainda que uma operação falhada não produz efeitos dentro do âmbito do seu contrato: ou termina por completo ou deixa esse estado inalterado.

A garantia no-throw significa que uma operação não propaga exceções. A simples utilização de noexcept não prova que os erros são tratados corretamente: uma exceção que tente sair dessa função provoca a chamada de std::terminate, em vez de reverter as alterações. As garantias são documentadas para cada operação; a presença de um catch não é suficiente para as assegurar.

Copy-and-swap implementa a segurança forte na atribuição: primeiro constrói temporary e, em seguida, confirma a alteração através de um swap que não lança exceções. Se a cópia falhar, o destino ainda não foi alterado. Após a troca, o objeto temporário contém o estado anterior e liberta-o ao ser destruído. Esta técnica exige uma cópia que não altere o original, uma troca que não lance exceções e uma destruição segura. O custo pode incluir uma cópia e uma alocação adicionais; efeitos externos, como escrever num ficheiro, não são revertidos automaticamente.

RAII associa recursos ao tempo de vida dos objetos: durante o desenrolamento da pilha, são destruídos os objetos locais já construídos. Os destrutores devem efetuar a limpeza sem propagar exceções. Se uma exceção sair de um destrutor invocado como parte do desenrolamento da pilha, é chamado std::terminate. Se, pelo contrário, um destrutor que pode lançar exceções for chamado no fluxo normal de execução do código de limpeza, um catch nesse mesmo código pode capturar uma exceção desse destrutor, mesmo que o desenrolamento da pilha devido à exceção original ainda esteja em curso. A norma exige destrutores que não lancem exceções na biblioteca padrão. As fontes fornecidas são um projeto de norma em evolução, não um texto C++23 congelado.

Identificadores de referência abrangidos por esta entrada: Basic, strong and no-throw guarantees; copy-and-swap.

Exemplos

#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

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