Impedire la chiusura della finestra della console nell'applicazione console di Visual Studio C / C ++

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

Ho usato Visual Studio per anni, ma questa è la prima volta che ho fatto lo sviluppo di 'Console Application'.

Quando eseguo la mia applicazione, viene visualizzata la finestra della console, viene visualizzato l'output del programma e la finestra si chiude all'uscita dell'applicazione.

C'è un modo per tenerlo aperto fino a quando non ho verificato l'output o visualizzare i risultati dopo la chiusura della finestra?

Se si esegue senza 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 nell'ultima riga.

Fai clic destro sul tuo progetto

Proprietà> Proprietà di configurazione> Linker> Sistema

Selezionare Console (/ SUBSYSTEM: CONSOLE) in SubSystemopzione o si può semplicemente digitare Console nel campo di testo!

Ora provalo ... dovrebbe funzionare

Ecco un modo per C / C ++:

#include <stdlib.h>

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

Metti questo nella parte superiore del tuo programma e SE è su un sistema Windows ( #ifdef _WIN32), quindi 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 comunque chiudersi all'uscita dal programma.

Vai al menu Debug- > Premi Start senza debug

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

Aspetterà <ENTER>.

A partire da Visual Studio 2017 (15.9.4) esiste un'opzione:

Tools->Options->Debugging->Automatically close the console

Il frammento corrispondente dalla documentazione di Visual Studio :

Chiudi automaticamente la console quando il debug si interrompe:

Indica a Visual Studio di chiudere la console al termine di una sessione di debug.

prova a chiamare getchar()subito prima dei main()ritorni.

(/ SUBSYSTEM: CONSOLE) non ha funzionato per il mio vs2013 (l'avevo già fatto).

"Esegui senza debug" non è un'opzione, dal momento che non voglio passare dal debug alla 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 diversamente. Come ricordo, in vs2008 non avevamo bisogno di tali trucchi.

Ecco una soluzione che (1) non richiede alcuna modifica del codice o punti di interruzione e (2) fa una pausa dopo la fine del programma in modo da poter vedere tutto ciò che è stato stampato. Si fermerà dopo F5 o Ctrl + F5. Il principale svantaggio è che su VS2013 Express (come testato), non carica simboli, quindi il debug è 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à qualunque comando tu fornisca e fino a otto argomenti. La seconda riga ... farà una pausa.

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

3. Cambia "Argomenti comando" in $(TargetPath) (o qualunque cosa sia in "Comando").
4. Cambia "Comando" nel percorso completo di runthenpause.bat .
5. Premi OK.

Ora, quando corri, runthenpause.bat avvierà l'applicazione e, una volta terminata l'applicazione, ti metterà in pausa per vedere l'output della console.

Pubblicherò un aggiornamento se scoprirò come caricare i simboli. Ho provato /Z7per questo ma senza successo.

basta inserire come ultima riga di codice:

system("pause");

È possibile eseguire il file eseguibile da un prompt dei comandi. In questo modo è possibile 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 chiuderebbe fino a quando non si immettono i dati per la avariabile.

aggiungi “| pausa "nella casella degli argomenti dei comandi nella sezione debug nelle proprietà del progetto.

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

Se il problema persiste, aggiungi quanto segue alla fine del codice:

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

Questo ti aspetta per premere un tasto per chiudere la finestra del terminale una volta che il codice ha raggiunto la fine.

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

Una soluzione leggermente migliore:

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

all'inizio del programma.

Professionisti:

• può usare std :: exit ()
• può avere più ritorni dalla principale
• puoi eseguire il tuo programma con il debugger
• IDE indipendente (+ OS indipendente se si utilizza il cin.sync(); cin.ignore();trucco anziché system("pause");)

Contro:

• modificare il codice
• non si fermerà su std :: terminate ()
• accadrà comunque nel tuo programma al di fuori della sessione IDE / debugger; puoi impedirlo in Windows usando:

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

Utilizzare entrambi:

1. cin.get();

o

2. system("pause");

Assicurati di crearne uno alla fine della main()funzione e prima returndell'istruzione.

Puoi anche usare questa opzione

#include <conio.h> 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main() {
   .
   .
   .
   getch(); 

   return 0;
}

Nel mio caso, l'ho sperimentato quando ho creato un progetto C ++ vuoto sull'edizione della community VS 2017. Sarà necessario impostare il sottosistema su "Console (/ SUBSYSTEM: CONSOLE)" in Proprietà di configurazione.

1. Vai su "Visualizza" quindi seleziona "Gestore proprietà"
2. Fare clic con il tasto destro sul progetto / soluzione e selezionare "Proprietà". Questo apre una pagina delle proprietà del Test
3. Passa al linker quindi seleziona "Sistema"
4. Fare clic su "Sottosistema" per visualizzare un menu a discesa
5. Scegli "Console (/ SUBSYSTEM: CONSOLE)"
6. Applicare e salvare
7. La prossima volta che esegui il codice con "CTRL + F5", dovresti vedere l'output.

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

#include <iostream>;

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

Utilizzare Console.ReadLine()alla fine del programma. Ciò manterrà la finestra aperta fino a quando non si preme il Entertasto. Vedere https://docs.microsoft.com/en-us/dotnet/api/system.console.readline per i dettagli.