Was ist der Unterschied zwischen Ausgang und Rückkehr?

Was ist der Unterschied zwischen return- und exit-Anweisungen in der C-Programmierung, wenn sie von irgendwo in einem C-Programm aufgerufen werden?

• Rückkehr kehrt von der aktuellen Funktion zurück; es ist ein Sprachschlüsselwort wie for oder break.
• Ausfahrt() beendet das gesamte Programm, egal von wo aus Sie es aufrufen. (Nach dem Spülen der stdio-Puffer usw.).

Der einzige Fall, in dem beide (fast) dasselbe tun, ist in der main() Funktion, als eine Rückkehr von der Hauptleitung an führt exit().

In den meisten C-Implementierungen main ist eine echte Funktion, die von einem Startcode aufgerufen wird, der so etwas tut int ret = main(argc, argv); exit(ret);. Der C-Standard garantiert, dass etwas Äquivalentes passiert, wenn main zurückgibt, jedoch von der Implementierung verarbeitet wird.

Beispiel mit return:

#include <stdio.h>

void f(){
    printf("Executing f\n");
    return;
}

int main(){
    f();
    printf("Back from f\n");
}

Wenn Sie dieses Programm ausführen, druckt es:

Executing f
Back from f

Ein weiteres Beispiel für exit():

#include <stdio.h>
#include <stdlib.h>

void f(){
    printf("Executing f\n");
    exit(0);
}

int main(){
    f();
    printf("Back from f\n");
}

Wenn Sie dieses Programm ausführen, druckt es:

Executing f

Du bekommst nie “Zurück von f”. Beachten Sie auch die #include <stdlib.h> notwendig, um die Bibliotheksfunktion aufzurufen exit().

Beachten Sie auch, dass der Parameter von exit() ist eine Ganzzahl (es ist der Rückgabestatus des Prozesses, den der Launcher-Prozess erhalten kann; die herkömmliche Verwendung ist 0 für Erfolg oder jeder andere Wert für einen Fehler).

Der Parameter der return-Anweisung ist unabhängig vom Rückgabetyp der Funktion. Wenn die Funktion void zurückgibt, können Sie die Rückgabe am Ende der Funktion weglassen.

Letzter Punkt, exit() kommen in zwei Geschmacksrichtungen _exit() und exit(). Der Unterschied zwischen den Formen ist der exit() (und Rückkehr von main) ruft mit registrierte Funktionen auf atexit() oder on_exit() bevor der Vorgang wirklich beendet wird, während _exit() (aus #include <unistd.h>oder sein Synonym _Exit from #include <stdlib.h>) beendet den Vorgang sofort.

Jetzt gibt es auch Probleme, die spezifisch für C++ sind.

C++ führt viel mehr Arbeit aus als C, wenn es Funktionen verlässt (return-ing). Insbesondere ruft es Destruktoren von lokalen Objekten auf, die den Gültigkeitsbereich verlassen. In den meisten Fällen kümmern sich Programmierer nicht viel um den Zustand eines Programms, nachdem der Prozess gestoppt wurde, daher würde es keinen großen Unterschied machen: Zugewiesener Speicher wird freigegeben, Dateiressourcen geschlossen und so weiter. Aber es kann wichtig sein, ob Ihr Destruktor IOs ausführt. Zum Beispiel automatisches C++ OStream lokal erstellte Dateien werden bei einem Aufruf zum Beenden nicht geleert und Sie verlieren möglicherweise einige nicht geleerte Daten (andererseits statische OStream wird gespült).

Dies wird nicht passieren, wenn Sie das gute alte C verwenden FILE* Ströme. Diese werden gespült exit(). Eigentlich ist die Regel die gleiche wie für registrierte Exit-Funktionen, FILE* wird bei allen normalen Terminierungen gespült, einschließlich exit()aber nicht Anrufe zu _exit() oder abbrechen().

Sie sollten auch bedenken, dass C++ einen dritten Weg bietet, um aus einer Funktion herauszukommen: das Auslösen einer Ausnahme. Diese Art, eine Funktion zu verlassen Wille Destruktor aufrufen. Wenn sie nirgendwo in der Aufruferkette abgefangen wird, kann die Ausnahme an die Funktion main() gehen und den Prozess beenden.

Destruktoren statischer C++-Objekte (Globals) werden aufgerufen, wenn Sie eines von beiden aufrufen return aus main() oder exit() überall in Ihrem Programm. Sie werden nicht aufgerufen, wenn das Programm mit beendet wird _exit() oder abort(). abort() ist hauptsächlich im Debug-Modus nützlich, um das Programm sofort zu stoppen und einen Stack-Trace (für Post-Mortem-Analysen) zu erhalten. Es ist normalerweise hinter dem versteckt assert() Makro nur im Debug-Modus aktiv.

Wann ist exit() nützlich?

exit() bedeutet, dass Sie den aktuellen Prozess sofort stoppen möchten. Es kann für die Fehlerverwaltung von Nutzen sein, wenn wir auf ein nicht behebbares Problem stoßen, das es Ihrem Code nicht mehr ermöglicht, irgendetwas Nützliches zu tun. Es ist oft praktisch, wenn der Kontrollfluss kompliziert ist und Fehlercodes ganz nach oben weitergegeben werden müssen. Beachten Sie jedoch, dass dies eine schlechte Programmierpraxis ist. Das stillschweigende Beenden des Prozesses ist in den meisten Fällen das schlechtere Verhalten und die eigentliche Fehlerverwaltung sollte bevorzugt werden (oder in C++ mit Ausnahmen).

Direktanrufe an exit() sind besonders schlecht, wenn sie in Bibliotheken durchgeführt werden, da dies den Bibliotheksbenutzer zum Scheitern bringen wird und es die Wahl des Bibliotheksbenutzers sein sollte, eine Art Fehlerbehebung zu implementieren oder nicht. Wenn Sie ein Beispiel dafür wollen, warum Sie anrufen exit() aus einer Bibliothek ist schlecht, es führt zum Beispiel dazu, dass Leute diese Frage stellen.

Es gibt eine unbestrittene legitime Verwendung von exit() als Möglichkeit, einen untergeordneten Prozess zu beenden, der von fork() auf Betriebssystemen gestartet wurde, die dies unterstützen. Es ist normalerweise eine schlechte Idee, vor fork() zum Code zurückzukehren. Dies ist der Grund dafür, warum Funktionen der exec()-Familie niemals an den Aufrufer zurückkehren.

Ich habe zwei Programme geschrieben:

int main(){return 0;}

und

#include <stdlib.h>
int main(){exit(0)}

Nach der Ausführung gcc -S -O1. Hier, was ich beim Zusammenbau gefunden habe (nur wichtige Teile):

main:
    movl    $0, %eax    /* setting return value */
    ret                 /* return from main */

und

main:
    subq    $8, %rsp    /* reserving some space */
    movl    $0, %edi    /* setting return value */
    call    exit        /* calling exit function */
                        /* magic and machine specific wizardry after this call */

Also mein Fazit ist: verwenden return wann du kannst und exit() wenn du brauchst.

In C gibt es keinen großen Unterschied, wenn es in der Startfunktion des Programms verwendet wird (was sein kann main(), wmain(), _tmain() oder der von Ihrem Compiler verwendete Standardname).

Wenn du return in main()die Kontrolle geht zurück an die _start() Funktion in der C-Bibliothek, die ursprünglich Ihr Programm gestartet hat, die dann aufruft exit() Sowieso. Es ist also eigentlich egal, welchen du verwendest.

In den meisten Fällen gibt es in einem C-Programm keinen Unterschied zwischen der Verwendung von return und anrufen exit() zu beenden main().

Der Zeitpunkt, an dem es einen Unterschied gibt, ist, wenn Sie Code erstellt haben, der ausgeführt wird, nachdem Sie von zurückgekehrt sind main() das auf lokalen Variablen beruht main(). Eine Möglichkeit, die sich manifestiert, ist mit setvbuf():

int main(void)
{
    char buffer[BUFSIZ];
    setvbuf(stdout, buffer, _IOFBF, BUFSIZ);
    …code using stdout…
    return 0;
}

In diesem Beispiel wird der Puffer über bereitgestellt setvbuf() geht aus dem Geltungsbereich, wenn main() zurück, aber der Code, der spült und schließt stdout wird versuchen, diesen Puffer zu verwenden. Dies führt zu undefiniertem Verhalten.

Der andere Mechanismus ist das Aufrufen atexit() mit einer Funktion, die auf Daten von zugreift main() — über einen Zeiger. Dies ist schwieriger einzurichten als die Funktionen, die über die aufgerufen werden atexit() Mechanismus werden keine Argumente angegeben. Sie müssen also so etwas tun:

static void *at_exit_data = 0;

static void at_exit_handler(void)
{
    char *str = at_exit_data;
    printf("Exiting: %s\n", str);
}

int main(void);
{
    char buffer[] = "Message to be printed via functions registered with at_exit()";
    at_exit_data = buffer;
    at_exit(at_exit_handler);
    …processing…
    return 0;
}

Wieder zeigte der Puffer auf by at_exit_data nicht mehr existiert, wenn das Programm zurückkehrt main() und so ruft die Handler-Funktion undefiniertes Verhalten auf.

Es gibt eine verwandte Funktion, at_quick_exit()aber die damit registrierten Funktionen werden nur aufgerufen, wenn die quick_exit() Funktion aufgerufen wird, was verhindert, dass die Funktionen danach aufgerufen werden main() kehrt zurück.

die return-Anweisung verlässt die aktuelle Funktion und exit() verlässt das Programm

they are the same when used in main() function

Auch return ist eine Anweisung, während exit() eine Funktion ist, die die Header-Datei stdlb.h erfordert