Wie kann das Konsolenfenster in Visual C ++ geöffnet bleiben?

Ich beginne mit Visual C ++ und möchte wissen, wie das Konsolenfenster beibehalten wird.

Zum Beispiel wäre dies eine typische "Hallo Welt" -Anwendung:

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

Was ist die Zeile, die ich vermisse?

Starten Sie das Projekt mit Ctrl+F5statt nur F5.

Das Konsolenfenster bleibt nun mit der Press any key to continue . . .Meldung geöffnet , nachdem das Programm beendet wurde.

Beachten Sie, dass hierfür die Console (/SUBSYSTEM:CONSOLE)Linker-Option erforderlich ist , die Sie wie folgt aktivieren können:

1. Öffnen Sie Ihr Projekt und rufen Sie den Projektmappen-Explorer auf. Wenn Sie mir in K & R folgen, lautet Ihre "Lösung" "Hallo" mit 1 Projekt darunter, auch "Hallo" in Fettdruck.
2. Klicken Sie mit der rechten Maustaste auf "Hallo" (oder wie auch immer Ihr Projektname lautet.)
3. Wählen Sie "Eigenschaften" aus dem Kontextmenü.
4. Wählen Sie Konfigurationseigenschaften> Linker> System.
5. Klicken Sie für die Eigenschaft "Subsystem" im rechten Bereich auf das Dropdown-Feld in der rechten Spalte.
6. Wählen Sie "Konsole (/ SUBSYSTEM: CONSOLE)"
7. Klicken Sie auf Übernehmen, warten Sie, bis der Vorgang abgeschlossen ist, und klicken Sie dann auf OK. (Wenn "Übernehmen" abgeblendet ist, wählen Sie eine andere Subsystemoption aus, klicken Sie auf Übernehmen und wenden Sie dann die Konsolenoption an. Meiner Erfahrung nach funktioniert OK an sich nicht.)

STRG-F5 und die Subsystemhinweise arbeiten zusammen. Sie sind keine separaten Optionen.

(Mit freundlicher Genehmigung von DJMorreTX von http://social.msdn.microsoft.com/Forums/en-US/vcprerelease/thread/21073093-516c-49d2-81c7-d960f6dc2ac6 )

Der Standardweg ist cin.get()vor Ihrer Rückgabeerklärung.

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

Setzen Sie einen Haltepunkt auf die returnLinie.

Sie führen es im Debugger aus, richtig?

Eine andere Option ist zu verwenden

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

Dies ist zwar nicht sehr portabel, da es nur unter Windows funktioniert, aber automatisch gedruckt wird

Drücken Sie eine beliebige Taste, um fortzufahren...

Bei Makefile-Projekten schlägt die akzeptierte Lösung aufgrund eines Fehlers in Visual Studio fehl (der mindestens bis zur Version 2012 vorhanden ist - ich habe 2013 noch nicht getestet). Dieser Fehler wird hier detailliert beschrieben .

Führen Sie die folgenden Schritte aus, damit die Konsole nach dem Beenden des Programms in einem Makefile-Projekt angehalten wird (dies kann für andere Versionen als 2010 - 2012 abweichen):

1) /SUBSYSTEM:CONSOLEAn den Linker übergeben. - BEARBEITEN : siehe unten.

2) Öffnen Sie Ihre Projektdatei (.vcxproj) in einem Texteditor.

3) Fügen Sie in das Root- <project>Tag Folgendes ein:

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

4) Laden Sie das Projekt in Ihre Lösung neu.

5) Führen Sie das Programm ohne Debugging aus (STRG + F5).

BEARBEITEN:

Gemäß meinem Kommentar unten ist das Festlegen der Linker-Option /SUBSYSTEM:CONSOLEfür Makefile-Projekte eigentlich irrelevant (und nicht unbedingt sogar möglich, wenn Sie einen anderen Compiler als MSVC verwenden). Alles, was zählt, ist, dass die Einstellung der .vcxproj-Datei gemäß Schritt 3 oben hinzugefügt wird.

Sie können cin.get();oder cin.ignore();kurz vor Ihrer return-Anweisung verwenden, um zu verhindern, dass das Konsolenfenster geschlossen wird.

Setzen Sie einfach einen Haltepunkt auf die letzte geschweifte Klammer der Hauptleitung.

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

Es funktioniert für mich, es muss nicht ohne Debugging ausgeführt werden. Außerdem werden Destruktoren ausgeführt, bevor der Haltepunkt erreicht wird, sodass Sie überprüfen können, ob Nachrichten auf diesen Destruktoren gedruckt wurden, falls vorhanden.

Fügen Sie einfach einen Haltepunkt in die schließende Klammer Ihrer _tmainMethode ein. Dies ist der einfachere Weg und Sie müssen keinen Code hinzufügen, um zu debuggen.

Setzen Sie einen Haltepunkt auf die Endklammer von main(). Es wird auch bei mehreren returnAnweisungen ausgelöst . Der einzige Nachteil ist, dass ein Anruf exit()nicht abgefangen wird.

Wenn Sie nicht debuggen, folgen Sie den Anweisungen in Zoidbergs Antwort und starten Sie Ihr Programm mit Ctrl+ F5anstatt nur F5.

Meine 2 Cent:

Auswahl 1: Fügen Sie am Ende einen Haltepunkt hinzu main()

Auswahl 2: Fügen Sie diesen Code direkt vor dem 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');

Sie müssen enthalten <iomanip>fürstd::numeric_limits

Fügen Sie einfach das System ("Pause") am Ende des Codes hinzu, bevor Sie 0 wie folgt zurückgeben

#include <stdlib.h>

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

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

cin.get()oder system("PAUSE"). Ich habe nicht gehört, dass Sie verwenden könnenreturn(0);

Ich #include <conio.h>füge hinzu und füge dann getch();kurz vor der return 0;Zeile hinzu. Das habe ich sowieso in der Schule gelernt. Die oben genannten Methoden sind ganz anders, wie ich sehe.

Hatte das gleiche Problem. Ich benutze _getch()kurz vor der return-Anweisung. Es klappt.

(Einige Optionen können unter verschiedenen Namen aufgerufen werden. Ich verwende nicht die englische Version.)

Ich hatte das gleiche Problem, als ich Projekte mit der Option "leeres Projekt" erstellte, Projekt als "Win32-Konsolenanwendung" anstelle von "leeres Projekt" erstellen. In dem Dialogfeld, das jetzt angezeigt wird, drücken Sie "Weiter". Danach können Sie die Option "Projekt leeren" aktivieren und auf "Bestätigen" klicken. Danach öffnet STRG + F5 eine Konsole, die nicht automatisch geschlossen wird.

Ich hatte das gleiche Problem; In meiner Anwendung gibt es mehrere exit () - Punkte und es gab keine Möglichkeit zu wissen, wo genau es beendet wird. Dann habe ich Folgendes herausgefunden:

atexit(system("pause"));

oder

atexit(cin.get());

Auf diese Weise wird es gestoppt, egal wo wir im Programm beenden.

Andere Option:

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

In der Hauptsache:

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

Die eigentliche Lösung ist die Auswahl der Projektvorlage. Sie MÜSSEN die Win32-Konsolenanwendung in älterem VS auswählen oder zuerst den Projektnamen eingeben und dann auf den Windows-Desktop-Assistenten doppelklicken und dann die Win32-Konsolenanwendung auswählen. Wählen Sie dann an dieser Stelle ein leeres Projekt aus. Dies ermöglicht dann, was der ursprüngliche Fragesteller wirklich wollte, ohne zusätzlichen Haltepunkt hinzuzufügen und Code zu halten. Ich habe auch dieses Problem durchlaufen. Die Antwort ist auch auf der MSDN-Site.

Hier ist eine Möglichkeit, das Befehlsfenster offen zu halten, unabhängig davon, wie die Ausführung gestoppt wird, ohne dass Code geändert wird:

Öffnen Sie in Visual Studio Projekteigenschaftsseiten -> Debuggen .

Geben Sie als Befehl ein$(ComSpec)

Geben Sie als Befehlsargumente ein /k $(TargetPath). Fügen Sie Ihrer eigenen Anwendung Argumente hinzu.

Jetzt F5 oder Strg-F5 führt windows / system32 / cmd.exe in einem neuen Fenster und / k sichergestellt , dass die Eingabeaufforderung bleibt nach Abschluss der Ausführung öffnen.

Der Nachteil ist, dass die Ausführung an Haltepunkten nicht stoppt.

Wie einige bereits betont haben, hängt die Zoidbergs-Lösung den Debugger nicht an, was Sie normalerweise nicht möchten.

Die beste Option imo ist, Ihren VS entsprechend zu konfigurieren (ab VS 2017), indem Sie zu Extras> Optionen> Debugging> Allgemein gehen. Dort deaktivieren Sie "Konsole automatisch schließen, wenn das Debuggen beendet wird" (ganz unten), was in Ihrem Fall wahrscheinlich aktiviert ist.

Sie können einfach keep_window_open () setzen; vor der Rückkehr hier ist ein Beispiel

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