Come interrompere immediatamente l'applicazione console C ++?

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?

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.

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.

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 . . .

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.

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.

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.

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
}

Chiama cin.get();2 volte:

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

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.

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.

#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.

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.

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();

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");

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 ++).

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.

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");
}

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.

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.

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.

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.

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

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....

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

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.

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

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 !!!!)

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

main()
  {
  //your codes 

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

  return 0;
  }

È tutto

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;

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.