Sistema ( “pausa”); – Perché è sbagliato?

Ecco una domanda che non capisco:

Il comando, system("pause"); viene insegnato ai nuovi programmatori come un modo per mettere in pausa un programma e attendere che l’input della tastiera continui. Tuttavia, sembra essere disapprovato da molti programmatori veterani come qualcosa che non dovrebbe essere fatto in vari gradi.

Alcune persone dicono che va bene da usare. Alcuni dicono che deve essere usato solo quando sei chiuso nella tua stanza e nessuno lo sta guardando. Alcuni dicono che verranno personalmente a casa tua e ti uccideranno se lo usi.

Io, io stesso sono un nuovo programmatore senza formazione formale di programmazione. Lo uso perché mi è stato insegnato a usarlo. Quello che non capisco è che se non è qualcosa da usare, allora perché è stato insegnato a usarlo? Oppure, il rovescio della medaglia, dopo tutto non è poi così male?

Quali sono i tuoi pensieri su questo argomento?

È disapprovato perché è un hack specifico della piattaforma che non ha nulla a che fare con l’apprendimento della programmazione, ma invece di aggirare una caratteristica dell’IDE / OS – la finestra della console lanciata da Visual Studio si chiude quando il programma ha terminato l’esecuzione, e così il nuovo utente non vede l’output del suo nuovo programma.

Bodging in System (“pause”) esegue il programma “pause” della riga di comando di Windows e attende che termini prima di continuare l’esecuzione del programma – la finestra della console rimane aperta in modo da poter leggere l’output.

Un’idea migliore sarebbe quella di mettere un breakpoint alla fine e debuggarlo, ma questo ha di nuovo dei problemi.

È lento. È dipendente dalla piattaforma. È insicuro.

Primo: cosa fa Chiamare “sistema” è letteralmente come digitare un comando nel prompt dei comandi di Windows. C’è una tonnellata di setup e teardown per la tua applicazione per fare una tale chiamata – e il sovraccarico è semplicemente ridicolo.

Cosa succede se un programma chiamato “pausa” è stato inserito nel PATH dell’utente? Il solo sistema di chiamata (“pausa”) garantisce solo che venga eseguito un programma chiamato “pausa” (sperare che tu non abbia il tuo eseguibile chiamato “pausa”!)

Basta scrivere la propria funzione “Pausa ()” che utilizza _getch. OK, certo, _getch è anch’esso dipendente dalla piattaforma (nota: è definito in “conio.h”) – ma è molto più bello di system() se stai sviluppando su Windows e ha lo stesso effetto (anche se è tua responsabilità fornire il testo con cout o così via).

Fondamentalmente: perché introdurre così tanti potenziali problemi quando puoi semplicemente aggiungere due linee di codice e una includere e ottenere un meccanismo molto più flessibile?

  • lento: deve passare attraverso un sacco di codice di Windows non necessario e un programma separato per una semplice operazione
  • non portatile: dipende dal programma di pausa
  • non di buon gusto: fare una chiamata di sistema dovrebbe essere fatta solo quando è veramente necessario
  • più digitando: System (“pause”) è più lungo di getchar ()

un semplice getchar () dovrebbe andare bene.

In sintesi, deve sospendere l’esecuzione dei programmi e fare una chiamata di sistema e allocare risorse non necessarie quando si potrebbe usare qualcosa di semplice come cin.get (). Le persone usano System (“PAUSE”) perché vogliono che il programma attenda fino a quando non premono invio per poter vedere il loro output. Se si desidera che un programma attenda l’input, ci sono funzioni integrate per ciò che sono anche multipiattaforma e meno impegnative.

Ulteriori spiegazioni in questo articolo.

Utilizzo del system("pause"); è Ungood Practice ™ perché

  • È completamente inutile .
    Per mantenere aperta la finestra della console del programma alla fine quando la si esegue da Visual Studio, utilizzare Ctrl + F5 per eseguirlo senza eseguire il debug, oppure posizionare un punto di interruzione nell’ultima parentesi destra } main . Quindi, nessun problema in Visual Studio. E naturalmente nessun problema quando lo si esegue dalla riga di comando.

  • È problematico e fastidioso
    quando esegui il programma dalla riga di comando. Per l’esecuzione intertriggers devi premere un tasto alla fine senza alcun fine. E per l’uso nell’automazione di alcune attività che la pause è molto indesiderata!

  • Non è portatile.
    Unix-land non ha comandi di pause standard.

Il comando pause è un comando interno cmd.exe e non può essere sovrascritto, come erroneamente è richiesto in almeno un’altra risposta. Cioè non è un rischio per la sicurezza, e l’affermazione che i programmi AV lo diagnostichino come tale è discutibile quanto l’affermazione di sovrascrivere il comando (dopotutto, un programma di richiamo del programma C ++ è in grado di fare tutto ciò che l’interprete di comandi può fare, e altro). Inoltre, mentre questo modo di mettere in pausa è estremamente inefficiente con gli usuali standard di programmazione C ++, ciò non ha importanza alla fine del programma di un novizio.

Quindi, le affermazioni nell’orda di risposte prima di questo non sono corrette, e il motivo principale per cui non dovresti usare il system("pause") o qualsiasi altro comando di attesa alla fine del tuo main , è il primo punto sopra: è completamente inutile, non ha assolutamente alcuno scopo, è solo molto sciocco.

Puoi usare std::cin.get() da iostream :

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

Inoltre, system('pause') è lento e include un file che probabilmente non è necessario: stdlib.h . È dipendente dalla piattaforma e in realtà richiama un sistema operativo "virtuale".

Perché non è portatile.

 pause 

è un programma windows / dos solo, quindi questo codice non verrà eseguito su linux. Inoltre, il system non è generalmente considerato come un ottimo modo per chiamare un altro programma: di solito è meglio usare CreateProcess o fork o qualcosa di simile.

Come elencato nelle altre risposte, ci sono molte ragioni che puoi trovare per evitarlo. Tutto si riduce ad una ragione che rende il resto discutibile. La funzione System() è intrinsecamente non sicura / non attendibile e non dovrebbe essere introdotta in un programma se non necessario.

Per un incarico di studente, questa condizione non è mai stata soddisfatta, e per questo motivo avrei fallito un incarico senza nemmeno eseguire il programma se fosse presente una chiamata a questo metodo. (Questo è stato chiarito sin dall’inizio.)

Per me non ha senso in generale aspettare prima di uscire senza motivo. Un programma che ha fatto il suo lavoro dovrebbe finire e restituire le sue risorse al suo creatore.

Uno non aspetta silenziosamente in un angolo buio dopo una giornata di lavoro, in attesa che qualcuno gli rovesci la spalla.

Ecco un motivo per cui non dovresti usarlo: faranno incazzare la maggior parte dei programmi antivirus che girano su Windows se passi il programma su un’altra macchina perché è una minaccia alla sicurezza. Anche se il tuo programma consiste solo in un semplice cout < < "hello world\n"; system("pause"); cout < < "hello world\n"; system("pause"); È pesante in termini di risorse e il programma accede al comando cmd, che gli antivirus considerano una minaccia.

il professionista usa il sistema (“PAUSE”); mentre si creano le piccole parti del programma è necessario eseguirne il debug. se lo usi per ottenere risultati di variabili prima durante e dopo ogni processo che stai usando per assicurarti che stiano funzionando correttamente.

Dopo aver provato e spostato a pieno ritmo con il resto della soluzione, rimuovere queste linee. è davvero buono quando si verifica un algoritmo definito dall’utente e si assicura che si stiano facendo le cose nell’ordine corretto per i risultati desiderati.

In nessun modo vuoi utilizzarlo in un’applicazione dopo averlo testato e assicurato che funzioni correttamente. Tuttavia ti permette di tenere traccia di tutto ciò che sta accadendo mentre accade. Non usarlo affatto per le app End-User.

È tutta una questione di stile. È utile per il debug ma non dovrebbe essere usato nella versione finale del programma. Non importa sul problema della memoria perché sono sicuro che quei ragazzi che hanno inventato il sistema (“pausa”) si aspettavano che sarebbe stato usato spesso. In un altro punto di vista, i computer vengono limitati nella loro memoria per tutto il resto che utilizziamo sul computer e non rappresenta una minaccia diretta come l’allocazione dynamic della memoria, quindi lo consiglierei per il debug del codice, ma nient’altro.