Jak zakończyć kod C ++

Chciałbym, aby mój kod C ++ przestał działać, jeśli zostanie spełniony określony warunek, ale nie jestem pewien, jak to zrobić. Więc w dowolnym momencie, jeśli ifinstrukcja jest prawdziwa, zakończ kod w następujący sposób:

if (x==1)
{
    kill code;
}

Istnieje kilka sposobów, ale najpierw musisz zrozumieć, dlaczego czyszczenie obiektów jest ważne, a zatem powód std::exitjest marginalizowany wśród programistów C ++.

RAII i rozwijanie stosu

C ++ korzysta z idiomu zwanego RAII , co w uproszczeniu oznacza, że ​​obiekty powinny wykonywać inicjalizację w konstruktorze i czyszczenie w destruktorze. Na przykład std::ofstreamklasa [może] otworzyć plik podczas konstruktora, a następnie użytkownik wykonuje na nim operacje wyjściowe, a na końcu pod koniec swojego cyklu życia, zwykle określanego przez jego zakres, wywoływany jest destruktor, który zasadniczo zamyka plik i opróżnia dowolna zapisana zawartość na dysk.

Co się stanie, jeśli nie dojdziesz do destruktora, aby opróżnić i zamknąć plik? Kto wie! Ale możliwe, że nie zapisze wszystkich danych, które miał zapisać w pliku.

Na przykład rozważ ten kod

#include <fstream>
#include <exception>
#include <memory>

void inner_mad()
{
    throw std::exception();
}

void mad()
{
    auto ptr = std::make_unique<int>();
    inner_mad();
}

int main()
{
    std::ofstream os("file.txt");
    os << "Content!!!";

    int possibility = /* either 1, 2, 3 or 4 */;

    if(possibility == 1)
        return 0;
    else if(possibility == 2)
        throw std::exception();
    else if(possibility == 3)
        mad();
    else if(possibility == 4)
        exit(0);
}

W każdej możliwości dzieje się:

• Możliwość 1: Return zasadniczo opuszcza bieżący zakres funkcji, więc wie o zakończeniu cyklu życia, w osten sposób wywołując swój destruktor i wykonując prawidłowe czyszczenie przez zamknięcie i opróżnienie pliku na dysk.
• Możliwość 2: Zgłoszenie wyjątku zajmuje się także cyklem życia obiektów w bieżącym zakresie, tym samym wykonując prawidłowe czyszczenie ...
• Możliwość 3: Tutaj rozwija się rozwijanie stosu! Nawet jeśli zostanie zgłoszony wyjątek inner_mad, odwijak przejdzie przez stos madi mainaby wykonać prawidłowe czyszczenie, wszystkie obiekty zostaną zniszczone poprawnie, w tym ptri os.
• Możliwość 4: Cóż, tutaj? exitjest funkcją C i nie jest świadomy ani zgodny z idiomami C ++. To nie wykonywać porządki na swoich obiektach, w tym osw tym samym zakresie. Dlatego Twój plik nie zostanie poprawnie zamknięty i z tego powodu treść może nigdy nie zostać w nim zapisana!
• Inne możliwości: Po prostu opuści główny zakres, wykonując domniemanie, return 0a tym samym dając taki sam efekt jak możliwość 1, tj. Prawidłowe czyszczenie.

Ale nie bądźcie tak pewni tego, co wam powiedziałem (głównie możliwości 2 i 3); kontynuuj czytanie, a dowiemy się, jak przeprowadzić prawidłowe czyszczenie oparte na wyjątkach.

Możliwe sposoby zakończenia

Wróć z głównego!

Powinieneś to zrobić, gdy tylko jest to możliwe; zawsze wolisz wracać ze swojego programu, zwracając odpowiedni status wyjścia z głównego.

Program wywołujący Twój program i być może system operacyjny mogą chcieć wiedzieć, czy to, co program miał zrobić, zostało wykonane pomyślnie, czy nie. Z tego samego powodu powinieneś zwrócić zero lub EXIT_SUCCESSaby zasygnalizować, że program został pomyślnie zakończony i EXIT_FAILUREaby zasygnalizować, że program zakończył się niepowodzeniem, każda inna forma wartości zwracanej jest zdefiniowana w implementacji ( § 18.5 / 8 ).

Jednak możesz być bardzo głęboko w stosie wywołań, a zwracanie wszystkiego może być bolesne ...

[Nie] zgłaszaj wyjątku

Zgłoszenie wyjątku wykona prawidłowe czyszczenie obiektu za pomocą rozwijania stosu, wywołując destruktor każdego obiektu w dowolnym poprzednim zakresie.

Ale oto haczyk ! Jest zdefiniowane w implementacji, czy odwijanie stosu jest wykonywane, gdy zgłoszony wyjątek nie jest obsługiwany (przez klauzulę catch (...)), a nawet jeśli masz noexceptfunkcję w środku stosu wywołań. Jest to określone w §15.5.1 [z wyjątkiem terminów] :

1. W niektórych sytuacjach należy zrezygnować z obsługi wyjątków dla mniej subtelnych technik obsługi błędów. [Uwaga: Te sytuacje to:

   [...]

   - gdy mechanizm obsługi wyjątków nie może znaleźć procedury obsługi zgłoszonego wyjątku (15.3), lub gdy wyszukiwanie funkcji obsługi (15.3) napotka najbardziej zewnętrzny blok funkcji o parametrze noexcept-specyfikacja , która nie zezwala na wyjątek (15.4), lub [...]

   [...]

2. W takich przypadkach wywoływana jest funkcja std :: terminate () (18.8.3). W sytuacji, gdy nie znaleziono pasującego modułu obsługi, jest zdefiniowane w implementacji, czy stos jest rozwijany przed wywołaniem std :: terminate () [...]

Więc musimy to złapać!

Rzuć wyjątek i złap go w pozycji głównej!

Ponieważ niewyłapane wyjątki mogą nie powodować rozwijania stosu (a tym samym nie będą wykonywać właściwego czyszczenia) , powinniśmy wychwycić wyjątek w main, a następnie zwrócić status wyjścia ( EXIT_SUCCESSlub EXIT_FAILURE).

Prawdopodobnie dobrym rozwiązaniem byłoby:

int main()
{
    /* ... */
    try
    {
        // Insert code that will return by throwing a exception.
    }
    catch(const std::exception&)  // Consider using a custom exception type for intentional
    {                             // throws. A good idea might be a `return_exception`.
        return EXIT_FAILURE;
    }
    /* ... */
}

[Nie] std :: exit

Nie powoduje to żadnego rozwijania stosu i żaden żywy obiekt na stosie nie wywoła odpowiedniego niszczyciela w celu przeprowadzenia czyszczenia.

Jest to egzekwowane w §3.6.1 / 4 [basic.start.init] :

Zakończenie programu bez opuszczania bieżącego bloku (np. Przez wywołanie funkcji std :: exit (int) (18.5)) nie niszczy żadnych obiektów z automatycznym czasem przechowywania (12.4) . Jeśli std :: exit zostanie wywołane w celu zakończenia programu podczas niszczenia obiektu o czasie przechowywania statycznym lub wątkowym, program ma niezdefiniowane zachowanie.

Pomyśl o tym teraz, dlaczego zrobiłbyś coś takiego? Ile przedmiotów boleśnie uszkodziłeś?

Inne [złe] alternatywy

Istnieją inne sposoby zakończenia programu (inne niż zawieszanie się) , ale nie są zalecane. Dla wyjaśnienia zostaną tutaj przedstawione. Zwróć uwagę, że normalne zakończenie programu nie oznacza rozwijania stosu, ale dobry stan systemu operacyjnego.

• std::_Exit powoduje normalne zakończenie programu i to wszystko.
• std::quick_exitpowoduje normalne zakończenie programu i wywołuje std::at_quick_exitprocedury obsługi, żadne inne czyszczenie nie jest wykonywane.
• std::exitpowoduje normalne zakończenie programu, a następnie wywołuje programy std::atexitobsługi. Przeprowadzane są inne rodzaje porządków, takie jak wywoływanie destrukcyjnych obiektów statycznych.
• std::abortpowoduje nieprawidłowe zakończenie programu, żadne czyszczenie nie jest wykonywane. Należy to wywołać, jeśli program zakończy się w naprawdę, naprawdę nieoczekiwany sposób. Nie zrobi nic poza zasygnalizowaniem systemu operacyjnego o nienormalnym zakończeniu. W tym przypadku niektóre systemy wykonują zrzut pamięci.
• std::terminatewywołuje te, std::terminate_handlerktóre std::abortdomyślnie wywołują .

Jak wspomniał Martin York, wyjście nie wykonuje koniecznego czyszczenia, tak jak robi to return.

Zawsze lepiej jest użyć powrotu w miejscu wyjścia. Jeśli nie jesteś w Main, gdziekolwiek chcesz wyjść z programu, wróć najpierw do Main.

Rozważ poniższy przykład. W następującym programie zostanie utworzony plik z wymienioną zawartością. Ale jeśli komentowany jest return i niekomentowane wyjście (0), kompilator nie zapewnia, że ​​plik będzie zawierał wymagany tekst.

int main()
{
    ofstream os("out.txt");
    os << "Hello, Can you see me!\n";
    return(0);
    //exit(0);
}

Nie tylko to, posiadanie wielu punktów wyjścia w programie utrudni debugowanie. Wyjścia używaj tylko wtedy, gdy jest to uzasadnione.

Wywołaj std::exitfunkcję.   

Ludzie mówią „call exit (kod powrotu)”, ale to zła forma. W małych programach jest w porządku, ale jest z tym wiele problemów:

1. W rezultacie będziesz mieć wiele punktów wyjścia z programu
2. Sprawia, że ​​kod jest bardziej skomplikowany (jak używanie goto)
3. Nie można zwolnić pamięci przydzielonej w czasie wykonywania

Naprawdę, jedynym wyjściem z problemu jest wyjście z tego wiersza w main.cpp:

return 0;

Jeśli używasz metody exit () do obsługi błędów, powinieneś dowiedzieć się o wyjątkach (i zagnieżdżaniu wyjątków), jako o wiele bardziej eleganckiej i bezpiecznej metodzie.

return 0;umieść to w dowolnym miejscu, int main()a program natychmiast się zamknie.

Program zakończy się, gdy przepływ wykonania osiągnie koniec głównej funkcji.

Aby go wcześniej zakończyć, możesz użyć funkcji exit (int status), gdzie status jest wartością zwracaną do tego, co uruchomiło program. 0 zwykle oznacza stan bez błędu

Albo zwróć wartość z twojego, mainalbo użyj exitfunkcji. Oba przyjmują int. Tak naprawdę nie ma znaczenia, jaką wartość zwracasz, chyba że masz zewnętrzny proces sprawdzający wartość zwracaną.

Jeśli masz błąd gdzieś głęboko w kodzie, albo rzuć wyjątek, albo ustaw kod błędu. Zawsze lepiej jest wyrzucić wyjątek niż ustawić kody błędów.

Zasadniczo użyłbyś tej exit()metody z odpowiednim statusem wyjścia .

Zero oznaczałoby udany bieg. Niezerowy status wskazuje, że wystąpił jakiś problem. Ten kod zakończenia jest używany przez procesy nadrzędne (np. Skrypty powłoki) w celu ustalenia, czy proces został pomyślnie uruchomiony.

Poza wywoływaniem exit (kod_błędu) - który wywołuje programy obsługi atexit, ale nie destruktory RAII itp. - coraz częściej używam wyjątków.

Coraz bardziej wygląda mój główny program

int main(int argc, char** argv) 
{
    try {
        exit( secondary_main(argc, argv );
    }
    catch(...) {
        // optionally, print something like "unexpected or unknown exception caught by main"
        exit(1);
    }
}

gdzie minor_main w miejscu, gdzie wszystkie rzeczy, które zostały pierwotnie umieszczone - tj. pierwotny main jest przemianowany na wtórny_main i dodawany jest kod główny powyżej. Jest to po prostu drobiazg, aby nie było za dużo kodu między szufladą a połowem w głównym.

Jeśli chcesz, złap inne typy wyjątków.
Bardzo lubię łapać typy błędów łańcucha, takie jak std :: string lub char *, i drukować je w module obsługi catch w main.

Korzystanie z takich wyjątków pozwala przynajmniej wywoływać destruktory RAII, aby mogli wykonać czyszczenie. Co może być przyjemne i przydatne.

Ogólnie rzecz biorąc, obsługa błędów C - wyjście i sygnały - oraz obsługa błędów C ++ - wyjątki try / catch / throw - w najlepszym przypadku grają niespójnie.

Następnie wykrywasz błąd

throw "error message"

lub jakiś bardziej szczegółowy typ wyjątku.

Jeśli instrukcja if znajduje się w pętli, możesz jej użyć

 break; 

Jeśli chcesz uciec trochę kodu i kontynuować pętlę Użyj:

kontyntynuj;

Jeśli instrukcja if nie znajduje się w pętli, możesz użyć:

 return 0;

Or 




  exit();

Koleś ... exit()funkcja jest zdefiniowana w stdlib.h

Musisz więc dodać preprocesor.

Umieść include stdlib.hw sekcji nagłówka

Następnie używaj exit();gdziekolwiek chcesz, ale pamiętaj, aby wstawić liczbę interger w nawiasie wyjścia.

na przykład:

exit(0);

Jeśli warunek, który testuję, jest naprawdę złą wiadomością, robię to:

*(int*) NULL= 0;

To daje mi niezły rdzeń, z którego mogę zbadać sytuację.

Aby przełamać warunek, użyj return (0);

W twoim przypadku byłoby to:

    if(x==1)
    {
        return 0;
    }