Devo restituire EXIT_SUCCESS o 0 da main ()?

È una domanda semplice, ma continuo a vedere risposte contrastanti: la routine principale di un programma C ++ dovrebbe restituire 0 o EXIT_SUCCESS ?

 #include  int main(){return EXIT_SUCCESS;} 

o

 int main(){return 0;} 

Sono esattamente la stessa cosa? EXIT_SUCCESS dovrebbe essere utilizzato solo con exit() ?

Pensavo che EXIT_SUCCESS sarebbe stata un’opzione migliore perché altri software potrebbero voler essere considerati zero come errori, ma ho anche sentito che se si restituisce 0 , il compilatore è comunque in grado di cambiarlo in un valore diverso.

EXIT_FAILURE , in un’istruzione return in main o come argomento in exit() , è l’unico modo portatile per indicare un errore in un programma C o C ++. exit(1) può effettivamente segnalare la terminazione con esito positivo su VMS, ad esempio.

Se stai usando EXIT_FAILURE quando il tuo programma fallisce, allora potresti usare EXIT_SUCCESS quando riesce, giusto per simmetria.

D’altra parte, se il programma non segnala mai un errore, puoi usare 0 o EXIT_SUCCESS . Entrambi sono garantiti dallo standard per segnalare il completamento con successo. (È a malapena ansible che EXIT_SUCCESS possa avere un valore diverso da 0, ma è uguale a 0 su ogni implementazione che abbia mai sentito.)

L’utilizzo di 0 ha il vantaggio minore che non è necessario #include in C, o #include in C ++ (se stai usando un’istruzione return piuttosto che chiamare exit() ) – ma per un programma di qualsiasi dimensione significativa che includerai stdlib direttamente o indirettamente in ogni caso.

Del resto, in C che inizia con lo standard 1999, e in tutte le versioni di C ++, raggiungendo la fine di main() fa un return 0; implicito return 0; in ogni caso, quindi potresti non aver bisogno di usare 0 o EXIT_SUCCESS esplicito. (Ma almeno in C, considero un return 0; esplicito return 0; per essere migliore stile.)

(Qualcuno mi ha chiesto di OpenVMS. Non l’ho usato da molto tempo, ma poiché ricordo i valori di stato dispari generalmente denotano successo mentre i valori pari indicano errori. L’implementazione C esegue il mapping da 0 a 1 , in modo che return 0; Altri valori vengono passati invariati, quindi return 1; indica anche la terminazione con esito positivo. EXIT_FAILURE avrebbe un valore pari a zero.)

Non importa. Entrambi sono uguali.

Citazioni standard C ++:

Se il valore dello stato è zero o EXIT_SUCCESS, viene restituito un modulo definito dall’implementazione dello stato.

0 è, per definizione, un numero magico. EXIT_SUCCESS è quasi universalmente uguale a 0, abbastanza felicemente. Quindi, perché non tornare / uscire 0?

uscita (EXIT_SUCCESS); è abbondantemente chiaro nel significato.

exit (0); d’altra parte, è controintuitivo in qualche modo. Qualcuno che non ha familiarità con il comportamento della shell potrebbe supporre che 0 == false == cattivo, proprio come ogni altro utilizzo di 0 in C. Ma no – in questo caso speciale, 0 == successo == buono. Per gli sviluppatori più esperti, non sarà un problema. Ma perché rintracciare il nuovo ragazzo senza assolutamente motivo?

tl; dr – se c’è una costante definita per il tuo numero magico, non c’è quasi mai una ragione per non usare la costante in primo luogo. È più ricercabile, spesso più chiaro, ecc. E non ti costa nulla.

Questa è una storia infinita che riflette i limiti (un mito) di “interoperabilità e potenzialità su tutti”.

Quello che il programma dovrebbe restituire per indicare “successo” dovrebbe essere definito da chi sta ricevendo il valore (il sistema operativo o il processo che ha invocato il programma) non da una specifica del linguaggio.

Ma ai programmatori piace scrivere il codice in “modo portatile” e quindi inventano il proprio modello per il concetto di “sistema operativo” che definisce i valori simbolici da restituire.

Ora, in uno scenario molti-a-molti (in cui molte lingue servono a scrivere programmi su molti sistemi) la corrispondenza tra la convenzione linguistica per “successo” e quella del sistema operativo (che nessuno può garantire di essere sempre la stessa) dovrebbe essere gestito dalla specifica implementazione di una libreria per una specifica piattaforma di destinazione.

Ma – sfortunatamente – questi concetti non erano chiari al momento in cui il linguaggio C è stato implementato (principalmente per scrivere il kernel UNIX), e Gigagrammi di libri dove scritto dicendo “return 0 significa successo”, dal momento che era vero sul sistema operativo a quella volta con un compilatore C.

Da quel momento in poi, non è mai stata fatta una chiara standardizzazione su come gestire tale corrispondenza. C e C ++ ha la propria definizione di “valori di ritorno” ma nessuno garantisce una corretta conversione del sistema operativo (o meglio: nessuna documentazione del compilatore dice nulla al riguardo). 0 significa successo se vero per UNIX-LINUX e -per ragioni indipendenti- anche per Windows, e questo copre il 90% dei “computer del consumatore” esistenti, che – nella maggior parte dei casi – non tengono conto del valore restituito (quindi possiamo discutere per decenni, ma nessuno se ne accorgerà mai!)

All’interno di questo scenario, prima di prendere una decisione, poni queste domande: – Sono interessato a comunicare qualcosa al mio interlocutore sulla mia esistente? (Se restituisco sempre 0 … non c’è alcun indizio dietro a tutto) – Il mio chiamante ha delle convenzioni su questa comunicazione? (Si noti che un singolo valore non è una convenzione: che non consente alcuna rappresentazione di informazioni)

Se entrambe le risposte sono no, probabilmente la soluzione migliore è non scrivere affatto la dichiarazione di ritorno principale. (E lasciare che il compilatore di decidere, rispetto all’objective sta lavorando per).

Se nessuna convenzione è in atto 0 = il successo incontra la maggior parte delle situazioni (e l’uso di simboli può essere problematico se introduce una convenzione).

Se sono in vigore le convenzioni, assicurarsi di utilizzare costanti simboliche coerenti con esse (e garantire coerenza di congruenza, non coerenza di valore tra le piattaforms).

Una volta che inizi a scrivere il codice che può restituire una miriade di stati di uscita, puoi iniziare a #define tutti. In questo caso, EXIT_SUCCESS ha senso nel contesto di non essere un ” numero magico “. Questo rende il tuo codice più leggibile perché ogni altro codice di uscita sarà EXIT_SOMETHING . Se scrivi semplicemente un programma che tornerà quando è terminato, return 0 è valido, e probabilmente anche più pulito perché suggerisce che non esiste una struttura di codice di ritorno sofisticata.

Ciò che ritorni da un programma è solo una convenzione.

No, non posso pensare a nessuna circostanza in cui “EXIT_SUCCESS” non sia “0”.

Personalmente, consiglierei “0”.

A PARER MIO…

Se utilizzi EXIT_SUCCESS, il tuo codice sarà più portatile.

http://www.dreamincode.net/forums/topic/57495-return-0-vs-return-exit-success/

isnt exit_success è una macro, che è definita come zero. Vorrei poter ricordare dove leggo. Il che ha detto che EXIT_SUCCESS lo rende più significativo. ma lungo la linea entrambi sono trattati come nei file di intestazione, EXIT_SUCCESS come zero.

Alcuni compilatori potrebbero creare problemi con questo: su un compilatore Mac C ++, EXIT_SUCCESS ha funzionato bene per me, ma su un compilatore Linux C ++ ho dovuto aggiungere cstdlib per sapere cosa è EXIT_SUCCESS. Oltre a questo, sono la stessa cosa.

Prima di tutto, suppongo che tu sappia che main() dovrebbe sempre tornare int .

In secondo luogo, quando restituiamo un valore da main, stiamo praticamente dicendo “il programma è stato eseguito con successo!”

Tuttavia: la maggior parte dei sistemi operativi considererà il return 0; come una corsa di successo, ma alcuni cercheranno il return 1; per dire “questo programma è stato eseguito con successo!”

Ora, EXIT_SUCCESS è una macro C ++, che si limita a garantire che restituisca il valore corretto, sempre dicendo “questo programma è stato eseguito con successo!”

Spero che questo ti aiuti 🙂

0 == False && False == EXIT_SUCCESS

In pratica, non penso che faccia molta differenza. – ma Main è definito come int, quindi sembrerebbe logico che main restituisca un int. In alcune circostanze, è ansible che si desideri restituire valori diversi per errori diversi e sembrerebbe strano dare un nome di fantasia.