Wie kann verhindert werden, dass die C ++ - Konsolenanwendung sofort beendet wird?

In letzter Zeit habe ich versucht, C ++ von dieser Website zu lernen . Wenn ich versuche, eines der Codebeispiele auszuführen, wird das Programm leider etwa eine halbe Sekunde lang geöffnet und dann sofort geschlossen. Gibt es eine Möglichkeit, das sofortige Schließen des Programms zu verhindern, damit ich die Früchte meiner Bemühungen sehen kann?

Bearbeiten: Wie Charles Bailey in einem Kommentar unten zu Recht hervorhebt, funktioniert dies nicht, wenn Zeichen gepuffert sind stdin, und es gibt wirklich keine gute Möglichkeit, dies zu umgehen. Wenn Sie mit einem angeschlossenen Debugger arbeiten, ist die von John Dibling vorgeschlagene Lösung wahrscheinlich die sauberste Lösung für Ihr Problem.

Das heißt, ich lasse das hier und vielleicht findet es jemand anderes nützlich. Ich habe es oft als eine Art schnellen Hack benutzt, wenn ich Tests während der Entwicklung geschrieben habe.

Am Ende Ihrer mainFunktion können Sie anrufenstd::getchar();

Dadurch wird ein einzelnes Zeichen erhalten stdin, wodurch Sie das Verhalten "Drücken Sie eine beliebige Taste, um fortzufahren" erhalten (wenn Sie tatsächlich die Meldung "Drücken Sie eine beliebige Taste" möchten, müssen Sie selbst eine drucken).

Sie müssen #include <cstdio>für getchar.

Wenn Sie Visual Studio verwenden und die Konsolenanwendung über die IDE starten:

Durch Drücken von STRG-F5 (ohne Debugging starten) wird die Anwendung gestartet und das Konsolenfenster geöffnet, bis Sie eine beliebige Taste drücken.

Die Lösung von James funktioniert für alle Plattformen.

Alternativ Windowskönnen Sie kurz vor Ihrer Rückkehr von der mainFunktion Folgendes hinzufügen :

  system("pause");

Dadurch wird der pauseBefehl ausgeführt, der wartet, bis Sie eine Taste drücken, und außerdem eine nette Nachricht anzeigtPress any key to continue . . .

Wenn Sie Microsoft Visual C ++ 2010 Express verwenden und auf das Problem stoßen, dass STRG + F5 nicht funktioniert, um die Konsole nach Beendigung des Programms geöffnet zu halten, sehen Sie sich diesen MSDN-Thread an .

Wahrscheinlich ist Ihre IDE so eingestellt, dass die Konsole nach einem STRG + F5-Lauf geschlossen wird. Tatsächlich schließt ein "leeres Projekt" in Visual C ++ 2010 die Konsole standardmäßig. Um dies zu ändern, gehen Sie wie vom Microsoft-Moderator vorgeschlagen vor:

Klicken Sie mit der rechten Maustaste auf Ihren Projektnamen und gehen Sie zur Seite Eigenschaften. Erweitern Sie Konfigurationseigenschaften -> Linker -> System. Wählen Sie in der Dropdown-Liste Subsystem die Option Konsole (/ SUBSYSTEM: CONSOLE) aus. Da das leere Projekt dies standardmäßig nicht angibt.

Normalerweise setze ich nur einen Haltepunkt main() die schließende geschweifte Klammer. Wenn das Ende des Programms auf irgendeine Weise erreicht ist, wird der Haltepunkt erreicht und Sie können ALT-Tab zum Konsolenfenster, um die Ausgabe anzuzeigen.

Warum nicht einfach das Programm von einer Konsole aus ausführen, dh das Programm von cmd.exe aus ausführen, wenn Sie Windows verwenden? Auf diese Weise bleibt das Fenster nach Beendigung des Programms geöffnet.

[BEARBEITEN]: Wenn ich KDevelop4 verwende, wird eine vollwertige Instanz von Bash (eine Linux-CLI) in einer Registerkarte am unteren Rand der IDE ausgeführt. Welches ist, was ich unter solchen Umständen benutze.

Fügen Sie vor dem Ende Ihres Codes diese Zeile ein:

system("pause");

Dadurch bleibt die Konsole so lange erhalten, bis Sie eine Taste drücken.

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

cin.get();2 mal anrufen :

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

Wenn Sie Ihren Code von einer kompetenten IDE wie Code :: Blocks ausführen, verwaltet die IDE die Konsole, mit der der Code ausgeführt wird, und lässt sie beim Schließen der Anwendung geöffnet. Sie möchten keinen speziellen Code hinzufügen, um die Konsole offen zu halten, da dies die ordnungsgemäße Funktion der Konsole beeinträchtigt, wenn Sie sie außerhalb der IDE tatsächlich verwenden.

Okay, ich vermute, Sie arbeiten mit Visual Studio unter Windows ... warum? Nun, wenn Sie unter einem Linux-Betriebssystem arbeiten, werden Sie es wahrscheinlich von der Konsole aus ausführen.

Wie auch immer, Sie können am Ende Ihres Programms Mist hinzufügen, wie andere es vorschlagen, oder Sie können einfach STRG + F5 drücken (ohne Debugging starten) und Visual Studio lässt die Konsole .

Eine andere Option, wenn Sie die Debug-Version ausführen und Ihrem Code keinen Mist hinzufügen möchten, besteht darin, das Konsolenfenster (Start -> Ausführen -> cmd) zu öffnen und zu Ihrem Debug-Ausgabeverzeichnis zu navigieren . Geben Sie dann einfach den Namen Ihrer ausführbaren Datei ein und Ihr Debug-Programm wird in der Konsole ausgeführt. Sie können dann den Anhang von Visual Studio verwenden, um etwas zu verarbeiten, wenn Sie dies wirklich möchten.

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

using namespace std;

int main()
{

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

    return 0;
}

Ich habe nicht bemerkt, dass jemand anderes dies gepostet hat, also hier ist es.

Wenn Sie Ihre Anwendung tatsächlich in Visual C ++ debuggen, drücken Sie F5 oder das grüne Dreieck in der Symbolleiste. Wenn Sie es nicht wirklich debuggen (Sie haben keine Haltepunkte festgelegt), drücken Sie Strg + F5 oder wählen Sie Start ohne Debugging in den Menüs (es befindet sich normalerweise im Debug-Menü, was meiner Meinung nach verwirrend ist.) Es wird etwas schneller sein. und was für Sie noch wichtiger ist, wird am Ende pausieren, ohne dass Sie Ihren Code ändern müssen.

Alternativ können Sie eine Eingabeaufforderung öffnen, zu dem Ordner navigieren, in dem sich Ihre Exe befindet, und sie ausführen, indem Sie ihren Namen eingeben. Auf diese Weise wird die Eingabeaufforderung nach Abschluss der Ausführung nicht geschlossen und Sie können die Ausgabe sehen. Ich bevorzuge beide Methoden gegenüber dem Hinzufügen von Code, der die App stoppt, sobald sie fertig ist.

Fügen Sie einfach am Ende Ihres Programms Folgendes hinzu. Es wird versucht, eine Form von Benutzereingaben zu erfassen, sodass die Konsole nicht automatisch geschlossen wird.

cin.get();

Fügen Sie vor jeder exit()Funktion oder vor jedem returns in die folgenden Zeilen ein main():

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

Für Visual Studio (und nur für Visual Studio) erhalten Sie mit dem folgenden Codeausschnitt die Eingabeaufforderung "Warten, bis der Tastendruck fortgesetzt wird", die wirklich darauf wartet, dass der Benutzer eine neue Taste explizit drückt , indem er zuerst den Eingabepuffer leert:

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

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

Beachten Sie, dass dies die tchar.hMakros verwendet, um mit mehreren 'Zeichensätzen' kompatibel zu sein (wie VC ++ sie nennt).

Ich mache einfach das:

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

Hinweis: Das Löschen des CIN-Puffers und dergleichen ist nur erforderlich, wenn Sie CIN zu einem früheren Zeitpunkt in Ihrem Programm verwendet haben. Auch die Verwendung von std :: numeric_limits :: max () ist wahrscheinlich besser als INT_MAX, aber etwas wortreich und normalerweise unnötig.

Verwenden Sie #include "stdafx.h"& system("pause");genau wie den Code unten.

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

Ähnliche Idee wie Ihre Antwort, nur minimalistische Alternative.

Erstellen Sie eine Batchdatei mit folgendem Inhalt:

helloworld.exe
pause

Verwenden Sie dann die Batch-Datei.

einfach

#include <cstdio>

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

Aus irgendeinem Grund kann normalerweise 1 Zeichen mit getchar bereits in stdin gelesen werden, wenn Sie ein Programm ausführen. Der erste getchar liest dieses Zeichen und der zweite getchar wartet auf Benutzereingaben, bevor er das Programm beendet. Und nachdem ein Programm die meisten Terminals beendet hat, schließen Sie das Terminal sofort, insbesondere unter Windows. Wir wollen also auf einfache Weise verhindern, dass ein Programm beendet wird, nachdem es alles ausgegeben hat. Natürlich gibt es komplexere und sauberere Wege, um dies zu lösen, aber dies ist der einfachste.

Überprüfen Sie, ob Ihre IDE in der Projekteinstellung ein Kontrollkästchen enthält, um das Fenster nach dem Beenden des Programms geöffnet zu lassen. Wenn nicht, std::cin.get();lesen Sie ein Zeichen am Ende der Hauptfunktion. Verwenden Sie jedoch nur zeilenbasierte Eingaben (std :: getline) oder behandeln Sie ansonsten ungelesene Zeichen (std :: ignore bis newline), da sonst .get () am Ende nur den Müll liest, den Sie hinterlassen haben früher ungelesen.

Das scheint gut zu funktionieren:

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

Wenn Sie zuerst den Puffer löschen, ist dies kein Problem, wenn Sie den nächsten lesen. Aus irgendeinem Grund cin.ignore(1)funktioniert es nicht, es muss 2 sein.

Sie können jederzeit eine Batchdatei erstellen. Wenn Ihr Programm beispielsweise helloworld.exe heißt, lautet der folgende Code:

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

Wenn Sie Windows ausführen, können Sie system("pause >nul");oder system("pause");. Es führt einen Konsolenbefehl aus, um das Programm anzuhalten, bis Sie eine Taste drücken. >nulverhindert es zu sagen Press any key to continue....

Ich setze einen Haltepunkt bei der letzten Rückgabe 0 des Programms. Es funktioniert gut.

Ich habe verwendet cin.get()und das hat funktioniert, aber eines Tages musste ich cin.get([Array Variable])vorher einen anderen verwenden , um eine Ling-Zeichenfolge mit leerem Zeichen in der Mitte zu greifen. so dass die cin.get()nicht - Eingabeaufforderung Fenster von Schließung vermeiden. Endlich habe ich einen anderen Weg gefunden: Drücken Sie STRG + F5 , um in einem externen Fenster zu öffnen, und Visual Studio hat keine Kontrolle mehr darüber. Ich werde Sie nur nach dem Schließen fragen, nachdem die letzten Befehle ausgeführt wurden.

Ich habe versucht, getchar()am Ende eine Funktion zu setzen . Aber es hat nicht funktioniert. Also habe ich zwei getchar()Funktionen nacheinander hinzugefügt . Ich denke, der erste getchar()absorbiert die EnterTaste, die Sie nach der letzten Dateneingabe drücken. Versuchen Sie also, zwei getchar()Funktionen anstelle einer hinzuzufügen

Anstatt die Run-Taste zu drücken, drücken Sie gleichzeitig STRG und F5. Sie können dann eine beliebige Taste drücken, um die Nachricht fortzusetzen. Oder geben Sie am Ende Ihrer Hauptfunktion "(Warnung nur zum Testen nicht aktueller Programme verwenden, da Antivirenprogramme es nicht mögen !!!!)" ein, aber: (Warnung Verwenden Sie diese Option nur zum Testen nicht aktueller Programme als Antivirenprogramm mag es nicht !!!!)

Verwenden Sie einfach cin.ignore (), bevor Sie 0 zurückgeben. zweimal

main()
  {
  //your codes 

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

  return 0;
  }

das ist alles

Alles, was Sie tun müssen, um eine Variable für x festzulegen, geben Sie diese einfach vor der Rückgabe 0 ein.

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

Sie können sogar eine Ganzzahl am Anfang Ihrer main()Funktion deklarieren (z. B. int a;) und std::cin >> a;kurz vor dem Rückgabewert setzen. Das Programm läuft also so lange weiter, bis Sie eine Taste drücken und eingeben.