¿Cómo puedo borrar la consola?

Como en el título. ¿Cómo puedo borrar la consola en C ++?

Para puro C ++

No puedes. C ++ ni siquiera tiene el concepto de una consola.

El progtwig podría estar imprimiendo en una impresora, saliendo directamente a un archivo, o siendo redirigido a la entrada de otro progtwig para todo lo que le importa. Incluso si pudieras borrar la consola en C ++, los casos serían mucho más complicados.

Consulte esta entrada en las preguntas frecuentes comp.lang.c ++:

Específico del sistema operativo

Si todavía tiene sentido borrar la consola de su progtwig y está interesado en las soluciones específicas del sistema operativo, existen.

Para Windows (como en su etiqueta), revise este enlace:

  • ¿Cómo borramos la consola en el ensamblaje?

Editar: Esta respuesta se mencionó anteriormente usando el system("cls"); , porque Microsoft dijo que hiciera eso. Sin embargo, se ha señalado en los comentarios que esto no es algo seguro de hacer . He eliminado el enlace al artículo de Microsoft debido a este problema.

Bibliotecas (algo portátil)

ncurses es una biblioteca que admite la manipulación de la consola:

Para Windows, a través de la API de consola:

 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); } 

Felizmente ignora todos los posibles errores, pero bueno, es la limpieza de la consola. No como el system("cls") maneja los errores mejor.

Para * nixes, generalmente puede ir con códigos de escape ANSI, por lo que sería:

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

Usar el system para esto es feo.

Para Linux / Unix y tal vez algunos otros, pero no para Windows antes de 10 TH2:

 printf("\033c"); 

reiniciará la terminal.

 // #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; } 

dar salida a múltiples líneas a la consola de la ventana es inútil … simplemente agrega líneas vacías. lamentablemente, el modo es específico de Windows e implica conio.h (y clrscr () puede no existir, eso tampoco es un encabezado estándar) o el método 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 ); } 

Para el sistema POSIX es mucho más simple, puede usar ncurses o funciones de terminal

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

Use el system("cls") para borrar la pantalla:

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

Para borrar la pantalla, primero deberá incluir un módulo:

 #include  

esto importará los comandos de Windows. Luego puede usar la función ‘sistema’ para ejecutar comandos por lotes (que editan la consola). En Windows en C ++, el comando para borrar la pantalla sería:

 system("CLS"); 

Y eso borraría la consola. El código completo se vería así:

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

¡Y eso es todo lo que necesitas! Buena suerte 🙂

En Windows:

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

En Linux / Unix:

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

Esto es REALMENTE agitado pero intenta:

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

Esto es difícil de hacer en MAC ya que no tiene acceso a las funciones de Windows que pueden ayudar a borrar la pantalla. Mi mejor solución es hacer bucles y agregar líneas hasta que el terminal esté despejado y luego ejecutar el progtwig. Sin embargo, esto no es tan eficiente ni amigable con la memoria si usa esto principalmente y con frecuencia.

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

Aquí hay una manera simple de hacerlo:

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

Use System :: Console :: Clear ();

Esto borrará (vaciará) el buffer

Puede usar el método de consola claro del sistema operativo a través del sistema (“”);
para Windows sería un sistema (“cls”); por ejemplo
y en lugar de lanzar tres códigos diferentes para diferentes sistemas operativos. solo crea un método para obtener lo que está ejecutando el sistema operativo.
puede hacerlo detectando si existen variables únicas del sistema con #ifdef
p.ej

 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 

}

La llamada simplemente cls () en cualquier lugar

uso: clrscr ();

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

editar: pregunta completamente rehecha

Simplemente prueba en qué sistema están y envía un comando del sistema según el sistema. aunque esto se establecerá en tiempo de comstackción

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

¡Este es un método completamente nuevo!

La manera más fácil sería enjuagar la secuencia varias veces (idealmente más grande que cualquier consola posible) 1024 * 1024 es probablemente un tamaño que ninguna ventana de consola podría tener.

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

El único problema con esto es el cursor del software; esa cosa parpadeante (o cosa que no parpadea) dependiendo de la plataforma / consola estará al final de la consola, opuesta a la parte superior. Sin embargo, esto nunca debería inducir ningún problema con suerte.