HOWTO · C++

exit(1) in C++

Questo articolo mostra come utilizzare la funzione di uscita in C++

In questa pagina

Per convenzione, exit(1) termina un programma C++ con uno stato diverso da zero, segnalando un errore all’ambiente chiamante. Uno stato pari a zero segnala convenzionalmente il successo. In C++, la funzione è std::exit ed è dichiarata in <cstdlib>; per i valori standard di stato si usano EXIT_SUCCESS e EXIT_FAILURE. In genere è preferibile restituire un valore da main, perché così gli oggetti locali possono essere ripuliti normalmente.

Che cosa fa std::exit in C++

La funzione std::exit riceve uno stato intero e termina il programma senza restituire il controllo al chiamante. La forma familiare exit(1) si riferisce alla funzione della libreria C; in C++, si usa il nome qualificato std::exit per indicarne esplicitamente il namespace. Le costanti EXIT_SUCCESS e EXIT_FAILURE esprimono gli stati standard di successo e insuccesso senza presupporre un valore numerico specifico per l’insuccesso.

La terminazione normale tramite std::exit esegue le funzioni registrate con std::atexit, distrugge gli oggetti con durata di memorizzazione statica e svuota e chiude i flussi C. Non svolge lo stack delle chiamate: gli oggetti automatici nella funzione che chiama std::exit non vengono distrutti. È un aspetto importante se questi oggetti possiedono risorse la cui pulizia dipende dai distruttori.

Come usare std::exit con un codice di stato

Usa std::exit(EXIT_SUCCESS) quando una funzione esterna a main deve terminare con successo l’intero programma, anche se di solito è più semplice ragionare restituendo uno stato da main. Esegui questo esempio. Il testo visualizzato, “Operation completed” (“Operazione completata”), resta in inglese nel blocco perché il codice e l’output sono mantenuti invariati:

#include <cstdlib>
#include <iostream>

int main() {
    std::cout << "Operation completed" << '\n';
    std::exit(EXIT_SUCCESS);
}
Operation completed

Se si verifica una condizione fatale che impedisce qualsiasi recupero utile, segnala il problema e termina con std::exit(EXIT_FAILURE). Questo programma autonomo sceglie tale percorso con --fail; senza l’argomento termina normalmente. Il messaggio diagnostico viene scritto sullo standard error e lo stato selezionato comunica all’ambiente chiamante se l’operazione è riuscita. Le stringhe visualizzate nei blocchi restano in inglese: “Unable to continue” significa “Impossibile continuare” e “Operation completed” significa “Operazione completata”. Il codice e l’output sono mantenuti invariati:

#include <cstdlib>
#include <iostream>
#include <string_view>

int main(int argc, char* argv[]) {
    if (argc > 1 && std::string_view(argv[1]) == "--fail") {
        std::cerr << "Unable to continue" << '\n';
        std::exit(EXIT_FAILURE);
    }

    std::cout << "Operation completed" << '\n';
    return EXIT_SUCCESS;
}

Che cosa viene eseguito durante la terminazione normale

Le operazioni di pulizia sono selettive: vengono eseguite le funzioni registrate con std::atexit, sono distrutti gli oggetti con durata di memorizzazione statica e i flussi C vengono svuotati e chiusi. Gli oggetti automatici nella funzione che chiama std::exit vengono ignorati, perché la chiamata non risale gli ambiti in cui si trovano. Perciò, quando usi std::exit, non fare affidamento sui distruttori locali per rilasciare un file, un lock o un’altra risorsa: predisponi prima la pulizia oppure restituisci il controllo normalmente attraverso l’ambito proprietario.

Uno stato comunica il risultato del programma, ma da solo non descrive la causa dell’errore. Prima di terminare, stampa o registra un messaggio diagnostico utile e documenta gli eventuali valori di stato specifici dell’applicazione per chi la chiama. Per indicare in modo portabile successo e insuccesso, usa EXIT_SUCCESS e EXIT_FAILURE da <cstdlib>.

Registrare operazioni di pulizia con std::atexit

Registra una funzione con std::atexit se deve essere eseguita durante la terminazione normale tramite std::exit o al ritorno da main. Le funzioni vengono eseguite in ordine inverso rispetto alla registrazione. Dovrebbero occuparsi di operazioni di pulizia circoscritte e non dipendere dagli oggetti automatici della funzione che ha avviato la terminazione.

Questo esempio autonomo registra due callback con etichette distinte. Poiché vengono eseguite in ordine inverso rispetto alla registrazione, release_cache viene eseguita prima di close_log. Le etichette mostrate nel codice e nell’output restano in inglese perché i blocchi sono mantenuti invariati: significano rispettivamente “rilascia la cache” e “chiudi il log”.

#include <cstdlib>
#include <iostream>

void close_log() {
    std::cout << "close log" << '\n';
}

void release_cache() {
    std::cout << "release cache" << '\n';
}

int main() {
    std::atexit(close_log);
    std::atexit(release_cache);
    std::cout << "main work" << '\n';
    return EXIT_SUCCESS;
}
main work
release cache
close log

Quando preferire il ritorno da main

Restituire un valore da main è la scelta abituale quando il lavoro è terminato o un risultato può essere propagato lungo la catena di chiamate. L’intero restituito diventa lo stato del programma e gli oggetti automatici locali in main vengono distrutti quando la funzione termina. In questo modo anche le funzioni circostanti e i distruttori possono completare le normali operazioni di pulizia.

Usa std::exit quando il programma deve terminare immediatamente da una funzione più interna e non è pratico riportare la decisione tramite i normali valori di ritorno. Prima di farlo, considera gli oggetti automatici che verranno ignorati. Per gli errori che possono essere gestiti, restituisci un valore di errore oppure propaga un’eccezione fino a un punto di gestione adeguato; riserva la terminazione dell’intero processo ai casi in cui non è opportuno continuare.