So beenden Sie C ++ - Code

Ich möchte, dass mein C ++ - Code nicht mehr ausgeführt wird, wenn eine bestimmte Bedingung erfüllt ist, bin mir aber nicht sicher, wie ich das tun soll. Wenn also eine ifAussage wahr ist, beenden Sie den Code wie folgt:

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

Es gibt verschiedene Möglichkeiten, aber zuerst müssen Sie verstehen, warum die Objektbereinigung wichtig ist, und daher ist der Grund std::exitunter C ++ - Programmierern marginalisiert.

RAII und Stack Unwinding

C ++ verwendet eine Redewendung namens RAII , was in einfachen Worten bedeutet, dass Objekte eine Initialisierung im Konstruktor und eine Bereinigung im Destruktor durchführen sollten. Zum Beispiel diestd::ofstream Klasse die Datei während des Konstruktors öffnen, dann führt der Benutzer Ausgabeoperationen für sie aus, und schließlich wird am Ende ihres Lebenszyklus, der normalerweise durch seinen Umfang bestimmt wird, der Destruktor aufgerufen, der die Datei im Wesentlichen schließt und leert Alle auf die Festplatte geschriebenen Inhalte.

Was passiert, wenn Sie nicht zum Destruktor gelangen, um die Datei zu leeren und zu schließen? Wer weiß! Möglicherweise werden jedoch nicht alle Daten in die Datei geschrieben.

Betrachten Sie zum Beispiel diesen Code

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

Was bei jeder Möglichkeit passiert, ist:

• Möglichkeit 1: Return verlässt im Wesentlichen den aktuellen Funktionsumfang, sodass es über das Ende des Lebenszyklus osinformiert ist, indem es seinen Destruktor aufruft und eine ordnungsgemäße Bereinigung durch Schließen und Leeren der Datei auf die Festplatte durchführt.
• Möglichkeit 2: Durch das Auslösen einer Ausnahme wird auch der Lebenszyklus der Objekte im aktuellen Bereich berücksichtigt, wodurch eine ordnungsgemäße Bereinigung durchgeführt wird ...
• Möglichkeit 3: Hier tritt das Abwickeln des Stapels in Aktion! Obwohl die Ausnahme ausgelöst wird inner_mad, durchläuft der Abwickler den Stapel von madund führt maineine ordnungsgemäße Bereinigung durch. Alle Objekte werden ordnungsgemäß zerstört, einschließlich ptrund os.
• Möglichkeit 4: Nun, hier? exitist eine C-Funktion und weder bekannt noch kompatibel mit den C ++ - Redewendungen. Es werden keine Bereinigungen für Ihre Objekte durchgeführt, auch nicht osim selben Bereich. Ihre Datei wird also nicht richtig geschlossen und aus diesem Grund wird der Inhalt möglicherweise nie in sie geschrieben!
• Andere Möglichkeiten: Es verlässt nur den Hauptbereich, indem es eine implizite Ausführung durchführt return 0und somit den gleichen Effekt wie Möglichkeit 1 hat, dh eine ordnungsgemäße Bereinigung.

Aber sei dir nicht so sicher, was ich dir gerade gesagt habe (hauptsächlich Möglichkeiten 2 und 3); Lesen Sie weiter und wir werden herausfinden, wie Sie eine ordnungsgemäße ausnahmebasierte Bereinigung durchführen.

Mögliche Möglichkeiten zum Beenden

Rückkehr von der Hauptstraße!

Sie sollten dies nach Möglichkeit tun. Ziehen Sie es immer vor, von Ihrem Programm zurückzukehren, indem Sie einen ordnungsgemäßen Exit-Status von main zurückgeben.

Der Aufrufer Ihres Programms und möglicherweise das Betriebssystem möchten möglicherweise wissen, ob das, was Ihr Programm tun sollte, erfolgreich ausgeführt wurde oder nicht. Aus dem gleichen Grund sollten Sie entweder Null zurückgeben oder EXIT_SUCCESSsignalisieren, dass das Programm erfolgreich beendet wurde, und EXIT_FAILUREum zu signalisieren, dass das Programm nicht erfolgreich beendet wurde , ist jede andere Form von Rückgabewert implementierungsdefiniert ( §18.5 / 8 ).

Sie befinden sich jedoch möglicherweise sehr tief im Aufrufstapel, und es kann schmerzhaft sein, alles zurückzugeben ...

[Nicht] eine Ausnahme auslösen

Durch das Auslösen einer Ausnahme wird eine ordnungsgemäße Objektbereinigung mithilfe des Abwickelns des Stapels durchgeführt, indem der Destruktor jedes Objekts in einem früheren Bereich aufgerufen wird.

Aber hier ist der Haken ! Es ist implementierungsdefiniert, ob das Abwickeln des Stapels durchgeführt wird, wenn eine ausgelöste Ausnahme nicht behandelt wird (durch die catch (...) -Klausel) oder selbst wenn Sie eine noexceptFunktion in der Mitte des Aufrufstapels haben. Dies ist in §15.5.1 [außer.terminate] angegeben :

1. In einigen Situationen muss die Ausnahmebehandlung für weniger subtile Fehlerbehandlungstechniken abgebrochen werden. [Hinweis: Diese Situationen sind:

   [...]

   - wenn der Ausnahmebehandlungsmechanismus keinen Handler für eine ausgelöste Ausnahme finden kann (15.3) oder wenn die Suche nach einem Handler (15.3) auf den äußersten Block einer Funktion mit einer noexceptSpezifikation stößt, die die Ausnahme nicht zulässt (15.4), oder [...]

   [...]

2. In solchen Fällen heißt std :: terminate () (18.8.3). In der Situation, in der kein passender Handler gefunden wird, wird implementierungsdefiniert, ob der Stapel abgewickelt wird, bevor std :: terminate () [...] aufgerufen wird.

Also müssen wir es fangen!

Wirf eine Ausnahme und fange sie an der Hauptleitung!

Da nicht erfasste Ausnahmen möglicherweise kein Abwickeln des Stapels durchführen (und folglich keine ordnungsgemäße Bereinigung durchführen) , sollten wir die Ausnahme in main abfangen und dann einen Exit-Status zurückgeben ( EXIT_SUCCESSoderEXIT_FAILURE ) zurückgeben.

Ein möglicherweise gutes Setup wäre also:

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;
    }
    /* ... */
}

[Nicht] std :: exit

Dies führt keine Abwicklung des Stapels durch, und kein lebendes Objekt auf dem Stapel ruft seinen jeweiligen Destruktor auf, um eine Bereinigung durchzuführen.

Dies wird in §3.6.1 / 4 [basic.start.init] durchgesetzt :

Das Beenden des Programms ohne Verlassen des aktuellen Blocks (z. B. durch Aufrufen der Funktion std :: exit (int) (18.5)) zerstört keine Objekte mit automatischer Speicherdauer (12.4) . Wenn std :: exit aufgerufen wird, um ein Programm während der Zerstörung eines Objekts mit statischer oder Thread-Speicherdauer zu beenden, hat das Programm ein undefiniertes Verhalten.

Denken Sie jetzt darüber nach, warum sollten Sie so etwas tun? Wie viele Gegenstände haben Sie schmerzhaft beschädigt?

Andere [als schlechte] Alternativen

Es gibt andere Möglichkeiten, ein Programm zu beenden (außer Abstürzen) , aber sie werden nicht empfohlen. Nur zur Verdeutlichung werden sie hier vorgestellt. Beachten Sie, wie normale Programmbeendigung nicht mittleres Stack Abwickeln , sondern eine Ordnung Zustand für das Betriebssystem.

• std::_Exit verursacht eine normale Programmbeendigung, und das war's.
• std::quick_exitbewirkt eine normale Programmbeendigung und ruft std::at_quick_exitHandler auf, es wird keine weitere Bereinigung durchgeführt.
• std::exitverursacht eine normale Programmbeendigung und ruft dann std::atexitHandler auf. Andere Arten von Bereinigungen werden durchgeführt, z. B. das Aufrufen von Destruktoren für statische Objekte.
• std::abortverursacht eine abnormale Programmbeendigung, es wird keine Bereinigung durchgeführt. Dies sollte aufgerufen werden, wenn das Programm auf eine wirklich, wirklich unerwartete Weise beendet wurde. Es wird nichts anderes tun, als dem Betriebssystem die abnormale Beendigung zu signalisieren. Einige Systeme führen in diesem Fall einen Core-Dump durch.
• std::terminateruft das auf, std::terminate_handlerwas std::abortstandardmäßig aufruft .

Wie Martin York erwähnte, führt der Ausgang keine notwendige Bereinigung durch, wie dies bei der Rückgabe der Fall ist.

Es ist immer besser, die Rückgabe anstelle des Ausgangs zu verwenden. Wenn Sie sich nicht in main befinden, wo immer Sie das Programm beenden möchten, kehren Sie zuerst zu main zurück.

Betrachten Sie das folgende Beispiel. Mit dem folgenden Programm wird eine Datei mit dem genannten Inhalt erstellt. Wenn die Rückgabe jedoch kommentiert und nicht kommentiert ist (0), versichert Ihnen der Compiler nicht, dass die Datei den erforderlichen Text enthält.

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

Nicht nur das, mehrere Exit-Punkte in einem Programm erschweren das Debuggen. Verwenden Sie exit nur, wenn dies gerechtfertigt werden kann.

Rufen Sie die std::exitFunktion auf.   

Die Leute sagen "Call Exit (Rückkehrcode)", aber das ist eine schlechte Form. In kleinen Programmen ist es in Ordnung, aber es gibt eine Reihe von Problemen damit:

1. Sie werden am Ende mehrere Austrittspunkte aus dem Programm haben
2. Dadurch wird der Code komplizierter (wie bei der Verwendung von goto).
3. Es kann keinen zur Laufzeit zugewiesenen Speicher freigeben

Wirklich, das einzige Mal, wenn Sie das Problem beenden sollten, ist mit dieser Zeile in main.cpp:

return 0;

Wenn Sie exit () verwenden, um Fehler zu behandeln, sollten Sie sich mit Ausnahmen (und Verschachtelungsausnahmen) als einer viel eleganteren und sichereren Methode vertraut machen.

return 0;Setzen Sie das, wo immer Sie wollen, int main()und das Programm wird sofort geschlossen.

Das Programm wird beendet, wenn der Ausführungsablauf das Ende der Hauptfunktion erreicht.

Um es vorher zu beenden, können Sie die Funktion exit (int status) verwenden, wobei status ein Wert ist, der an den Start des Programms zurückgegeben wird. 0 zeigt normalerweise einen fehlerfreien Zustand an

Geben Sie entweder einen Wert von Ihrem zurück mainoder verwenden Sie die exitFunktion. Beide nehmen eine int. Es spielt keine Rolle, welchen Wert Sie zurückgeben, es sei denn, Sie haben einen externen Prozess, der nach dem Rückgabewert sucht.

Wenn Sie irgendwo tief im Code einen Fehler haben, lösen Sie entweder eine Ausnahme aus oder legen Sie den Fehlercode fest. Es ist immer besser, eine Ausnahme auszulösen, als Fehlercodes festzulegen.

Im Allgemeinen würden Sie die exit()Methode mit einem geeigneten Exit-Status verwenden .

Null würde einen erfolgreichen Lauf bedeuten. Ein Status ungleich Null zeigt an, dass ein Problem aufgetreten ist. Dieser Exit-Code wird von übergeordneten Prozessen (z. B. Shell-Skripten) verwendet, um festzustellen, ob ein Prozess erfolgreich ausgeführt wurde.

Über den Aufruf von exit (error_code) hinaus, der atexit-Handler, aber keine RAII-Destruktoren usw. aufruft, verwende ich immer mehr Ausnahmen.

Mein Hauptprogramm sieht immer mehr so ​​aus

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

Dabei wird sekundäres_Main dort abgelegt, wo das gesamte ursprünglich platzierte Material abgelegt wird - dh das ursprüngliche Haupt wird in sekundäres_Main umbenannt und das obige Stub-Haupt wird hinzugefügt. Dies ist nur eine Kleinigkeit, damit nicht zu viel Code zwischen dem Fach und dem Hauptfang vorhanden ist.

Wenn Sie möchten, fangen Sie andere Ausnahmetypen ab.
Ich mag es, String-Fehlertypen wie std :: string oder char * abzufangen und diese im catch-Handler in main zu drucken.

Mit solchen Ausnahmen können zumindest RAII-Destruktoren aufgerufen werden, damit sie bereinigen können. Welches kann angenehm und nützlich sein.

Insgesamt spielen C-Fehlerbehandlung - Exit und Signale - und C ++ - Fehlerbehandlung - Try / Catch / Throw-Ausnahmen - bestenfalls inkonsistent zusammen.

Dann, wo Sie einen Fehler erkennen

throw "error message"

oder ein spezifischerer Ausnahmetyp.

Wenn sich Ihre if-Anweisung in Loop befindet, können Sie verwenden

 break; 

Wenn Sie einem Code entkommen und die Schleife fortsetzen möchten, verwenden Sie:

fortsetzen;

Wenn Ihre if-Anweisung nicht in Loop ist, können Sie Folgendes verwenden:

 return 0;

Or 




  exit();

Dude ... exit()Funktion ist unter stdlib.h definiert

Sie müssen also einen Präprozessor hinzufügen.

Fügen Sie include stdlib.hden Header-Bereich ein

Verwenden exit();Sie dann, wo immer Sie möchten, aber denken Sie daran, eine Interger-Nummer in die Klammer von exit zu setzen.

beispielsweise:

exit(0);

Wenn der Zustand, auf den ich teste, wirklich schlechte Nachrichten sind, mache ich Folgendes:

*(int*) NULL= 0;

Dies gibt mir einen schönen Kern, von dem aus ich die Situation untersuchen kann.

Um eine Bedingung zu brechen, verwenden Sie die Rückgabe (0).

In Ihrem Fall wäre es also:

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