Come posso uscire dall'uscita di un programma di console C++?

Question

Esiste una riga di codice che interromperà il programma?

Qualcosa come Python sys.exit()?

Answer 1

#include <cstdlib> 
... 
exit(exit_code); 

Answer 2

Sì! exit(). È in <cstdlib>.

Answer 3

uscita (0); // al termine della funzione principale prima di chiudere le parentesi graffe

Answer 4

Mentre è possibile chiamata exit() (e potrebbe essere necessario farlo se la vostra applicazione rileva qualche errore fatale), il modo più pulito per uscire da un programma è quello di tornare da main():

int main() 
{ 
    // do whatever your program does 

} // function returns and exits program 

Quando si chiama exit(), oggetti con durata memorizzazione automatica (variabili locali) non vengono distrutti prima che il programma termina, così non si ottiene una corretta pulizia. Questi oggetti potrebbero dover ripulire tutte le risorse che possiedono, persistere eventuali modifiche dello stato in sospeso, terminare eventuali thread in esecuzione o eseguire altre azioni affinché il programma possa terminare in modo pulito.

Answer 5

In main(), v'è anche:

return 0; 

Answer 6

se ci si trova nella principale si può fare:

return 0; 

o

exit(exit_code); 

Il codice di uscita dipende la semantica del tuo codice. 1 è l'errore 0 e un'uscita normale.

In qualche altra funzione del vostro programma:

exit(exit_code) 

sarà uscire dal programma.

Answer 7

Ci sono diversi modi per far terminare il programma. Quale è appropriato dipende dal motivo per cui vuoi che il tuo programma termini. La maggior parte delle volte dovrebbe essere eseguendo una dichiarazione di ritorno nella funzione principale. Come nel seguito.

int main() 
{ 
    f(); 
    return 0; 
} 

Come altri hanno identificato questo permette tutte le variabili di stack ad essere adeguatamente distrutti in modo da ripulire correttamente. Questo è molto importante.

Se è stato rilevato un errore da qualche parte nel codice e è necessario uscire, è necessario generare un'eccezione per tornare alla funzione principale. Come nel seguito.

struct stop_now_t { }; 
void f() 
{ 
     // ... 
     if (some_condition()) 
      throw stop_now_t(); 
     // ... 
} 

int main() 
{ 
    try { 
      f(); 
    } catch (stop_now_t& stop) { 
      return 1; 
    } 
    return 0; 
} 

Questo fa sì che lo stack venga svolto e tutte le variabili dello stack vengano distrutte. Ancora molto importante. Si noti che è opportuno indicare un errore con un valore di ritorno diverso da zero.

Se nel caso improbabile che il programma rileva una condizione che indica che non è più sicuro di eseguire qualsiasi più istruzioni allora si dovrebbe usare std :: abort(). Questo porterà il tuo programma ad un arresto improvviso senza ulteriori elaborazioni. std :: exit() è simile, ma può chiamare atexit gestori che potrebbe essere male se il vostro programma è sufficientemente BORKED.

Answer 8

Consentire al flusso di esecuzione di lasciare main per returning a value or allowing execution to reach the end of the function è il modo in cui un programma deve terminare se non in circostanze irrecuperabili. Restituire un valore è facoltativo in C++, ma in genere preferisco restituire EXIT_SUCCESS trovato in cstdlib (un valore specifico della piattaforma che indica che il programma è stato eseguito correttamente).

#include <cstdlib> 

int main(int argc, char *argv[]) { 
    ... 
    return EXIT_SUCCESS; 
} 

Se, tuttavia, il programma raggiunge uno stato irreversibile, dovrebbe generare un'eccezione. È importante rendersi conto delle implicazioni di farlo, comunque. Non ci sono best practice largamente accettate per decidere cosa dovrebbe o non dovrebbe essere un'eccezione, ma ci sono alcune regole generali che devi conoscere.

Ad esempio, lanciare un'eccezione da un distruttore è quasi sempre una pessima idea perché l'oggetto distrutto potrebbe essere stato distrutto perché era già stata generata un'eccezione. Se viene lanciata una seconda eccezione, viene chiamato terminate e il programma si arresta senza che sia stata eseguita alcuna ulteriore pulizia. È possibile possibile utilizzare uncaught_exception per determinare se è sicuro, ma in genere è meglio non consentire mai eccezioni di lasciare un distruttore.

Mentre è generalmente sempre possibile per le funzioni che chiami, ma non ha scritto per lanciare eccezioni (per esempio, new getteranno std::bad_alloc se non può allocare memoria sufficiente), è spesso difficile per i programmatori principianti per tenere traccia di o anche sapere tutte le regole speciali che circondano le eccezioni in C++. Per questo motivo, consiglio di utilizzarli solo in situazioni in cui non esiste un modo ragionevole per il tuo programma di continuare l'esecuzione.

#include <stdexcept> 
#include <cstdlib> 
#include <iostream> 

int foo(int i) { 
    if (i != 5) { 
    throw std::runtime_error("foo: i is not 5!"); 
    } 
    return i * 2; 
} 

int main(int argc, char *argv[]) { 
    try { 
    foo(3); 
    } 
    catch (const std::exception &e) { 
    std::cout << e.what() << std::endl; 
    return EXIT_FAILURE; 
    } 
    return EXIT_SUCCESS; 
} 

exit è una rapina sulla C e può comportare oggetti con memorizzazione automatica di non essere ripulito correttamente. abort e terminate effettivamente causa il suicidio del programma e sicuramente non pulirà le risorse.

Qualunque cosa tu faccia, non utilizzare le eccezioni, exit o abort/terminate come una stampella per aggirare la scrittura di un programma ben strutturato. Salvali per situazioni eccezionali.

Answer 9

#include <cstdlib> 
... 
/*wherever you want it to end, e.g. in an if-statement:*/ 
if (T == 0) 
{ 
exit(0); 
} 

Answer 10

abbastanza semplice ..

exit (0); } // fine della funzione

Assicurarsi che vi sia uno spazio su entrambi i lati dello 0. Senza spazi, il programma non si fermerà.

Answer 11

else if(Decision >= 3) 
    { 
exit(0); 
    }