8.12 — Zatrzymanie (wcześniejsze wyjście z programu)

Ostatnią kategorią instrukcji kontroli przepływu, którą omówimy w tym rozdziale, jest zatrzymanie. A halt jest instrukcją kontroli przepływu, która kończy program. W C++ zatrzymania są implementowane jako funkcje (a nie słowa kluczowe), więc nasze instrukcje halt będą wywołaniami funkcji.

Zróbmy krótką wycieczkę i podsumujmy, co dzieje się, gdy program kończy się normalnie. Kiedy main() funkcja powraca (albo przez dotarcie do końca funkcji, albo przez return statement), dzieje się wiele różnych rzeczy.

Po pierwsze, ponieważ opuszczamy funkcję, wszystkie zmienne lokalne i parametry funkcji ulegają zniszczeniu (jak zwykle).

Następnie wywoływana jest specjalna funkcja o nazwie std::exit() , ze zwracaną wartością from main() (the status code) przekazane jako argument. Czym więc jest std::exit()?

Funkcja std::exit()

std::exit() to funkcja, która powoduje normalne zakończenie programu. Normalne zakończenie oznacza, że ​​program zakończył działanie w oczekiwany sposób. Należy zauważyć, że termin normal termination nie sugeruje niczego na temat tego, czy program odniósł sukces (po to właśnie jest status code ). Załóżmy na przykład, że piszesz program, w którym oczekiwałeś, że użytkownik wpisze nazwę pliku do przetworzenia. Jeśli użytkownik wpisał nieprawidłową nazwę pliku, program prawdopodobnie zwróci wartość różną od zera status code w celu wskazania stanu awarii, ale nadal będzie normal termination.

std::exit() wykonywał szereg funkcji czyszczących. Najpierw niszczone są obiekty o statycznym czasie przechowywania. Następnie przeprowadzane jest inne czyszczenie plików, jeśli jakieś pliki były używane. Na koniec kontrola jest zwracana z powrotem do systemu operacyjnego, z argumentem przekazywanym do std::exit() używanym jako status code.

Wywołanie std::exit() jawnie

Chociaż std::exit() jest wywoływane niejawnie po powrocie funkcji main() , std::exit() można również wywołać jawnie, aby zatrzymać program przed jego normalnym zakończeniem. Kiedy std::exit() jest wywoływane w ten sposób, będziesz musiał uwzględnić cstdlib .

Oto przykład użycia std::exit() jawnie:

#include <cstdlib> // for std::exit()
#include <iostream>

void cleanup()
{
    // code here to do any kind of cleanup required
    std::cout << "cleanup!\n";
}

int main()
{
    std::cout << 1 << '\n';
    cleanup();

    std::exit(0); // terminate and return status code 0 to operating system

    // The following statements never execute
    std::cout << 2 << '\n';

    return 0;
}

Ten program wypisuje:

1
cleanup!

Zauważ, że instrukcje po wywołaniu std::exit() nigdy nie są wykonywane, ponieważ program już zakończony.

Chociaż w powyższym programie wywołujemy std::exit() z funkcji main(), std::exit() można ją wywołać z dowolnej funkcji, aby zakończyć program w tym momencie.

std::exit() nie czyści zmiennych lokalnych

Ważna uwaga dotycząca wywoływania std::exit() jawnie: std::exit() nie czyści żadnych zmiennych lokalnych (albo w bieżącej funkcji, albo w funkcjach na stosie wywołań). Oznacza to, że wywołanie std::exit() może być niebezpieczne, jeśli Twój program polega na czyszczeniu jakichkolwiek zmiennych lokalnych.

std::atexit

Ponieważ std::exit() zakończa program natychmiast, możesz chcieć ręcznie przeprowadzić czyszczenie przed zakończeniem. W tym kontekście czyszczenie oznacza zamykanie bazy danych lub połączeń sieciowych, zwalnianie przydzielonej pamięci, zapisywanie informacji w pliku dziennika itp.

W powyższym przykładzie wywołaliśmy funkcję cleanup() , aby obsłużyć nasze zadania porządkowe. Jednak pamiętanie o ręcznym wywołaniu funkcji czyszczącej przed wywołaniem każdego wywołania metody exit() stanowi obciążenie dla programisty i jest przepisem na błędy.

Aby to ułatwić, C++ oferuje funkcję std::atexit() , która pozwala określić funkcję, która będzie automatycznie wywoływana po zakończeniu programu poprzez std::exit().

Oto przykład:

#include <cstdlib> // for std::exit()
#include <iostream>

void cleanup()
{
    // code here to do any kind of cleanup required
    std::cout << "cleanup!\n";
}

int main()
{
    // register cleanup() to be called automatically when std::exit() is called
    std::atexit(cleanup); // note: we use cleanup rather than cleanup() since we're not making a function call to cleanup() right now

    std::cout << 1 << '\n';

    std::exit(0); // terminate and return status code 0 to operating system

    // The following statements never execute
    std::cout << 2 << '\n';

    return 0;
}

Ten program ma takie same dane wyjściowe jak poprzedni przykład:

1
cleanup!

Zauważ, że przekazując cleanup() funkcję jako argument, używamy cleanup (nazwy funkcji), a nie cleanup() (co faktycznie wywołałoby tę funkcję).

Zaletą std::atexit() jest to, że musimy ją wywołać tylko raz (prawdopodobnie z poziomu funkcji main()). Ponieważ std::atexit() zostanie automatycznie wywołany przy wyjściu, nie musimy pamiętać o wywołaniu czegokolwiek przed wywołaniem std::exit().

Kilka uwag na temat std::atexit() i funkcji czyszczącej: Po pierwsze, ponieważ std::exit() jest wywoływany niejawnie, gdy main() zakończy się, wywoła to wszelkie funkcje zarejestrowane przez std::atexit() jeśli program zakończy działanie w ten sposób. Po drugie, rejestrowana funkcja nie może przyjmować żadnych parametrów ani zwracać wartości. Na koniec, możesz zarejestrować wiele funkcji czyszczących za pomocą std::atexit() jeśli chcesz, a będą one wywoływane w odwrotnej kolejności rejestracji (ostatnia zarejestrowana funkcja zostanie wywołana jako pierwsza).

std::abort i std::terminate

C++ zawiera dwie inne funkcje związane z zatrzymaniem.

Klasa std::abort() funkcja powoduje nieprawidłowe zakończenie programu. Nieprawidłowe zakończenie oznacza, że w programie wystąpił jakiś nietypowy błąd w czasie wykonywania i program nie mógł kontynuować działania. Na przykład próba podzielenia przez 0 spowoduje nieprawidłowe zakończenie. std::abort() nie powoduje żadnego czyszczenia.

#include <cstdlib> // for std::abort()
#include <iostream>

int main()
{
    std::cout << 1 << '\n';
    std::abort();

    // The following statements never execute
    std::cout << 2 << '\n';

    return 0;
}

Przypadki zobaczymy w przyszłej lekcji. 9.6 — Assert i static_assert gdzie std::abort jest wywoływana niejawnie.

Klasa std::terminate() funkcja jest zwykle używana w połączeniu z exceptions (wyjątki omówimy w późniejszym rozdziale). Chociaż funkcję std::terminate można wywołać jawnie, częściej jest ona wywoływana niejawnie, gdy wyjątek nie jest obsługiwany (oraz w kilku innych przypadkach związanych z wyjątkami). Domyślnie std::terminate() wywołania std::abort().

Kiedy należy zastosować stop?

Krótka odpowiedź brzmi „prawie nigdy”. Niszczenie obiektów lokalnych jest ważną częścią C++ (szczególnie gdy wchodzimy do klas), a żadna z wyżej wymienionych funkcji nie czyści zmiennych lokalnych. Wyjątki są lepszym i bezpieczniejszym mechanizmem obsługi przypadków błędów.