Ik begin in Visual C++ en ik zou graag willen weten hoe ik het console-venster moet bewaren.
Dit zou bijvoorbeeld een typische “Hello World” -toepassing zijn:
int _tmain(int argc, _TCHAR* argv[])
{
cout << "Hello World";
return 0;
}
Wat is de lijn die ik mis?
Antwoord 1, Autoriteit 100%
Start het project met CTRL + F5 in plaats van slechts F5 .
Het console-venster blijft nu open met de Press any key to continue . . .BERICHT NA HET PROGRAMMA UITSITEITEN.
Merk op dat dit de Console (/SUBSYSTEM:CONSOLE)Linker-optie vereist, die u als volgt kunt inschakelen:
- Open uw project en ga naar de Solution Explorer. Als u samen met mij volgt in K & AMP; R, zal uw "oplossing" 'hallo' zijn met 1 project eronder, ook 'hallo' in vetgedrukt.
- Klik met de rechtermuisknop op de 'Hallo' (of wat je projectnaam ook is.)
- Kies "Eigenschappen" in het contextmenu.
- Kies Configuration Eigenschappen & GT; LINKER & GT; SYSTEEM.
- Voor het eigenschap "Subsysteem" in het rechterdeelvenster, klikt u op de vervolgkeuzelijst in de rechterkolom.
- Kies "Console (/ Subsysteem: console)"
- Klik op Toepassen, wacht tot het klaar is met het doen wat het doet, klik vervolgens op OK. (Als "Toepassen" grijs is, kiest u een andere subsystemenoptie, klikt u op Toepassen en ga dan terug en breng de console optie aan. Mijn ervaring is dat OK alleen zal werken.)
CTRL-F5 en de subsysteemhips werken samen; Het zijn geen afzonderlijke opties.
(Met dank aan DJMorreTX van http://social.msdn.microsoft.com/Forums/en-US/vcprerelease/thread/21073093-516c-49d2-81c7-d960f6dc2ac6)
Antwoord 2, autoriteit 10%
De standaardmanier is cin.get()vóór uw retourverklaring.
int _tmain(int argc, _TCHAR* argv[])
{
cout << "Hello World";
cin.get();
return 0;
}
Antwoord 3, autoriteit 6%
Zet een onderbrekingspunt op de regel return.
Je draait het toch in de debugger?
Antwoord 4, autoriteit 5%
Een andere optie is om
#include <process.h>
system("pause");
Hoewel dit niet erg draagbaar is, omdat het alleen op Windows werkt, maar automatisch wordt afgedrukt
Druk op een willekeurige toets om door te gaan...
Antwoord 5, autoriteit 2%
Voor makefile-projecten mislukt de geaccepteerde oplossing vanwege een bug in Visual Studio (die in ieder geval aanwezig is tot versie 2012 - ik heb 2013 nog niet getest). Deze bug is gedetailleerd hier.
Als u de console wilt laten pauzeren na het beëindigen van het programma op een makefile-project, voert u deze stappen uit (dit kan verschillen voor andere versies dan 2010 - 2012):
1) Geef - EDIT: zie hieronder./SUBSYSTEM:CONSOLEdoor aan de linker.
2) Open uw projectbestand (.vcxproj) in een teksteditor.
3) Binnen de root <project>tag, voeg je het volgende in:
<ItemDefinitionGroup> <Link> <SubSystem>Console</SubSystem> </Link> </ItemDefinitionGroup>
4) Laad het project opnieuw in uw oplossing.
5) Start het programma zonder debuggen (CTRL + F5).
BEWERKEN:
Zoals in mijn opmerking hieronder, is het instellen van de linker-optie /SUBSYSTEM:CONSOLEeigenlijk niet relevant voor makefile-projecten (en niet noodzakelijkerwijs zelfs mogelijk, als je een andere compiler dan MSVC gebruikt). Het enige dat telt, is dat de instelling wordt toegevoegd aan het .vcxproj-bestand, zoals in stap 3 hierboven.
Antwoord 6
Je kunt cin.get();of cin.ignore();gebruiken net voor je return-statement om te voorkomen dat het consolevenster wordt gesloten.
Antwoord 7
zet gewoon een breekpunt op de laatste accolade van main.
int main () {
//...your code...
return 0;
} //<- breakpoint here
het werkt voor mij, het is niet nodig om het uit te voeren zonder debuggen. Het voert ook destructors uit voordat het het breekpunt bereikt, zodat je eventuele berichten op deze destructors kunt controleren als je die hebt.
Antwoord 8
Voeg eenvoudig een breekpunt toe aan het haakje sluiten van uw _tmain-methode. Dit is de gemakkelijkere manier en u hoeft geen code toe te voegen om fouten op te sporen.
Antwoord 9
Plaats een breekpunt op de eindaccolade van main(). Het wordt geactiveerd, zelfs met meerdere return-instructies. Het enige nadeel is dat een aanroep naar exit()niet wordt opgevangen.
Als je niet aan het debuggen bent, volg dan het advies in het antwoord van Zoidberg en start je programma met Ctrl+F5in plaats van alleen F5.
Antwoord 10
Mijn 2 cent:
Keuze 1: voeg een onderbrekingspunt toe aan het einde van main()
Keuze 2: voeg deze code toe, vlak voor de 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');
U moet <iomanip>opnemen voor std::numeric_limits
Antwoord 11
voeg gewoon system("pause") toe aan het einde van de code voordat je 0 teruggeeft op deze manier
#include <stdlib.h>
int main()
{
//some code goes here
system("pause")
return 0;
}
Antwoord 12
int main()
{
//...
getchar();
return 0;
}
Antwoord 13
cin.get(), of system("PAUSE").
Ik heb niet gehoord dat je return(0);
. kunt gebruiken
Antwoord 14
Zoals sommigen al hebben opgemerkt, voegt de oplossing van Zoidberg de debugger niet toe, wat je normaal gesproken niet wilt.
De beste optie imo is om je VS dienovereenkomstig te configureren (vanaf VS 2017), door naar Tools > Opties > Foutopsporing > Algemeen. Daar haal je het vinkje weg bij "De console automatisch sluiten wanneer debuggen stopt" (helemaal onderaan), wat in jouw geval waarschijnlijk is aangevinkt.
Antwoord 15
Ik voeg #include <conio.h>toe en voeg vervolgens getch();toe net voor de regel return 0;. Dat heb ik in ieder geval op school geleerd. De hierboven genoemde methoden zijn heel anders zie ik.
Antwoord 16
Heb hetzelfde probleem gehad. Ik gebruik _getch()net voor de return-instructie. Het werkt.
Antwoord 17
(Sommige opties kunnen met verschillende namen worden aangeroepen. Ik gebruik de Engelse versie niet)
Ik had hetzelfde probleem toen ik projecten aanmaakte met de optie "leeg project", Maak een project als "Win32-console-toepassing" in plaats van "leeg project" . In het dialoogvenster dat nu verschijnt, drukt u op "Doorgaan" en daarna kunt u de optie "Leeg project" aanvinken en op bevestigen drukken. Daarna zal CTRL + F5 een console openen die niet automatisch sluit.
Antwoord 18
Ik had hetzelfde probleem; In mijn applicatie zijn er meerdere exit()-punten en er was geen manier om te weten waar het precies uitkomt, toen ontdekte ik dit:
atexit(system("pause"));
of
atexit(cin.get());
Op deze manier stopt het, ongeacht waar we het programma verlaten.
Antwoord 19
Een andere optie:
#ifdef _WIN32
#define MAINRET system("pause");return 0
#else
#define MAINRET return 0
#endif
Algemeen:
int main(int argc, char* argv[]) {
MAINRET;
}
Antwoord 20
Eigenlijk is de echte oplossing de selectie van de projectsjabloon zelf.
U MOET Win32 Console-toepassing selecteren in oudere VS, of vul eerst de projectnaam in en dubbelklik vervolgens op de Windows Desktop-wizard en selecteer vervolgens Win32-consoletoepassing. Selecteer vervolgens leeg project op dit punt. Dit maakt dan mogelijk wat de oorspronkelijke vraagsteller echt wilde zonder extra stop- en wachtcode toe te voegen.
Ik ben ook door dit probleem gegaan. Het antwoord staat ook op de MSDN-site.
Antwoord 21
Hier is een manier om het opdrachtvenster open te houden, ongeacht hoe de uitvoering stopt, zonder enige code te wijzigen:
Open in Visual Studio Projecteigenschappenpagina's-> Foutopsporing.
Voer voor Opdracht$(ComSpec)
in
Voor Opdrachtargumentenvoert u /k $(TargetPath)in. Voeg eventuele argumenten toe aan uw eigen toepassing.
Nu F5of Ctrl-F5voert Windows/System32/cmd.exeuit in een nieuw venster, en /kzorgt ervoor dat de opdrachtprompt open blijft nadat de uitvoering is voltooid.
Het nadeel is dat de uitvoering niet stopt bij breekpunten.
Antwoord 22
je kunt gewoon zetten
keep_window_open ();
voor de terugkeer is hier een voorbeeld
int main()
{
cout<<"hello world!\n";
keep_window_open ();
return 0;
}