Come mantenere aperta la finestra della console in Visual C ++?

Sto iniziando in Visual C ++ e mi piacerebbe sapere come mantenere la finestra della console.

Ad esempio questa sarebbe una tipica applicazione “ciao mondo”:

int _tmain(int argc, _TCHAR* argv[]) { cout << "Hello World"; return 0; } 

Qual è la linea che mi manca?

Avvia il progetto con Ctrl + F5 invece di solo F5 .

La finestra della console rimarrà aperta con il Press any key to continue . . . Press any key to continue . . . messaggio dopo l’uscita del programma.

Si noti che ciò richiede l’opzione di collegamento Console (/SUBSYSTEM:CONSOLE) , che è ansible abilitare come segue:

  1. Apri il tuo progetto e vai a Solution Explorer. Se segui con me in K & R, la tua “Soluzione” sarà “Ciao” con 1 progetto sotto di esso, anche “Ciao” in grassetto.
  2. Fai clic con il pulsante destro del mouse su “Ciao” (o qualunque sia il nome del tuo progetto).
  3. Scegli “Proprietà” dal menu di scelta rapida.
  4. Scegli Proprietà di configurazione> Linker> Sistema.
  5. Per la proprietà “Sottosistema” nel riquadro a destra, fare clic sulla casella a discesa nella colonna a destra.
  6. Scegli “Console (/ SUBSYSTEM: CONSOLE)”
  7. Fai clic su Applica, attendi che finisca di fare qualsiasi cosa, quindi fai clic su OK. (Se “Applica” non è selezionabile, scegli qualche altra opzione per il sottosistema, fai clic su Applica, quindi torna indietro e applica l’opzione della console. La mia esperienza è che OK da solo non funzionerà.)

CTRL-F5 e il sottosistema suggerimenti funzionano insieme; non sono opzioni separate.

(Per gentile concessione di DJMorreTX da http://social.msdn.microsoft.com/Forums/en-US/vcprerelease/thread/21073093-516c-49d2-81c7-d960f6dc2ac6 )

Il modo standard è cin.get() prima della dichiarazione di ritorno.

 int _tmain(int argc, _TCHAR* argv[]) { cout < < "Hello World"; cin.get(); return 0; } 

Metti un punto di interruzione sulla linea di return .

Lo stai eseguendo nel debugger, giusto?

Un’altra opzione è da usare

 #include  system("pause"); 

Anche se questo non è molto portabile perché funziona solo su Windows, ma verrà stampato automaticamente

Premere un tasto qualsiasi per continuare…

Per i progetti makefile, la soluzione accettata fallisce a causa di un bug in Visual Studio (che è presente almeno fino alla versione 2012 – Non ho ancora testato il 2013). Questo bug è dettagliato qui .

Per fare in modo che la console si interrompa dopo la chiusura del programma su un progetto makefile, eseguire questi passaggi (questo potrebbe essere diverso per le versioni diverse dal 2010 – 2012):

1) Passa /SUBSYSTEM:CONSOLE al linker.MODIFICA : vedi sotto.

2) Apri il file di progetto (.vcxproj) in un editor di testo.

3) All’interno del root , inserisci quanto segue:

   Console   

4) Ricarica il progetto nella tua soluzione.

5) Esegui il programma senza eseguire il debug (CTRL + F5).

MODIFICARE:

Come per il mio commento qui sotto, l’impostazione dell’opzione linker /SUBSYSTEM:CONSOLE è in realtà irrilevante per i progetti makefile (e non necessariamente nemmeno ansible, se si utilizza un compilatore diverso da MSVC). Tutto ciò che importa è che l’impostazione viene aggiunta al file .vcxproj, come per il punto 3 sopra.

Puoi usare cin.get(); o cin.ignore(); appena prima della dichiarazione di ritorno per evitare che la finestra della console si chiuda.

Aggiungi semplicemente un Breakpoint alla parentesi chiusa del tuo metodo _tmain . Questo è il modo più semplice e non è necessario aggiungere codice per eseguire il debug.

basta inserire un breakpoint sull’ultima parentesi graffa principale.

  int main () { //...your code... return 0; } //< - breakpoint here 

funziona per me, non è necessario eseguire senza debug. Esegue anche i distruttori prima di colpire il punto di interruzione in modo da poter controllare qualsiasi messaggio stampato su questi distruttori, se ne hai.

Posiziona un punto di interruzione sulla parentesi finale di main() . Verrà triggersto anche con più dichiarazioni di reso. L’unico lato negativo è che una chiamata a exit() non verrà catturata.

Se non stai eseguendo il debug, segui il consiglio nella risposta di Zoidberg e avvia il tuo programma con Ctrl + F5 invece di solo F5 .

cin.get () o sistema (“PAUSE”). Non ho sentito che puoi usare return (0);

#include e poi aggiungo getch(); appena prima del return 0; linea. Questo è quello che ho imparato a scuola comunque. I metodi sopra menzionati qui sono molto diversi, vedo.

Aveva lo stesso problema. Sto usando _getch () appena prima dell’istruzione return. Funziona.

Ho avuto lo stesso problema; Nella mia applicazione ci sono più punti exit () e non c’era modo di sapere dove esca esattamente, poi ho scoperto questo:

 atexit(system("pause")); 

o

 atexit(cin.get()); 

In questo modo si fermerà indipendentemente da dove usciamo nel programma.

I miei 2 centesimi:

Scelta 1: Aggiungi un breakpoint alla fine di main()

Scelta 2: aggiungi questo codice, subito prima del return 0; :

 std::cout < < "Press ENTER to continue..."; //So the User knows what to do std::cin.ignore(std::numeric_limits::max(), '\n'); 

È necessario includere per std::numeric_limits

(Alcune opzioni possono essere chiamate con nomi diversi. Non uso la versione inglese)

Ho avuto lo stesso problema, quando ho creato progetti con l’opzione “progetto vuoto”, Crea progetto come “Applicazione Win32-console” invece di “progetto vuoto”. Nella finestra di dialogo che si apre ora, si preme “continua” e successivamente è ansible selezionare l’opzione “progetto vuoto” e premere conferma. Dopo che CTRL + F5 aprirà una console che non si chiude automaticamente.

puoi semplicemente mettere keep_window_open (); prima del ritorno ecco un esempio

 int main() { cout< <"hello world!\n"; keep_window_open (); return 0; } 

Un’altra opzione:

 #ifdef _WIN32 #define MAINRET system("pause");return 0 #else #define MAINRET return 0 #endif 

In principale:

 int main(int argc, char* argv[]) { MAINRET; } 

basta aggiungere il sistema (“pausa”) alla fine del codice prima di restituire 0 come questo

 int main() { some code goes here system("pause") return 0; } 

In realtà, la vera soluzione è la selezione del modello di progetto stesso. È NECESSARIO selezionare Applicazione console Win32 nella VS precedente, oppure inserire prima il nome del progetto, quindi fare doppio clic sulla procedura guidata Windows Desktop e selezionare l’applicazione console Win32. Quindi selezionare il progetto vuoto a questo punto. Ciò consente quindi ciò che l’interlocutore originale desiderava davvero senza aggiungere punti di arresto e codice di attesa aggiuntivi. Ho affrontato anche questo problema. La risposta è anche al sito MSDN.

Ecco un modo per mantenere aperta la finestra di comando indipendentemente da come si ferma l’esecuzione senza modificare alcun codice:

In Visual Studio, apri le pagine delle proprietà del progetto -> Debug .

Per Comando , inserisci $(ComSpec)

Per Argomenti di comando , immettere /k $(TargetPath) . Aggiungi qualsiasi argomento alla tua applicazione.

Ora F5 o Ctrl-F5 esegue Windows / System32 / cmd.exe in una nuova finestra e / k assicura che il prompt dei comandi rimanga aperto al termine dell’esecuzione.

Il rovescio della medaglia è che l’esecuzione non si fermerà sui punti di interruzione.