Impedire la chiusura della finestra della console sull’applicazione console di Visual Studio C / C ++

Questa è probabilmente una domanda imbarazzante, poiché senza dubbio la risposta è ovvia.

Ho usato Visual Studio per anni, ma questa è la prima volta che faccio uno sviluppo di ‘Applicazione Console’.

Quando eseguo l’applicazione, viene visualizzata la finestra della console, viene visualizzato l’output del programma e quindi la finestra si chiude mentre l’applicazione si chiude.

C’è un modo per tenerlo aperto fino a quando non ho controllato l’output, o visualizzare i risultati dopo che la finestra è stata chiusa?

Se si esegue senza eseguire il debug (Ctrl + F5), per impostazione predefinita viene richiesto di premere Invio per chiudere la finestra. Se si desidera utilizzare il debugger, è necessario inserire un punto di interruzione sull’ultima riga.

Fai clic con il tasto destro sul tuo progetto

Proprietà> Proprietà di configurazione> Linker> Sistema

selezionare Console (/ SUBSYSTEM: CONSOLE) nell’opzione SubSystem .

Ora provalo … dovrebbe funzionare

Ecco un modo per C / C ++:

 #include  #ifdef _WIN32 #define WINPAUSE system("pause") #endif 

Metti questo nella parte superiore del tuo programma, e SE è su un sistema Windows ( #ifdef _WIN32 ), allora creerà una macro chiamata WINPAUSE . Ogni volta che vuoi mettere in pausa il tuo programma, chiama WINPAUSE; e metterà in pausa il programma, usando il comando DOS. Per altri sistemi come Unix / Linux, la console non dovrebbe uscire comunque dall’uscita del programma.

Vai al menu Debug- > Premi StartWithoutDebugging

Se stai usando .NET, metti Console.ReadLine() prima della fine del programma.

Attenderà .

prova a chiamare getchar() prima che main() ritorni.

(/ SUBSYSTEM: CONSOLE) non ha funzionato per il mio vs2013 (l’ho già avuto).

“Esegui senza debug” non è un’opzione, dal momento che non voglio passare tra il debug e la visualizzazione dell’output.

Ho finito con

 int main() { ... #if _DEBUG LOG_INFO("end, press key to close"); getchar(); #endif // _DEBUG return 0; } 

Soluzione utilizzata in qtcreator pre 2.6. Ora mentre qt sta crescendo, vs sta andando in altro modo. Come ricordo, nel vs2008 non avevamo bisogno di trucchi del genere.

Ecco una soluzione che (1) non richiede alcuna modifica del codice o punti di interruzione e (2) sospende dopo la chiusura del programma in modo da poter vedere tutto ciò che è stato stampato. Metterà in pausa dopo F5 o Ctrl + F5. Lo svantaggio principale è che su VS2013 Express (come testato), non carica i simboli, quindi il debugging è molto limitato.

  1. Crea un file batch. Ho chiamato il mio runthenpause.bat , con i seguenti contenuti:

     %1 %2 %3 %4 %5 %6 %7 %8 %9 pause 

    La prima riga eseguirà qualsiasi comando tu fornisca e fino a otto argomenti. La seconda linea si fermerà.

  2. Apri le proprietà del progetto | Proprietà di configurazione | Debug.

  3. Cambia “Argomenti del comando” in $(TargetPath) (o qualunque cosa sia in “Comando”).
  4. Cambia “Comando” sul percorso completo per runthenpause.bat .
  5. Hit OK.

Ora, quando si esegue, runthenpause.bat avvierà l’applicazione e, una volta terminata l’applicazione, si interromperà per vedere l’output della console.

Pubblicherò un aggiornamento se capisco come caricare i simboli. Ho provato /Z7 per questo, ma senza successo.

Potresti eseguire il tuo eseguibile da un prompt dei comandi. In questo modo puoi vedere tutto l’output. Oppure potresti fare qualcosa del genere:

 int a = 0; scanf("%d",&a); return YOUR_MAIN_CODE; 

e in questo modo la finestra non si chiuderà finché non si immetteranno i dati per la variabile.

aggiungi “| pausa “nella casella degli argomenti del comando nella sezione di debug delle proprietà del progetto.

Basta premere CNTRL + F5 per aprirlo in una finestra della riga di comando esterna (Visual Studio non ha il controllo su di esso).

Se questo non funziona, aggiungi quanto segue alla fine del tuo codice:

 Console.WriteLine("Press any key to exit..."); Console.ReadKey(); 

Attendi che tu prema un tasto per chiudere la finestra del terminale una volta che il codice ha raggiunto la fine.

Se vuoi farlo in più posti, inserisci il codice sopra in un metodo (es. private void Pause() ) e chiama Pause() ogni volta che un programma raggiunge una ansible fine.

metti come ultima linea di codice:

 system("pause"); 

Una soluzione alquanto migliore:

 atexit([] { system("PAUSE"); }); 

all’inizio del tuo programma.

Professionisti:

  • può usare std :: exit ()
  • può avere più ritorni da main
  • è ansible eseguire il programma sotto il debugger
  • IDE indipendente (+ OS indipendente se si usa il cin.sync(); cin.ignore(); trucco invece di system("pause"); )

Contro:

  • devi modificare il codice
  • non metterà in pausa su std :: terminate ()
  • si verificherà ancora nel tuo programma al di fuori della sessione IDE / debugger; puoi prevenirlo con Windows usando:

 extern "C" int __stdcall IsDebuggerPresent(void); int main(int argc, char** argv) { if (IsDebuggerPresent()) atexit([] {system("PAUSE"); }); ... } 

O usare:

  1. cin.get();

o

  1. system("pause");

Assicurati di averli entrambi alla fine della funzione main() e prima dell’istruzione return .

Visual Studio 2015 , con importazioni . Perché odio quando gli esempi di codice non danno le importazioni necessarie.

 #include ; int main() { getchar(); return 0; } 

Usa console.readline . La tua è scrivere la linea ma non leggerla.