De laatste tijd probeer ik C++ te leren van deze website. Helaas, telkens wanneer ik een van de codevoorbeelden probeer uit te voeren, zie ik dat programma ongeveer een halve seconde openen en dan onmiddellijk sluiten. Is er een manier om te voorkomen dat het programma onmiddellijk wordt afgesloten, zodat ik de vruchten van mijn inspanning kan zien?
Antwoord 1, autoriteit 100%
Als u Visual Studio gebruikt en u start de consoletoepassing vanuit de IDE:
door op CTRL-F5te drukken (start zonder foutopsporing) wordt de toepassing gestart en blijft het consolevenster open totdat u op een willekeurige toets drukt.
Antwoord 2, autoriteit 96%
Bewerken:Zoals Charles Bailey terecht opmerkt in een opmerking hieronder, zal dit niet werken als er tekens zijn gebufferd in stdin, en er is echt geen goede manier om werk daar omheen. Als je met een debugger werkt, De voorgestelde oplossing van John Diblingis waarschijnlijk de schoonste oplossing voor uw probleem.
Dat gezegd hebbende, laat ik dit hier en misschien vindt iemand anders het nuttig. Ik heb het veel gebruikt als een soort snelle hack bij het schrijven van tests tijdens de ontwikkeling.
Aan het einde van uw main-functie kunt u std::getchar();
Dit krijgt een enkel teken van stdin, waardoor je het soort “druk op een willekeurige toets om door te gaan”-gedrag krijgt (als je echt een “druk op een toets”-bericht wilt, moet je om er zelf een af te drukken).
Je moet #include <cstdio>voor getchar.
Antwoord 3, autoriteit 89%
De oplossing van James werkt voor alle platforms.
Als alternatief kunt u op Windowsook het volgende toevoegen net voordat u terugkeert van de main-functie:
system("pause");
Hiermee wordt de opdracht pauseuitgevoerd die wacht tot u op een toets drukt en ook een mooi bericht weergeeft Press any key to continue . . .
Antwoord 4, autoriteit 62%
Als je Visual C++ 2010 Express van Microsoft gebruikt en het probleem tegenkomt waarbij CTRL+F5niet werkt om de console open te houden nadat het programma is beëindigd, kijk dan eens naar deze MSDN-thread.
Waarschijnlijk is uw IDE ingesteld om de console te sluiten na een CTRL+F5-run; in feite sluit een “leeg project” in Visual C++ 2010 de console standaard af. Als u dit wilt wijzigen, doet u wat de Microsoft-moderator heeft voorgesteld:
Klik met de rechtermuisknop op uw projectnaam en ga naar de pagina Eigenschappen, vouw Configuratie-eigenschappen uit -> Linker -> Systeem, selecteer alstublieft Console (/SUBSYSTEM:CONSOLE) in de vervolgkeuzelijst SubSystem. Omdat het lege project dit standaard niet specificeert.
Antwoord 5, autoriteit 14%
Meestal plaats ik gewoon een breekpunt op de accolade sluiten van main(). Wanneer het einde van het programma op wat voor manier dan ook wordt bereikt, zal het breekpunt worden bereikt en kun je met Alt-Tab naar het consolevenster gaan om de uitvoer te bekijken.
Antwoord 6, autoriteit 11%
Waarom voert u het programma niet gewoon uit vanaf een console, dwz voer het programma uit vanaf cmd.exe als u Windows gebruikt. Op die manier blijft het venster open nadat het programma is afgelopen.
[EDIT]: Als ik KDevelop4 gebruik, wordt er een volwaardige instantie van Bash (een Linux CLI) uitgevoerd in een tabblad onderaan de IDE. Dat is wat ik in dit soort omstandigheden gebruik.
Antwoord 7, autoriteit 9%
Voer voor het einde van uw code deze regel in:
system("pause");
Hierdoor blijft de console totdat u een toets indrukt.
#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
}
Antwoord 8, autoriteit 6%
Bel cin.get();2 keer:
//...
cin.get();
cin.get();
return 0
}
Antwoord 9, autoriteit 3%
Als u uw code uitvoert vanuit een competente IDE, zoals Code::Blocks, zal de IDE beheer de console die het gebruikt om de code uit te voeren, en houd deze open wanneer de toepassing wordt gesloten. Je wilt geen speciale code toevoegen om de console open te houden, omdat dit zal voorkomen dat het correct functioneert wanneer je het echt gebruikt, buiten de IDE.
Antwoord 10, autoriteit 3%
Ik doe gewoon dit:
//clear buffer, wait for input to close program
std::cin.clear(); std::cin.ignore(INT_MAX, '\n');
std::cin.get();
return 0;
Opmerking: het wissen van de cin-buffer en dergelijke is alleen nodig als je cin eerder in je programma hebt gebruikt. Ook het gebruik van std::numeric_limits::max() is waarschijnlijk beter dan INT_MAX, maar het is een beetje omslachtig en meestal niet nodig.
Antwoord 11, autoriteit 2%
Ok, ik neem aan dat je Windows gebruikt en Visual Studio gebruikt… waarom? Nou, want als je een soort Linux-besturingssysteem gebruikt, zou je het waarschijnlijk vanaf de console uitvoeren.
Hoe dan ook, je kunt onzin aan het einde van je programma toevoegen zoals anderen suggereren, of je kunt gewoon op CTRL + F5drukken (start zonder debuggen) en Visual Studio zal de console verlaten zodra deze klaar is .
Een andere optie als u de Debug-versie wilt uitvoeren en geen onzin aan uw code wilt toevoegen, is door het consolevenster te openen (Start -> Run -> cmd) en naar uw Debug-uitvoermap te gaan. Voer vervolgens de naam van uw uitvoerbare bestand in en het zal uw foutopsporingsprogramma in de console uitvoeren. Je kunt dan de bijlage van Visual Studio gebruiken om te verwerken of zoiets als je dat echt wilt.
Antwoord 12, autoriteit 2%
Voeg gewoon het volgende toe aan het einde van je programma. Het zal proberen een of andere vorm van gebruikersinvoer vast te leggen, dus het voorkomt dat de console automatisch sluit.
cin.get();
Antwoord 13
Als u uw toepassing daadwerkelijk debugt in Visual C++, drukt u op F5 of de groene driehoek op de werkbalk. Als je het niet echt debugt (je hebt geen onderbrekingspunten ingesteld), druk je op Ctrl+F5 of kies je Start Without Debugging in de menu’s (het staat meestal in het Debug-menu, wat volgens mij verwarrend is.) Het zal een beetje sneller zijn, en wat nog belangrijker voor u is, zal aan het einde pauzeren zonder dat u uw code hoeft te wijzigen.
U kunt ook een opdrachtprompt openen, naar de map gaan waar uw exe zich bevindt en deze uitvoeren door de naam te typen. Op die manier wordt de opdrachtprompt niet gesloten wanneer het klaar is met uitvoeren en kunt u de uitvoer zien. Ik geef de voorkeur aan beide methoden boven het toevoegen van code die de app stopt zodra deze klaar is.
Antwoord 14
Voeg de volgende regels toe voor een exit()-functie of voor een returns in main():
std::cout << "Paused, press ENTER to continue." << std::endl;
cin.ignore(100000, "\n");
Antwoord 15
Voor Visual Studio (en alleen Visual Studio) geeft het volgende codefragment u een ‘wait for keypress to continue’-prompt die echt wacht tot de gebruiker expliciet op een nieuwe-toets drukt, door eerst te spoelen de invoerbuffer:
#include <cstdio>
#include <tchar.h>
#include <conio.h>
_tprintf(_T("Press a key to continue "));
while( _kbhit() /* defined in conio.h */ ) _gettch();
_gettch();
Merk op dat dit de tchar.hmacro’s gebruikt om compatibel te zijn met meerdere ‘tekensets’ (zoals VC++ ze noemt).
Antwoord 16
Gebruik #include "stdafx.h"& system("pause");net als de onderstaande code.
#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");
}
Antwoord 17
gewoon
#include <cstdio>
int main(){
// code...
std::getchar();
std::getchar();
return 0;
}
om de een of andere reden is er meestal 1 teken mogelijk om te lezen met getchar die al in stdin staat als je een programma uitvoert. dus de eerste getchar leest dit teken, en de tweede getchar wacht op gebruikersinvoer (uw) voordat het programma wordt afgesloten. En nadat een programma de meeste terminals verlaat, vooral op Windows, sluit u de terminal onmiddellijk.
dus waar we naar streven is een eenvoudige manier om te voorkomen dat een programma eindigt nadat het alles heeft uitgevoerd.
Natuurlijk zijn er complexere en schonere manieren om dit op te lossen, maar dit is de eenvoudigste.
Antwoord 18
Vergelijkbaar idee als jaantwoord, gewoon minimalistisch alternatief.
Maak een batchbestand met de volgende inhoud:
helloworld.exe
pause
Gebruik dan het batchbestand.
Antwoord 19
Kijk of uw IDE een selectievakje heeft in de projectinstellingen om het venster open te houden nadat het programma is beëindigd. Zo niet, gebruik dan std::cin.get();om een teken aan het einde van de hoofdfunctie te lezen. Zorg er echter voor dat u alleen op regel gebaseerde invoer (std::getline) gebruikt of anders omgaat met overgebleven ongelezen tekens (std::negeren tot nieuwe regel) omdat anders de .get() aan het einde alleen de rotzooi leest die u hebt achtergelaten eerder ongelezen.
Antwoord 20
Dit lijkt goed te werken:
cin.clear();
cin.ignore(2);
Als je eerst de buffer leegmaakt, is het geen probleem als je de volgende leest.
Om de een of andere reden werkt cin.ignore(1)niet, het moet 2 zijn.
Antwoord 21
Je kunt altijd gewoon een batchbestand maken. Als uw programma bijvoorbeeld helloworld.exe heet, is de code:
@echo off
:1
cls
call helloworld.exe
pause >nul
goto :1
Antwoord 22
Als u Windows gebruikt, kunt u system("pause >nul");of system("pause");gebruiken. Het voert een consoleopdracht uit om het programma te pauzeren totdat u op een toets drukt. >nulvoorkomt dat het zegt Press any key to continue....
Antwoord 23
Ik plaats een breekpunt bij de laatste return 0 van het programma. Het werkt prima.
Antwoord 24
Ik gebruikte cin.get()en dat werkte, maar op een dag moest ik daarvoor een andere cin.get([Array Variable])gebruiken om een leng-tekenreeks met een leeg teken in het midden van. dus de cin.get()verhinderde niet dat het opdrachtpromptvenster werd gesloten. Eindelijk vond ik een andere manier:
Druk op CTRL+F5om in een extern venster te openen en Visual Studio heeft er geen controle meer over. Zal je vragen over het sluiten nadat de laatste commando’s zijn uitgevoerd.
Antwoord 25
Ik heb geprobeerd een functie getchar()aan het einde toe te voegen. Maar het werkte niet. Dus wat ik deed was twee getchar()-functies achter elkaar toevoegen. Ik denk dat de eerste getchar()de Enter-toets absorbeert die je indrukt na de laatste gegevensinvoer. Dus probeer twee getchar()-functies toe te voegen in plaats van één
Antwoord 26
In plaats van op de startknop te drukken, drukt u tegelijkertijd op CTRL en F5. U kunt dan op een willekeurige toets drukken om door te gaan met het bericht. Of typ “(waarschuwing gebruik dit alleen voor het testen van niet-echte programma’s omdat antivirussen het niet leuk vinden!!!!)” aan het einde van uw hoofdfunctie, maar: (waarschuwing gebruik dit alleen voor het testen van niet-echte programma’s, want antivirusprogramma’s doneren vind het niet leuk!!!!)
Antwoord 27
gebruik gewoon cin.ignore() vlak voor return 0; twee keer
main()
{
//your codes
cin.ignore();
cin.ignore();
return 0;
}
dat is alles
Antwoord 28
je kunt dit ook proberen
sleep (50000);
cout << "any text" << endl;
Hiermee wordt je code 50000m vastgehouden, vervolgens wordt het bericht afgedrukt en wordt het afgesloten. Maar houd er rekening mee dat het niet voor altijd zal pauzeren.
Antwoord 29
Hier is een probleem, niet zo voor de hand liggend. Op de een of andere manier had ik een debug-onderbrekingspunt toegevoegd op de allerlaatste regel van mijn programma. }Ik weet niet zeker hoe ik dat deed, misschien met een verkeerde muisklik tijdens het springen tussen verschillende schermen. Ik werk in VS Code.
En als ik naar debug ga, springt het systeem onmiddellijk naar dat breekpunt. Geen foutmelding, geen tussentijdse output, niets. Ik heb zoiets van, hoe snelde het programma door al mijn ingestelde breekpunten? Dit duurde te lang om erachter te komen.
Blijkbaar ziet het systeem dat laatste regelonderbrekingspunt als een “eerste” stop. De simpele oplossing? Verwijder dat breekpunt, doh! (vul hier een voorhoofdsklap in.)
Antwoord 30
Het enige wat u hoeft te doen is een variabele voor x in te stellen en deze vervolgens in te typen voor de return 0;
cout<<"\nPress any key and hit enter to end...";
cin>>x;