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:
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.