systeem(“pauze”); – Waarom is het fout?

Hier is een vraag die ik niet helemaal begrijp:

Het commando, system("pause");wordt aan nieuwe programmeurs geleerd als een manier om een programma te pauzeren en te wachten tot een toetsenbordinvoer doorgaat. Het lijkt echter door veel ervaren programmeurs te worden afgekeurd als iets dat niet in verschillende mate zou moeten worden gedaan.

Sommige mensen zeggen dat het prima te gebruiken is. Sommigen zeggen dat het alleen mag worden gebruikt als je opgesloten zit in je kamer en niemand kijkt. Sommigen zeggen dat ze persoonlijk naar je huis zullen komen en je zullen vermoorden als je het gebruikt.

Ik ben zelf een nieuwe programmeur zonder formele programmeeropleiding. Ik gebruik het omdat ik geleerd heb om het te gebruiken. Wat ik niet begrijp is dat als het niet iets is om te gebruiken, waarom heb ik dan geleerd het te gebruiken? Of, aan de andere kant, is het toch zo erg niet?

Wat vindt u van dit onderwerp?

Antwoord 1, autoriteit 100%

Het wordt afgekeurd omdat het een platformspecifieke hack is die niets te maken heeft met het leren programmeren, maar in plaats daarvan om een functie van de IDE/OS te omzeilen – het consolevenster dat vanuit Visual Studio wordt gestart, sluit wanneer het programma klaar is met uitvoeren , en dus krijgt de nieuwe gebruiker de uitvoer van zijn nieuwe programma niet te zien.

Bodging in System(“pause”) voert het Windows-opdrachtregelprogramma “pauze” uit en wacht tot dat is beëindigd voordat het programma verder wordt uitgevoerd – het consolevenster blijft open zodat u de uitvoer kunt lezen.

>

Een beter idee zou zijn om aan het einde een onderbrekingspunt te plaatsen en dit te debuggen, maar dat levert opnieuw problemen op.

Antwoord 2, autoriteit 48%

Het is traag. Het is platformafhankelijk. Het is onzeker.

Ten eerste: wat het doet. Het aanroepen van “systeem” is letterlijk hetzelfde als het typen van een opdracht in de Windows-opdrachtprompt. Er is een heleboel setup en demontage voor uw applicatie om zo’n oproep te doen – en de overhead is gewoon belachelijk.

Wat als een programma met de naam “pauze” in het PATH van de gebruiker is geplaatst? Door system(“pause”) aan te roepen, wordt alleen gegarandeerd dat een programma met de naam “pause” wordt uitgevoerd (hoop dat je het uitvoerbare bestand “pause” niet hebt!)

Schrijf gewoon je eigen “Pause()”-functie die _gech gebruikt. OK, natuurlijk, _gech is ook platformafhankelijk (let op: het is gedefinieerd in “conio.h”) – maar het is veel leuker dan System()als je op Windows ontwikkelt en het hetzelfde effect heeft (hoewel het uw verantwoordelijkheid is om de tekst te voorzien van cout of zo).

Kortom: waarom zou u zoveel potentiële problemen introduceren als u eenvoudig twee regels code en één code kunt toevoegen en een veel flexibeler mechanisme krijgt?

Antwoord 3, autoriteit 34%

• langzaam: het moet door veel heen springen
  onnodige Windows-code en a
  apart programma voor een simpele
  operatie
• niet draagbaar: afhankelijk van
  het pauzeprogramma
• geen goede stijl:
  het maken van een systeemoproep zou alleen moeten zijn:
  gedaan wanneer echtnodig
• meer
  typen: Systeem (“pauze”) is langer
  dan getchar()

een simpele getchar() zou prima moeten werken.

Antwoord 4, autoriteit 28%

Het gebruik van system("pause");is Ungood Practice™ omdat

• Het is volkomen onnodig.
  Om het consolevenster van het programma aan het einde open te houden wanneer u het vanuit Visual Studio uitvoert, gebruikt u Ctrl+F5om het uit te voeren zonder fouten te debuggen, of plaats anders een breekpunt op het laatste rechter accolade }van main. Dus geen probleem in Visual Studio. En natuurlijk helemaal geen probleem als je het vanaf de opdrachtregel uitvoert.

• Het is problematisch & vervelend
  wanneer u het programma vanaf de opdrachtregel uitvoert. Voor interactieve uitvoering moet je aan het einde zonder enig doel op een toets drukken. En voor gebruik bij het automatiseren van een taak die pausezeer ongewenst is!

• Het is niet draagbaar.
  Unix-land heeft geen standaard pausecommando.

De opdracht pauseis een interne opdracht cmd.exeen kan niet worden overschreven, zoals ten onrechte wordt beweerd in ten minste één ander antwoord. D.w.z. het is geen veiligheidsrisico, en de bewering dat AV-programma’s het als zodanig diagnosticeren, is net zo dubieus als de bewering dat het commando wordt genegeerd (een C++-programma dat systemaanroept, is immers in staat om dat allemaal zelf te doen de opdrachtinterpreter kan doen, en meer). En hoewel deze manier van pauzeren volgens de gebruikelijke normen van C++-programmering buitengewoon inefficiënt is, maakt dat helemaal niet uit aan het einde van het programma van een beginner.

Dus de beweringen in de horde antwoorden hiervoor zijn niet correct, en de belangrijkste reden waarom u system("pause")of een ander wachtcommandoaan het einde van je main, is het eerste punt hierboven: het is volledig onnodig, het dient absoluut geen doel, het is gewoon erg dom.

Antwoord 5, autoriteit 25%

Kortom, het moet de uitvoering van het programma pauzeren en een systeemaanroep doen en onnodige bronnen toewijzen als je zoiets eenvoudigs als cin.get() zou kunnen gebruiken. Mensen gebruiken Systeem (“PAUSE”) omdat ze willen dat het programma wacht tot ze op enter drukken om hun uitvoer te zien. Als je wilt dat een programma wacht op invoer, zijn er ingebouwde functies voor die ook platformoverschrijdend en minder veeleisend zijn.

Verdere uitleg in ditartikel.

Antwoord 6, autoriteit 18%

Je kunt std::cin.get()gebruiken van iostream:

#include <iostream> // std::cout, std::cin
using namespace std;
int main() {
   do {
     cout << '\n' << "Press the Enter key to continue.";
   } while (cin.get() != '\n');
   return 0;
}

Bovendien is system('pause')traag en bevat het een bestand dat je waarschijnlijk niet nodig hebt: stdlib.h. Het is platformafhankelijk en roept in feite een ‘virtueel’ besturingssysteem op.

Antwoord 7, autoriteit 11%

Omdat het niet draagbaar is.

pause

is alleen een Windows / Dos-programma, dus uw code zal niet op linux draaien. Bovendien wordt systemover het algemeen niet beschouwd als een erg goede manier om een ander programma aan te roepen – het is meestal beter om CreateProcessof forkof iets dergelijks te gebruiken .

Antwoord 8, autoriteit 4%

Zoals vermeld bij de andere antwoorden, zijn er veel redenen die u kunt vinden om dit te vermijden. Het komt allemaal neer op één reden die de rest betwistbaar maakt. De functie System()is inherent onveilig/niet-vertrouwd en mag niet in een programma worden geïntroduceerd tenzij dat nodig is.

Voor een opdracht van een student werd nooit aan deze voorwaarde voldaan, en om deze reden zou ik een opdracht mislukken zonder het programma zelfs maar uit te voeren als er een aanroep van deze methode aanwezig was. (Dit werd vanaf het begin duidelijk gemaakt.)

Antwoord 9, autoriteit 4%

Voor mij heeft het in het algemeen geen zin om te wachten voordat ik zonder reden afsluit. Een programma dat zijn werk heeft gedaan, moet gewoon stoppen en zijn bronnen teruggeven aan de maker.

Je wacht ook niet stil in een donkere hoek na een werkdag, wachtend op iemand die zijn schouder schudt.

Antwoord 10, autoriteit 4%

system("pause");  

is verkeerd omdat het deel uitmaakt van de Windows API en dus niet werkt in andere besturingssystemen.

Probeer alleen objecten uit de C++-standaardbibliotheek te gebruiken. Een betere oplossing is om te schrijven:

cin.get();
return 0;

Maar het zal ook problemen veroorzaken als je andere cin‘s in je code hebt. Omdat je na elke cinop Enterof \ntikt, wat een witruimteteken is. cinnegeert dit karakter en laat het in de bufferzone, maar cin.get(), krijgt dit overgebleven karakter. Dus de besturing van het programma bereikt de regel return 0en de console wordt gesloten voordat je de resultaten kunt zien.
Om dit op te lossen, schrijven we de code als volgt:

cin.ignore();  
cin.get();  
return 0;

Antwoord 11

Hier is één reden waarom u het niet zou moeten gebruiken: het zal de meeste antivirusprogramma’s die op Windows draaien, irriteren als u het programma doorgeeft aan een andere machine, omdat het een veiligheidsrisico is. Zelfs als je programma alleen uit een simpele cout << "hello world\n"; system("pause");
Het kost veel resources en het programma krijgt toegang tot het cmd-commando, dat antivirussen als een bedreiging zien.

Antwoord 12

de pro’s van het gebruik van system(“PAUSE”); terwijl het maken van de kleine delen van je programma bedoeld is om het zelf te debuggen. als je het gebruikt om resultaten van variabelen te krijgen voor tijdens en na elk proces dat je gebruikt om er zeker van te zijn dat ze goed werken.

Na het testen en het in volle gang brengen met de rest van de oplossing, moet u deze lijnen verwijderen. het is echt goed wanneer u een door de gebruiker gedefinieerd algoritme test en ervoor zorgt dat u de dingen in de juiste volgorde doet voor de gewenste resultaten.

Je wilt dit in geen geval in een applicatie gebruiken nadat je het hebt getest en er zeker van bent dat het goed werkt. Het stelt u echter wel in staat om alles bij te houden wat er gebeurt terwijl het gebeurt. Gebruik het helemaal niet voor apps van eindgebruikers.

Antwoord 13

Het is allemaal een kwestie van stijl. Het is handig voor het opsporen van fouten, maar verder zou het niet moeten worden gebruikt in de definitieve versie van het programma. Het maakt echt niet uit wat betreft het geheugenprobleem, want ik weet zeker dat de jongens die het systeem hebben uitgevonden (“pauze”) verwachtten dat het vaak zou worden gebruikt. In een ander perspectief worden computers beperkt in hun geheugen voor al het andere dat we sowieso op de computer gebruiken en het vormt geen directe bedreiging zoals dynamische geheugentoewijzing, dus ik zou het aanraden voor het debuggen van code, maar niets anders.