Come posso cancellare la console

Come nel titolo. Come posso cancellare la console in C ++?

Per puro C ++

Non puoi Il C ++ non ha nemmeno il concetto di console.

Il programma potrebbe stampare su una stampante, emettere direttamente su un file o essere reindirizzato all’input di un altro programma per tutte le sue preoccupazioni. Anche se fosse ansible svuotare la console in C ++, renderebbe questi casi significativamente più disordinati.

Vedi questa voce nelle domande frequenti su comp.lang.c ++:

OS-Specific

Se ha ancora senso cancellare la console nel programma e sei interessato a utilizzare soluzioni specifiche del sistema, quelle esistenti esistono.

Per Windows (come nel tuo tag), controlla questo link:

  • Come si cancella la console in assembly?

Modifica: questa risposta precedentemente menzionata usando il system("cls"); , perché Microsoft ha detto di farlo. Tuttavia è stato sottolineato nei commenti che questa non è una cosa sicura da fare . Ho rimosso il collegamento all’articolo di Microsoft a causa di questo problema.

Librerie (un po ‘portatili)

ncurses è una libreria che supporta la manipolazione della console:

Per Windows, tramite l’API della console:

 void clear() { COORD topLeft = { 0, 0 }; HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO screen; DWORD written; GetConsoleScreenBufferInfo(console, &screen); FillConsoleOutputCharacterA( console, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written ); FillConsoleOutputAttribute( console, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE, screen.dwSize.X * screen.dwSize.Y, topLeft, &written ); SetConsoleCursorPosition(console, topLeft); } 

Ignora felicemente tutti i possibili errori, ma hey, è la compensazione della console. Non come il system("cls") gestisce meglio gli errori.

Per * nix, di solito si può andare con i codici di escape ANSI, quindi sarebbe:

 void clear() { // CSI[2J clears screen, CSI[H moves the cursor to top-left corner std::cout << "\x1B[2J\x1B[H"; } 

Usare il system per questo è solo brutto.

Per Linux / Unix e forse alcuni altri, ma non per Windows prima di 10 TH2:

 printf("\033c"); 

ripristinerà il terminale.

 // #define _WIN32_WINNT 0x0500 // windows >= 2000 #include  #include  using namespace std; void pos(short C, short R) { COORD xy ; xy.X = C ; xy.Y = R ; SetConsoleCursorPosition( GetStdHandle(STD_OUTPUT_HANDLE), xy); } void cls( ) { pos(0,0); for(int j=0;j<100;j++) cout << string(100, ' '); pos(0,0); } int main( void ) { // write somthing and wait for(int j=0;j<100;j++) cout << string(10, 'a'); cout << "\n\npress any key to cls... "; cin.get(); // clean the screen cls(); return 0; } 

l’output di più righe sulla console di una finestra è inutile. solo aggiunge righe vuote ad essa. purtroppo, il modo è specifico di Windows e implica o conio.h (e clrscr () potrebbe non esistere, che non è un’intestazione standard) o metodo Win API

 #include  void ClearScreen() { HANDLE hStdOut; CONSOLE_SCREEN_BUFFER_INFO csbi; DWORD count; DWORD cellCount; COORD homeCoords = { 0, 0 }; hStdOut = GetStdHandle( STD_OUTPUT_HANDLE ); if (hStdOut == INVALID_HANDLE_VALUE) return; /* Get the number of cells in the current buffer */ if (!GetConsoleScreenBufferInfo( hStdOut, &csbi )) return; cellCount = csbi.dwSize.X *csbi.dwSize.Y; /* Fill the entire buffer with spaces */ if (!FillConsoleOutputCharacter( hStdOut, (TCHAR) ' ', cellCount, homeCoords, &count )) return; /* Fill the entire buffer with the current colors and attributes */ if (!FillConsoleOutputAttribute( hStdOut, csbi.wAttributes, cellCount, homeCoords, &count )) return; /* Move the cursor home */ SetConsoleCursorPosition( hStdOut, homeCoords ); } 

Per il sistema POSIX è molto più semplice, è ansible utilizzare ncurses o funzioni terminali

 #include  #include  void ClearScreen() { if (!cur_term) { int result; setupterm( NULL, STDOUT_FILENO, &result ); if (result <= 0) return; } putp( tigetstr( "clear" ) ); } 

Usa il system("cls") per cancellare lo schermo:

 #include  int main(void) { system("cls"); return 0; } 

Per cancellare lo schermo devi prima includere un modulo:

 #include  

questo importerà i comandi di Windows. Quindi è ansible utilizzare la funzione ‘system’ per eseguire i comandi Batch (che modificano la console). Su Windows in C ++, il comando per cancellare lo schermo sarebbe:

 system("CLS"); 

E ciò cancellerebbe la console. L’intero codice sarebbe simile a questo:

 #include  #include  using namespace std; int main() { system("CLS"); } 

E questo è tutto ciò che serve! In bocca al lupo 🙂

In Windows:

 #include  int main() { std::system("cls"); return 0; } 

In Linux / Unix:

 #include  int main() { std::system("clear"); return 0; } 

Questo è DAVVERO instabile ma prova:

 void cls() { for (int i = 0; i < 250; ++i) { std::cout << endl; } } 

Questo è difficile da fare su MAC visto che non ha accesso alle funzioni di Windows che possono aiutare a cancellare lo schermo. La mia soluzione migliore è quella di eseguire il ciclo e aggiungere linee fino a quando il terminale non è chiaro e quindi eseguire il programma. Tuttavia, questo non è efficiente o adatto alla memoria se lo si utilizza principalmente e spesso.

 void clearScreen(){ int clear = 5; do { cout << endl; clear -= 1; } while (clear !=0); } 

Ecco un modo semplice per farlo:

 #include  using namespace std; int main() { cout.flush(); // Flush the output stream system("clear"); // Clear the console with the "system" function } 

Usa System :: Console :: Clear ();

Questo cancellerà (vuoto) il buffer

È ansible utilizzare il metodo della console di cancellazione del sistema operativo tramite il sistema (“”);
per Windows sarebbe un sistema (“cls”); per esempio
e invece di rilasciare tre codici diversi per diversi sistemi operativi. basta fare un metodo per ottenere ciò che OS è in esecuzione.
puoi farlo rilevando se esistono variabili di sistema univoche con #ifdef
per esempio

 enum OPERATINGSYSTEM = {windows = 0, mac = 1, linux = 2 /*etc you get the point*/}; void getOs(){ #ifdef _WIN32 return OPERATINGSYSTEM.windows #elif __APPLE__ //etc you get the point #endif } int main(){ int id = getOs(); if(id == OPERATINGSYSTEM.windows){ system("CLS"); }else if (id == OPERATINGSYSTEM.mac){ system("CLEAR"); } //etc you get the point } 
 #include  void cls(){ #if defined(_WIN32) //if windows system("cls"); #else system("clear"); //if other #endif //finish 

}

Basta chiamare cls () ovunque

utilizzare: clrscr ();

 #include  using namespace std; int main() { clrscr(); cout << "Hello World!" << endl; return 0; } 

modifica: completamente rifatta la domanda

Basta testare il sistema su cui si trovano e inviare un comando di sistema a seconda del sistema. anche se questo sarà impostato in fase di compilazione

 #ifdef __WIN32 system("cls"); #else system("clear"); // most other systems use this #endif 

Questo è un metodo completamente nuovo!

Il modo più semplice sarebbe quello di svuotare lo stream più volte (idealmente più grande di qualsiasi console ansible) 1024 * 1024 è probabilmente una dimensione che nessuna finestra della console potrebbe mai essere.

 int main(int argc, char *argv) { for(int i = 0; i <1024*1024; i++) std::cout << ' ' << std::endl; return 0; } 

L'unico problema con questo è il cursore del software; quella cosa lampeggiante (o cosa non lampeggiante) a seconda della piattaforma / console sarà alla fine della console, opposta alla parte superiore di essa. Tuttavia questo non dovrebbe mai causare problemi, si spera.