Come interrompere immediatamente l'applicazione console C ++?


193

Ultimamente, ho cercato di imparare il C ++ da questo sito web . Sfortunatamente ogni volta che provo ad eseguire uno degli esempi di codice, vedo quel programma aperto per circa mezzo secondo e poi immediatamente chiuso. C'è un modo per fermare la chiusura immediata del programma in modo che io possa vedere i frutti del mio sforzo?


5
Fai doppio clic sul file eseguibile? Stai lavorando in Windows? Perché non stai lavorando dalla shell dei comandi e non stai digitando i comandi come vuoi che vengano eseguiti?
S.Lott

8
@S Lott: Perché se premi il pulsante "Vai" nel tuo IDE non devi preoccuparti di una console.
Billy ONeal,

4
Dovresti prendere in considerazione l'idea di ottenere un buon libro da cui imparare il C ++. I siti Web sono buone risorse, ma non corrispondono a un buon testo introduttivo. C'è un elenco definitivo di libri C ++ qui: stackoverflow.com/questions/388242/…
James McNellis

6
@Billy Se premendo il pulsante Vai si chiude l'app al termine, si sta utilizzando l'IDE errato.

2
Chiesto e risposto precedentemente qui: stackoverflow.com/questions/902261/… , anche se questo ha un titolo migliore.
dmckee --- ex gattino moderatore

Risposte:


122

Modifica: Come Charles Bailey sottolinea giustamente in un commento qui sotto, questo non funzionerà se ci sono personaggi tamponati stdine non c'è davvero un buon modo per aggirare questo. Se si esegue con un debugger collegato, la soluzione suggerita da John Dibling è probabilmente la soluzione più pulita al problema.

Detto questo, lo lascerò qui e forse qualcun altro lo troverà utile. L'ho usato molto come una sorta di hack rapido quando scrivevo test durante lo sviluppo.


Al termine della mainfunzione, è possibile chiamarestd::getchar();

Questo otterrà un singolo carattere stdin, dandoti così il tipo di comportamento "premi un tasto qualsiasi per continuare" (se in realtà vuoi un messaggio "premi un tasto qualsiasi", dovrai stamparlo tu stesso).

È necessario #include <cstdio>per getchar.


15
getcharnon risolve il problema - o solo in circostanze limitate, almeno. Legge un carattere da stdin, ma se ci sono già caratteri bufferizzati da stdin il programma andrà avanti senza attendere indipendentemente dal fatto che si stia stampando o meno un prompt.
CB Bailey,

1
@Charles: un buon punto. Ignorare fino a quando non \nè una soluzione parziale, ma non sarà di aiuto se viene bufferizzata più di una riga di input. Non conosco un modo C ++ standard per cancellare tutto da un flusso di input. : - /
James McNellis il

1
@James: Vecchio, ma che ne dici std::cin.ignore(std::cin.rdbuf()->in_avail());? Capito da qui .
GManNickG,

1
Un'opzione che uso molto è std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');con #include <limits>.
Xeo,

5
Per favore, non farlo. :( Non fa parte della funzione del tuo programma fare questo.
Lightness Races in Orbit il

138

Se si utilizza Visual Studio e si avvia l'applicazione console dall'IDE:

premendo CTRL-F5 (avvio senza debug) si avvia l'applicazione e si tiene aperta la finestra della console fino a quando non si preme un tasto qualsiasi.


1
Avvio della console dall'IDE? Come e perché lo faresti?
CodyBugstein,

1
Eccellente, ha funzionato. Perché questo non è il comportamento predefinito di Visual Studio?
Apparecchio d'illuminazione

Ho anche pensato che fosse il modo per farlo, fino ad oggi, quando ho creato un semplice programma console e il metodo sopra non ha funzionato :(
KansaiRobot

1
Esiste una versione di questo con il debug?
luckyging3r

109

La soluzione di James funziona per tutte le piattaforme.

In alternativa Windowspuoi anche aggiungere quanto segue appena prima di tornare dalla mainfunzione:

  system("pause");

Questo eseguirà il pausecomando che attende fino a quando premi un tasto e visualizza anche un bel messaggioPress any key to continue . . .


2
Sembra una variante Rube Goldberg di una soluzione.
Dave Van den Eynde,

4
@Dave Van den Eynde: è anche abbastanza comune e viene fornito di serie nel codice del boilerplate in DevCPP. +1
Billy ONeal

4
@Dave d'altra parte chiarisce che questo è solo un espediente per un esempio, mentre std: getch potrebbe essere accidentalmente lasciato nel codice reale.
Martin Beckett,

2
Questa è una soluzione perfettamente valida per quelli su Windows. Sebbene non sia l'ideale, funziona
signore

La soluzione più semplice, più veloce. Proprio quello di cui avevo bisogno
CodyBugstein il

83

Se si utilizza Microsoft Visual C ++ 2010 Express e si riscontra un problema con CTRL + F5 che non funziona per mantenere aperta la console dopo che il programma è terminato, dare un'occhiata a questo thread MSDN .

Probabilmente il tuo IDE è impostato per chiudere la console dopo un'esecuzione CTRL + F5; infatti, un "Progetto vuoto" in Visual C ++ 2010 chiude la console per impostazione predefinita. Per modificare ciò, fai come suggerito dal moderatore Microsoft:

Fare clic con il pulsante destro del mouse sul nome del progetto e andare alla pagina Proprietà, espandere Proprietà di configurazione -> Linker -> Sistema, selezionare Console (/ SOTTOSISTEMA: CONSOLLE) nel menu a discesa Sottosistema. Perché, per impostazione predefinita, il progetto vuoto non lo specifica.


1
E se non fosse un'app console?
Jesse Pepper,

3
@ Mr.Underhill Funzionerà solo se si avvia senza il debugger (Ctrl + F5).
Jonathan Mee,

Oltre ad essere l'unica soluzione non hack, questo è anche l'unico modo per vedere le stampe dai distruttori degli oggetti dello stack principale.
Poniros,

20

Di solito metto un punto di interruzione sulla main()parentesi graffa di chiusura. Quando la fine del programma viene raggiunta con qualsiasi mezzo, il punto di interruzione colpirà e sarà possibile ALT-Tab nella finestra della console per visualizzare l'output.


14

Perché non eseguire semplicemente il programma da una console, ad esempio eseguire il programma da cmd.exe se si utilizza Windows. In questo modo la finestra rimane aperta al termine del programma.

[EDIT]: quando uso KDevelop4 c'è un'istanza a tutti gli effetti di Bash (una CLI di Linux) in esecuzione in una scheda nella parte inferiore dell'IDE. Che è quello che uso in questo tipo di circostanze.


3
Perché se stai usando un IDE non usi generalmente una console. Premi push, il programma viene eseguito e il gioco è fatto.
Billy ONeal,

3
Qualsiasi IDE competente manterrà la console sullo schermo quando l'app termina, ad esempio Code :: Blocks fa esattamente questo.

3
@nobugz: l'ho capito. Per far sì che la finestra si attacchi, devi avere / SUBSYSTEM: CONSOLE sulla riga di comando del linker. La documentazione dice che questo è il valore predefinito se mainè definito, ma se non lo imposto esplicitamente sulla riga di comando, VS uccide la finestra all'uscita dell'applicazione. sospiro
James McNellis il

2
@James: che è necessario per ottenere una finestra della console in primo luogo. Ciò a sua volta richiede main () anziché WinMain (), non viceversa. Mi sono perso un po '...
Hans Passant,

4
@nobugz: se si parte da un "Progetto vuoto" anziché da "Applicazione console Win32", il sottosistema non viene impostato esplicitamente nelle proprietà del progetto. Se si definisce mainnel progetto, il linker per impostazione predefinita utilizza il sottosistema CONSOLE. Quando esegui il debug o esegui, otterrai una finestra della console. Tuttavia, a meno che non specifichi esplicitamente CONSOLE come sottosistema nelle proprietà del progetto, Visual Studio non manterrà aperta la finestra della console. Comincio sempre da un progetto vuoto e raramente cambio le proprietà dei singoli progetti, quindi non ho mai visto la finestra della console rimanere in giro. Ci scusiamo per la confusione
James McNellis il

9

Prima della fine del codice, inserisci questa riga:

system("pause");

Ciò manterrà la console fino a quando non si preme un tasto.

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s;
    cout << "Please enter your first name followed by a newline\n";
    cin >> s;
    cout << "Hello, " << s << '\n';
    system("pause"); // <----------------------------------
    return 0; // This return statement isn't necessary
}

Ha inoltre stampato "Premere un tasto qualsiasi per continuare ..." per me.
PapaHotelPapa,

8

Chiama cin.get();2 volte:

    //...
    cin.get();
    cin.get();
    return 0
}

6
ma perché due volte ??
Madhawa Priyashantha

e se avessimo bisogno di un altro cin.get () per ottenere ad esempio una stringa all'interno dell'array prima di questo? Non funziona in questo scenario.
QMaster

4

Se esegui il tuo codice da un IDE competente, come Code :: Blocks , l'IDE gestirà la console che utilizza per eseguire il codice, mantenendolo aperto alla chiusura dell'applicazione. Non si desidera aggiungere un codice speciale per mantenere aperta la console, perché ciò impedirà il suo corretto funzionamento quando lo si utilizza per davvero, al di fuori dell'IDE.


3

Ok, immagino che tu sia su Windows usando Visual Studio ... perché? Bene perché se ti trovi su una sorta di sistema operativo Linux, probabilmente lo avresti eseguito dalla console.

Ad ogni modo, puoi aggiungere schifezze alla fine del programma come suggeriscono altri, oppure puoi semplicemente premere CTRL + F5 (avviare senza debug) e Visual Studio lascerà la console una volta completata.

Un'altra opzione se si desidera eseguire la versione di debug e non aggiungere schifezze al codice è aprire la finestra della console (Start -> Esegui -> cmd) e passare alla directory di output del debug . Quindi, basta inserire il nome dell'eseguibile e verrà eseguito il programma di debug nella console. È quindi possibile utilizzare l'allegato di Visual Studio per elaborare o qualcosa del genere, se proprio lo si desidera.


3
#include "stdafx.h"
#include <iostream>
#include <conio.h>

using namespace std;

int main()
{

    cout << "Press any key to continue...";
    getch();

    return 0;
}

Non ho notato che nessun altro lo abbia pubblicato, quindi eccolo qui.


Aggiungo che si conio.htratta di un'intestazione specifica di Windows e potrebbe non essere disponibile su tutti i computer (o potrebbe essere necessario collegarlo separatamente, il che è eccessivo).
Yksisarvinen,

Lavorando. avevo solo bisogno di cambiare getch (); a _getch (); da quando è diventato obsoleto
ncesar il

2

Se stai effettivamente eseguendo il debug dell'applicazione in Visual C ++, premi F5 o il triangolo verde sulla barra degli strumenti. Se non lo stai davvero eseguendo il debug (non hai set di punti di interruzione), premi Ctrl + F5 o scegli Avvia senza debug nei menu (di solito è nel menu Debug, che concordo è confuso.) Sarà un po 'più veloce, e, cosa più importante per te, si fermerà alla fine senza che tu debba cambiare il tuo codice.

In alternativa, apri un prompt dei comandi, vai alla cartella in cui si trova il tuo exe ed eseguilo digitandone il nome. In questo modo al termine dell'esecuzione del prompt dei comandi non si chiude e si può vedere l'output. Preferisco entrambi questi metodi per aggiungere il codice che arresta l'app appena terminata.


2

Basta aggiungere quanto segue alla fine del programma. Tenterà di acquisire una qualche forma di input dell'utente, impedendo così alla console di chiudersi automaticamente.

cin.get();

2

Aggiungi le seguenti righe prima di qualsiasi exit()funzione o prima di ogni returns in main():

std::cout << "Paused, press ENTER to continue." << std::endl;
cin.ignore(100000, "\n");

Questo non funziona per me, la prima riga funziona ma premendo
invio

2

Per Visual Studio (e solo Visual Studio) il seguente frammento di codice fornisce un prompt 'aspetta che il tasto premuto continui' che attende davvero che l'utente prema esplicitamente un nuovo tasto, svuotando prima il buffer di input:

#include <cstdio>
#include <tchar.h>
#include <conio.h>

_tprintf(_T("Press a key to continue "));
while( _kbhit() /* defined in conio.h */ ) _gettch();
_gettch();

Nota che questo usa le tchar.hmacro per essere compatibile con più 'set di caratteri' (come li chiama VC ++).


2

Faccio solo questo:

//clear buffer, wait for input to close program
std::cin.clear(); std::cin.ignore(INT_MAX, '\n');
std::cin.get();
return 0;

Nota: cancellare il buffer cin e questo è necessario solo se hai usato cin ad un certo punto nel programma. Anche usare std :: numeric_limits :: max () è probabilmente migliore di INT_MAX, ma è un po 'prolisso e di solito non necessario.


Funziona, ma il ritorno 0; non eseguirò se uso questo codice.
Wernersbacher,

2

Usa #include "stdafx.h"e system("pause");proprio come il codice in basso.

#include "stdafx.h"
#include <iostream>
using namespace std;
int main()
{
    std::cout << "hello programmer!\n\nEnter 2 numbers: ";
    int x, y;
    std::cin >> x >> y;
    int w = x*y;
    std::cout <<"\nyour answer is: "<< w << endl;
    system("pause");
}

systemè dichiarato in <cstdlib>no stdafx.h.
melpomene,

1

Un'idea simile a yeh risposta, solo minimalista alternativa.

Creare un file batch con il seguente contenuto:

helloworld.exe
pause

Quindi utilizzare il file batch.


1

semplicemente

#include <cstdio>

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

per qualche ragione di solito c'è 1 carattere che è possibile leggere con getchar già in stdin quando si esegue un programma. quindi il primo getchar legge questo carattere e il secondo getchar attende l'input dell'utente (tuo) prima di uscire dal programma. E dopo che un programma esce dalla maggior parte dei terminali, in particolare sul terminale di chiusura di Windows immediatamente. quindi ciò a cui miriamo è un modo semplice per impedire che un programma finisca dopo che ha prodotto tutto. Naturalmente ci sono modi più complessi e chiari per risolvere questo, ma questo è il più semplice.


2
Aggiungi almeno una breve spiegazione del perché questo risolve il problema.
kaya3

0

Verifica se il tuo IDE ha una casella di controllo nelle impostazioni del progetto per mantenere aperta la finestra al termine del programma. In caso contrario, utilizzare std::cin.get();per leggere un carattere alla fine della funzione principale. Tuttavia, assicurati di utilizzare solo l'input basato su riga (std :: getline) o di trattare altrimenti i caratteri non letti rimanenti (std :: ignore fino a newline) perché altrimenti il ​​.get () alla fine leggerà solo la spazzatura che hai lasciato non letto in precedenza.


0

Questo sembra funzionare bene:

cin.clear();
cin.ignore(2);

Se si cancella prima il buffer, non sarà un problema quando si legge quello successivo. Per qualche motivo cin.ignore(1)non funziona, deve essere 2.


1
2 a volte non è anche sufficiente (quando ci sono più sequenze di tasti in coda). Il modo corretto consiste nell'ignorare tutti i caratteri presenti nella coda. Per con cin.rdbuf()->in_avail,. Non un numero magico, come 1 o 2.
Konrad Rudolph

0

Puoi sempre creare un file batch. Ad esempio, se il tuo programma si chiama helloworld.exe, alcuni codici sarebbero:

@echo off
:1
cls
call helloworld.exe
pause >nul
goto :1

0

Se stai utilizzando Windows, puoi farlo system("pause >nul");o system("pause");. Esegue un comando della console per mettere in pausa il programma fino a quando non si preme un tasto. >nulimpedisce di dire Press any key to continue....


0

Sto mettendo un punto di interruzione all'ultimo ritorno 0 del programma. Funziona bene


1
Questo non fornisce una risposta alla domanda. Per criticare o richiedere chiarimenti a un autore, lascia un commento sotto il suo post: puoi sempre commentare i tuoi post e una volta che avrai una reputazione sufficiente sarai in grado di commentare qualsiasi post .
Ravi Dhoriya ツ

1
In che modo questo non fornisce risposta? Sono esattamente nella stessa situazione dell'autore di una domanda e questo aiuta.
lierosk,

0

Ho usato cin.get()e ha funzionato, ma un giorno dovevo usarne un altro cin.get([Array Variable])prima di afferrare una stringa ling con un carattere vuoto nel mezzo. quindi la cin.get()finestra del prompt dei comandi non è stata evitata dalla chiusura. Alla fine ho trovato un altro modo: premi CTRL + F5 per aprire in una finestra esterna e Visual Studio non ha più il controllo su di essa. Ti chiederò solo di chiudere dopo l'esecuzione dei comandi finali.


0

Ho provato a mettere una getchar()funzione alla fine. Ma non ha funzionato. Quindi quello che ho fatto è stato aggiungere due getchar()funzioni una dopo l'altra. Penso che il primo getchar()assorba il Entertasto che premi dopo l'ultimo input di dati. Quindi prova ad aggiungere due getchar()funzioni anziché una


0

Invece di premere il pulsante Esegui, premi CTRL e F5 contemporaneamente, ti darà la pressione di qualsiasi tasto per continuare il messaggio. Oppure digita "(avviso utilizza questo solo per testare programmi non reali come un antivirus non piace !!!!)" alla fine della tua funzione principale ma: (avviso usa questo solo per testare programmi non reali come un antivirus non mi piace !!!!)


0

basta usare cin.ignore () subito prima di restituire 0; due volte

main()
  {
  //your codes 

  cin.ignore();
  cin.ignore();

  return 0;
  }

È tutto


Normalmente faccio qualcosa del genere. cin.ignore (); cin.get ();
aj.toulan,

-1

Tutto quello che devi fare è impostare una variabile per x quindi digitarla prima del ritorno 0;

cout<<"\nPress any key and hit enter to end...";
cin>>x;

-1

Puoi persino dichiarare un numero intero all'inizio della tua main()funzione (diciamo int a;) e metterlo std::cin >> a;appena prima del valore restituito. Quindi il programma continuerà a funzionare finché non si preme un tasto e si accede.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.