Voorkomen dat het consolevenster wordt gesloten in de Visual Studio C/C++ Console-toepassing

Dit is waarschijnlijk een gênante vraag, aangezien het antwoord ongetwijfeld verblindend duidelijk is.

Ik gebruik Visual Studio al jaren, maar dit is de eerste keer dat ik een ‘Console Application’-ontwikkeling heb gedaan.

Als ik mijn applicatie start, verschijnt het consolevenster, verschijnt de programma-uitvoer en sluit het venster wanneer de applicatie wordt afgesloten.

Is er een manier om het open te houden totdat ik de uitvoer heb gecontroleerd, of de resultaten te bekijken nadat het venster is gesloten?

Antwoord 1, autoriteit 100%

Vanaf Visual Studio 2017 (15.9.4) is er een optie:

Tools->Options->Debugging->Automatically close the console

Het bijbehorende fragment uit de Visual Studio-documentatie:

Sluit de console automatisch wanneer het debuggen stopt:

Vertelt Visual Studio om de console te sluiten aan het einde van een foutopsporingssessie.

Antwoord 2, autoriteit 98%

Als u uitvoert zonder foutopsporing (Ctrl+F5), wordt u standaard gevraagd om op Return te drukken om het venster te sluiten. Als je de debugger wilt gebruiken, moet je een breekpunt op de laatste regel plaatsen.

Antwoord 3, autoriteit 99%

Klik met de rechtermuisknop op uw project

Eigenschappen > Configuratie-eigenschappen > Linker > Systeem

Selecteer Console (/SUBSYSTEM:CONSOLE) in de optie SubSystem of typ gewoon Console in het tekstveld!

Probeer het nu… het zou moeten werken

Antwoord 4, autoriteit 85%

Hier is een manier voor C/C++:

#include <stdlib.h>
#ifdef _WIN32
    #define WINPAUSE system("pause")
#endif

Zet dit bovenaan je programma en ALS het op een Windows-systeem staat (#ifdef _WIN32), dan zal het een macro maken met de naam WINPAUSE. Telkens wanneer u wilt dat uw programma pauzeert, roept u WINPAUSE; aan en het zal het programma pauzeren met behulp van het DOS-commando. Voor andere systemen, zoals Unix/Linux, zou de console toch niet moeten stoppen bij het afsluiten van het programma.

Antwoord 5, autoriteit 62%

Ga naar debug-menu->Druk op StartWithoutDebugging

Antwoord 6, autoriteit 60%

Als u .NET gebruikt, plaatst u Console.ReadLine() vóór het einde van het programma.

Het zal wachten op <ENTER>.

Antwoord 7, autoriteit 26%

probeer getchar() te bellen vlak voordat main() terugkeert.

Antwoord 8, autoriteit 23%

(/SUBSYSTEM:CONSOLE) werkte niet voor mijn vs2013 (ik had het al).

“uitvoeren zonder foutopsporing” is geen optie, aangezien ik niet wil schakelen tussen foutopsporing en uitvoer zien.

Ik eindigde met

int main() {
  ...
#if _DEBUG
  LOG_INFO("end, press key to close");
  getchar();
#endif // _DEBUG
  return 0;
}

Oplossing gebruikt in qtcreator pre 2.6. Terwijl qt groeit, gaat vs een andere kant op. Zoals ik me herinner, hadden we in vs2008 zulke trucs niet nodig.

Antwoord 9, autoriteit 13%

Hier is een oplossing die (1) geen codewijzigingen of onderbrekingspunten vereist, en (2) na beëindiging van het programma pauzeert zodat u alles kunt zien dat was afgedrukt. Het pauzeert na F5 of Ctrl+F5. Het grootste nadeel is dat het op VS2013 Express (zoals getest) geen symbolen laadt, dus het debuggen is zeer beperkt.

1. Maak een batchbestand. Ik noemde de mijne runthenpause.bat, met de volgende inhoud:

   %1 %2 %3 %4 %5 %6 %7 %8 %9
   pause
   

   De eerste regel zal elk commando uitvoeren dat u opgeeft en maximaal acht argumenten. De tweede regel zal… pauzeren.

2. Open de projecteigenschappen | Configuratie-eigenschappen | Foutopsporing.

3. Verander “Opdrachtargumenten” in $(TargetPath) (of wat dan ook in “Opdracht”).
4. Verander “Opdracht” in het volledige pad naar runthenpause.bat.
5. Klik op OK.

Als je het nu uitvoert, zal runthenpause.bat je applicatie starten en nadat je applicatie is beëindigd, pauzeren zodat je de console-uitvoer kunt zien.

Ik zal een update plaatsen als ik weet hoe ik de symbolen kan laden. Ik heb /Z7 per dit geprobeerd, maar zonder succes.

Antwoord 10, autoriteit 13%

stel gewoon als je laatste regel code:

system("pause");

Antwoord 11, autoriteit 8%

voeg | . toe pauze in het vak met opdrachtargumenten onder de foutopsporingssectie bij projecteigenschappen.

Antwoord 12, autoriteit 6%

U kunt uw uitvoerbare bestand uitvoeren vanaf een opdrachtprompt. Op deze manier kon je alle output zien. Of je zou zoiets als dit kunnen doen:

int a = 0;
scanf("%d",&a);
return YOUR_MAIN_CODE;

en op deze manier zou het venster pas sluiten als u gegevens invoert voor de variabele a.

Antwoord 13, autoriteit 6%

Druk gewoon op CNTRL + F5 om het te openen in een extern opdrachtregelvenster (Visual Studio heeft er geen controle over).

Als dit niet werkt, voeg dan het volgende toe aan het einde van je code:

Console.WriteLine("Press any key to exit...");
Console.ReadKey();

Hiermee wacht u tot u op een toets drukt om het terminalvenster te sluiten zodra de code het einde heeft bereikt.

Als u dit op meerdere plaatsen wilt doen, plaatst u de bovenstaande code in een methode (bijv. private void Pause()) en roept u Pause() aan wanneer een programma een mogelijk einde bereikt.

Antwoord 14, autoriteit 4%

Een wat betere oplossing:

atexit([] { system("PAUSE"); });

aan het begin van je programma.

Pluspunten:

• kan std::exit() gebruiken
• kan meerdere retouren hebben van hoofd
• u kunt uw programma uitvoeren onder de debugger
• IDE-onafhankelijk (+ OS-onafhankelijk als je de truc cin.sync(); cin.ignore(); gebruikt in plaats van system("pause");)

Nadelen:

• code moeten wijzigen
• pauzeert niet op std::terminate()
• gebeurt nog steeds in uw programma buiten de IDE/debugger-sessie; u kunt dit onder Windows voorkomen door:

extern "C" int __stdcall IsDebuggerPresent(void);
int main(int argc, char** argv) {
    if (IsDebuggerPresent())
        atexit([] {system("PAUSE"); });
    ...
}

Antwoord 15, autoriteit 4%

Gebruik:

1. cin.get();

of

2. system("pause");

Zorg ervoor dat u een van beide maakt aan het einde van de functie main() en vóór de instructie return.

Antwoord 16, autoriteit 4%

U kunt deze optie ook gebruiken

#include <conio.h> 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main() {
   .
   .
   .
   getch(); 
   return 0;
}

Antwoord 17, autoriteit 4%

In mijn geval heb ik dit ervaren toen ik een Empty C++-project maakte in de VS 2017-communityeditie. U moet het subsysteem instellen op “Console (/SUBSYSTEM:CONSOLE)” onder Configuratie-eigenschappen.

1. Ga naar “Bekijken” en selecteer vervolgens “Property Manager”
2. Klik met de rechtermuisknop op het project/de oplossing en selecteer “Eigenschap”. Dit opent een testeigenschapspagina
3. Navigeer naar de linker en selecteer “Systeem”
4. Klik op “SubSystem” en er verschijnt een vervolgkeuzelijst
5. Kies “Console (/SUBSYSTEM:CONSOLE)”
6. Toepassen en opslaan
7. De volgende keer dat u uw code uitvoert met “CTRL +F5”, zou u de uitvoer moeten zien.

Antwoord 18, autoriteit 2%

Gebruik Console.ReadLine() aan het einde van het programma. Hierdoor blijft het venster open totdat u op de Enter-toets drukt. Zie https://docs.microsoft.com/en-us /dotnet/api/system.console.readline voor details.

Antwoord 19

Visual Studio 2015, met imports. Omdat ik haat
wanneer codevoorbeelden niet de benodigde invoer geven.

#include <iostream>;
int main()
{
    getchar();
    return 0;
}

Antwoord 20

Ga naar Setting>Debug>Sluit het vinkje bij sluiten op einde uit.

Antwoord 21

Momenteel is er geen manier om dit te doen met apps die in WSL2 draaien. Er zijn echter twee oplossingen:

1. Het foutopsporingsvenster behoudt de inhoud van het WSL-shellvenster dat is gesloten.

2. Het venster blijft open als uw toepassing een retourcode retourneert die niet nul is, dus u kunt bijvoorbeeld een niet-nul retourneren in debug-builds.

Antwoord 22

Soms kan een simpele hack die je setup of code niet verandert zijn:

Stel een breekpunt in met F9 en voer vervolgens Debug uit met F5.