Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Bezpieczeństwo wyjątków w C++: gwarancja podstawowa, silna i no-throw

Gwarancja podstawowa dopuszcza częściową zmianę poprawnego stanu, silna wyklucza obserwowalne skutki po wyjątku, a no-throw wyklucza propagację wyjątków do wywołującego.

Wersja: ISO C++23; implementation support may vary

Składnia

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

Gwarancja podstawowa (basic). Jeśli wyjątek opuści operację, nie dochodzi do wycieku zasobów, a niezmienniki obiektów objętych kontraktem pozostają zachowane. Poprawny stan nie musi być stanem początkowym: pierwsza z dwóch aktualizacji może pozostać widoczna, jeśli druga zgłosi wyjątek.

Gwarancja silna (strong). Jeśli wyjątek opuści operację, stan objęty kontraktem jest obserwowalnie taki sam jak przed wywołaniem. Sukces nadal może zmienić stan. W idiomie copy-and-swap najpierw tworzysz niezależną kopię i wykonujesz na niej wszystkie zmiany, które mogą zgłosić wyjątek. Jeśli przygotowanie się nie powiedzie, oryginał pozostaje nietknięty. Dopiero po udanym przygotowaniu zatwierdzasz wynik przez zamianę, która musi się powieść i nie zgłaszać wyjątków. Obiekt tymczasowy przejmuje stary stan i zwalnia go przy zniszczeniu, bez zgłaszania wyjątku.

Gwarancja no-throw. Przy spełnionych warunkach wstępnych żaden wyjątek nie dociera do wywołującego. Operacja może obsłużyć wyjątek wewnętrznie albo zgłosić niepowodzenie inaczej, na przykład kodem błędu. Specyfikator noexcept nie sprawdza poprawności implementacji ani nie zapewnia odzyskania stanu. Jeśli wyjątek próbuje opuścić funkcję zadeklarowaną z noexcept, wywoływane jest std::terminate. Operator noexcept(expr) sprawdza, czy wyrażenie jest potencjalnie rzucające, bez jego wykonywania.

Sprawdź założenia. Nie każde wywołanie std::swap jest wolne od wyjątków; sprawdź wybrane przeciążenie i jego warunki wstępne. Płytka kopia ze współdzielonym stanem mutowalnym lub nieodwracalny efekt zewnętrzny podczas przygotowania może podważyć gwarancję silną.

Przykłady

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

Wynik

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

Oba obiekty zaczynają od `1 2`. Wymuszony wyjątek po pierwszym zapisie pozostawia w `basic` poprawny stan `10 2`. W `update_strong` zmienia się tylko `staged`, więc `strong` zachowuje `1 2`. Bez wymuszonego wyjątku `commit` zatwierdza `10 20`.

Powiązane lekcje

  • C++ · Lekcja 15 · Zaawansowany · Wersja: 3

Źródła