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

Sto iniziando in Visual C ++ e vorrei 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?

Inizia il progetto con Ctrl+F5invece di solo F5.

La finestra della console rimarrà aperta con il Press any key to continue . . .messaggio dopo la chiusura del programma.

Nota che questo richiede l' Console (/SUBSYSTEM:CONSOLE)opzione linker, che puoi abilitare come segue:

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

CTRL-F5 e i suggerimenti del sottosistema 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 reso.

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

Metti un punto di interruzione sul return linea.

Lo stai eseguendo nel debugger, giusto?

Un'altra opzione è usare

#include <process.h>
system("pause");

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

Premere un tasto qualsiasi per continuare...

Per i progetti di makefile, la soluzione accettata non riesce, 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 venga messa in pausa dopo la conclusione del programma su un progetto makefile, procedere come segue (ciò può differire per le versioni diverse da 2010-2012):

1) Passa /SUBSYSTEM:CONSOLEal linker. - EDIT : vedi sotto.

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

3) All'interno del <project>tag radice , inserire quanto segue:

<ItemDefinitionGroup>
  <Link>
    <SubSystem>Console</SubSystem>
  </Link>
</ItemDefinitionGroup>

4) Ricarica il progetto nella tua soluzione.

5) Eseguire il programma senza debug (CTRL + F5).

MODIFICARE:

Secondo il mio commento qui sotto, l'impostazione dell'opzione linker /SUBSYSTEM:CONSOLEè in realtà irrilevante per i progetti di makefile (e non necessariamente nemmeno possibile, se si utilizza un compilatore diverso da MSVC). Tutto ciò che conta è che l'impostazione venga aggiunta al file .vcxproj, come indicato al passaggio 3 sopra.

È possibile utilizzare cin.get();o cin.ignore();appena prima della dichiarazione di ritorno per evitare la chiusura della finestra della console.

basta mettere un breakpoint sull'ultima parentesi graffa del main.

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

funziona per me, non c'è bisogno di correre senza debug. Esegue anche i distruttori prima di colpire il punto di interruzione, in modo da poter controllare l'eventuale stampa dei messaggi su questi distruttori.

Aggiungi semplicemente un Breakpoint alla parentesi di chiusura del tuo _tmainmetodo. Questo è il modo più semplice, inoltre non è necessario aggiungere codice per eseguire il debug.

Posizionare un punto di interruzione sul controvento finale di main(). Verrà inciampato anche con più returndichiarazioni. L'unico aspetto negativo è che una chiamata aexit() non verrà catturata.

Se non stai eseguendo il debug, segui i consigli nella risposta di Zoidberg e avvia il tuo programma con Ctrl+ F5anziché solo F5.

I miei 2 centesimi:

Scelta 1: aggiungere un punto di interruzione alla fine di main()

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

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

Devi includere <iomanip>perstd::numeric_limits

basta aggiungere il sistema ("pausa") alla fine del codice prima di restituire 0 in questo modo

#include <stdlib.h>

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

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

cin.get()o system("PAUSE"). Non ho sentito che puoi usarereturn(0);

Includo #include <conio.h>e poi aggiungo getch();poco prima della return 0;riga. Questo è quello che ho imparato a scuola comunque. I metodi sopra menzionati qui sono abbastanza diversi che vedo.

Ho avuto lo stesso problema. Sto usando _getch()poco prima della dichiarazione di ritorno. Funziona.

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

Ho avuto lo stesso problema, quando ho creato progetti con l'opzione "progetto vuoto", Crea progetto come "Applicazione console Win32" anziché "Progetto vuoto". Nella finestra di dialogo che si apre ora, premi "continua" e successivamente puoi selezionare l'opzione "progetto vuoto" e premere conferma. Successivamente CTRL + F5 aprirà una console che non si chiude automaticamente.

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

atexit(system("pause"));

o

atexit(cin.get());

In questo modo si fermerà, non importa dove usciamo dal programma.

Un'altra opzione:

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

In linea di principio:

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

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

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

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

Per Comando , immettere$(ComSpec)

Per Argomenti comando , immettere/k $(TargetPath) . Aggiungi eventuali argomenti alla tua domanda.

Ora F5 o Ctrl-F5 esegue Windows / System32 / cmd.exe in una nuova finestra e / k garantisce 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.

Come alcuni hanno già sottolineato, la soluzione Zoidbergs non collega il debugger, cosa che di solito non si desidera.

La migliore opzione imo è quella di configurare il tuo VS di conseguenza (dal VS 2017 in poi), andando su Strumenti> Opzioni> Debug> Generale. Lì deselezioni "Chiudi automaticamente la console quando il debug si arresta" (in fondo), che è probabilmente spuntato nel tuo caso.

puoi semplicemente mettere keep_window_open (); prima del ritorno qui c'è un esempio

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