istruzione return vs exit () in main ()

Dovrei usare exit()o solo returndichiarazioni in main()? Personalmente preferisco le returnaffermazioni perché sento che è come leggere qualsiasi altra funzione e il controllo del flusso quando sto leggendo il codice è fluido (secondo me). E anche se voglio refactoring la main()funzione, avere returnsembra una scelta migliore di exit().

Fa exit()qualcosa di speciale che returnnon lo fa?

In realtà, non v'è una differenza, ma è sottile. Ha più implicazioni per C ++, ma le differenze sono importanti.

Quando chiamo returnin main(), distruttori saranno chiamati per i miei oggetti con ambito a livello locale. Se chiamo exit(), nessun distruttore verrà chiamato per i miei oggetti con ambito locale! Rileggilo. exit() non ritorna . Ciò significa che una volta che lo chiamo, non ci sono "backsies". Gli oggetti che hai creato in quella funzione non verranno distrutti. Spesso questo non ha implicazioni, ma a volte lo fa, come chiudere i file (sicuramente vuoi che tutti i tuoi dati vengano scaricati su disco?).

Si noti che gli staticoggetti verranno ripuliti anche se si chiama exit(). Infine, nota che, se lo usi abort(), nessun oggetto verrà distrutto. Cioè, nessun oggetto globale, nessun oggetto statico e nessun oggetto locale avranno i loro distruttori chiamati.

Procedere con cautela nel favorire l'uscita rispetto al ritorno.

http://groups.google.com/group/gnu.gcc.help/msg/8348c50030cfd15a

Un'altra differenza: exitè una funzione di libreria standard, quindi è necessario includere intestazioni e collegamento con la libreria standard. Per illustrare (in C ++), questo è un programma valido:

int main() { return 0; }

ma per usare exitavrai bisogno di includere:

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

Inoltre questo aggiunge un ulteriore presupposto: che chiamare exitda mainha gli stessi effetti collaterali di restituire zero. Come altri hanno sottolineato, questo dipende dal tipo di eseguibile che stai costruendo (ad esempio, chi sta chiamando main). Stai codificando un'app che utilizza C-runtime? Un plugin Maya? Un servizio Windows? Un autista? Ogni caso richiederà una ricerca per vedere se exitè equivalente a return. L'uso di IMHO exitquando intendi davvero return rende il codice più confuso. OTOH, se davvero intendi exit , allora usalo sicuramente.

Esiste almeno un motivo per preferire exit: se uno dei tuoi atexitgestori fa riferimento a dati di durata della memorizzazione automatica in main, o se hai utilizzato setvbufo setbufper assegnare a uno dei flussi standard un buffer di durata della memorizzazione automatica main, quindi il ritorno da mainproduce comportamento indefinito, ma la chiamata exitè valida.

Un altro potenziale utilizzo (di solito riservato ai programmi giocattolo, tuttavia) è quello di uscire da un programma con invocazioni ricorsive di main.

Uso sempre returnperché il prototipo standard per main()dice che restituisce un int.

Detto questo, alcune versioni degli standard offrono mainun trattamento speciale e presumono che restituisca 0 se non vi sono returndichiarazioni esplicite . Dato il seguente codice:

int foo() {}
int main(int argc, char *argv[]) {}

G ++ genera solo un avviso per foo()e ignora il ritorno mancante da main:

% g++ -Wall -c foo.cc
foo.cc: In function ‘int foo()’:
foo.cc:1: warning: control reaches end of non-void function

I FORTEMENTE secondo il commento di R. sull'utilizzo uscita () in modo da non dover memorizzazione automatica nella main()bonificata prima effettivamente il programma termina. Una return X;dichiarazione main()non è esattamente equivalente a una chiamata a exit(X);, dal momento che l'archiviazione dinamica dei main()svanisce quando main()ritorni, ma non svanire se una chiamata a exit()è fatto, invece.

Inoltre, in C o in qualsiasi linguaggio simile a C returnun'affermazione suggerisce fortemente al lettore che l'esecuzione continuerà nella funzione chiamante, e mentre questa continuazione dell'esecuzione è di solito tecnicamente vera se si considera la routine di avvio C che ha chiamato la propria main()funzione, non è esattamente che cosa si intende quando si intende terminare il processo.

Dopotutto, se vuoi terminare il tuo programma da qualsiasi altra funzione tranne main()che devi chiamare exit(). Fare altrettanto in modo coerente main()rende il tuo codice molto più leggibile, e rende anche molto più facile per chiunque ricodificare il tuo codice; cioè il codice copiato da main()un'altra funzione non si comporterà a causa di returndichiarazioni accidentali che avrebbero dovuto essere exit()chiamate.

Quindi, combinando tutti questi punti insieme la conclusione è che è una cattiva abitudine , almeno per C, usare areturn un'istruzione per terminare il programma main().

Exit () fa qualcosa di speciale che "return" non fa?

Con alcuni compilatori per piattaforme non comuni, exit()potrebbe tradurre il suo argomento nel valore di uscita del programma durante un ritorno damain() potrebbe semplicemente passare il valore direttamente all'ambiente host senza alcuna traduzione.

Lo standard richiede un comportamento identico in questi casi (in particolare, dice che restituire qualcosa che è intcompatibile main()dovrebbe essere equivalente a chiamare exit()con quel valore). Il problema è che diversi sistemi operativi hanno convenzioni diverse per l'interpretazione dei valori di uscita. Su molti sistemi (MOLTI!), 0 significa successo e qualsiasi altra cosa è un fallimento. Ma su, diciamo, VMS, i valori dispari significano successo e anche quelli significano fallimento. Se restituissi 0 da main(), un utente VMS vedrebbe un brutto messaggio su una violazione di accesso. In realtà non c'era una violazione di accesso - quello era semplicemente il messaggio standard associato al codice di errore 0.

Quindi l'ANSI è arrivato e benedetto EXIT_SUCCESSe EXIT_FAILUREcome argomenti a cui potresti passare exit(). Lo standard dice anche che exit(0)bisogna comportarsi in modo identico a exit(EXIT_SUCCESS), quindi la maggior parte delle implementazioni definiscono EXIT_SUCCESSa 0.

Lo standard, quindi, ti mette in relazione con VMS, in quanto non lascia alcun modo standard per restituire un codice di errore che ha il valore 0.

Il compilatore VAX / VMS C dell'inizio degli anni '90 non interpretava quindi il valore di ritorno main(), ma semplicemente restituiva qualsiasi valore all'ambiente host. Ma se lo utilizzassi exit(), farebbe ciò che lo standard richiesto: tradurre EXIT_SUCCESS(o 0) in un codice di successo e EXIT_FAILUREin un codice di errore generico. Per utilizzarlo EXIT_SUCCESS, è stato necessario passarlo a exit(), da cui non è stato possibile restituirlo main(). Non so se versioni più moderne di quel compilatore conservassero quel comportamento.

Un programma C portatile usato per assomigliare a questo:

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

int main() {
  printf("Hello, World!\n");
  exit(EXIT_SUCCESS);  /* to get good return value to OS */
  /*NOTREACHED*/ /* to silence lint warning */
  return 0;  /* to silence compiler warning */
}

A parte: se ricordo bene, la convenzione VMS per i valori di uscita è più sfumata di pari / dispari. In realtà usa qualcosa come i tre bit bassi per codificare un livello di gravità. In generale, tuttavia, i livelli di gravità dispari indicavano il successo o informazioni varie e quelli pari indicavano errori.

In C il ritorno da mainè esattamente lo stesso di una chiamata exitcon lo stesso valore.

La sezione 5.1.2.2.3 della norma C afferma:

Se il tipo restituito della funzione principale è un tipo compatibile con int, un ritorno dalla chiamata iniziale alla funzione principale equivale a chiamare la funzione di uscita con il valore restituito dalla funzione principale come argomento ; 11) il raggiungimento di} che termina la funzione principale restituisce un valore di 0. Se il tipo restituito non è compatibile con int, lo stato di terminazione restituito all'ambiente host non è specificato.

Le regole per C ++ sono leggermente diverse come indicato in altre risposte.

In realtà c'è una differenza tra exit(0)e return(0)inmain - quando la tua mainfunzione viene chiamata più volte.

Il seguente programma

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

int main(int argc, char** argv) {
  if (argc == 0)
    return(0);
  printf("%d", main(argc - 1, argv));
}

Correre come

./program 0 0 0 0

Si tradurrà nel seguente output:

00000

Tuttavia questo:

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

int main(int argc, char** argv) {
  if (argc == 0)
    exit(0);
  printf("%d", main(argc - 1, argv));
}

Non stampa nulla indipendentemente dagli argomenti.

Se sei sicuro che nessuno ti chiamerà mainesplicitamente, non è tecnicamente una grande differenza in generale, ma mantenere un codice più chiaro exitsarebbe molto meglio. Se per qualche motivo vuoi chiamaremain , dovresti adattarlo alle tue esigenze.

Parlando di C.