c++ - parte - ¿Cómo puedo borrar la consola?

system cls c++ libreria

Question

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

Answer 1

Aquí hay una manera simple de hacerlo:

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

Answer 2

En Windows:

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

En Linux / Unix:

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

Answer 3

Esto es REALMENTE agitado pero intenta:

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

Answer 4

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

Answer 5

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.

Answer 6

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

printf("/033c");

reiniciará la terminal.

Answer 7

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.

Answer 8

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

#include <stdlib.h>

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 <iostream>
#include <stdlib.h>
using namespace std;
int main()
{
system("CLS");
}

¡Y eso es todo lo que necesitas! Buena suerte :)

Answer 9

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
}

Answer 10

Use System :: Console :: Clear ();

Esto borrará (vaciará) el buffer

Answer 11

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

#include <stdlib.h>
int main(void)
{
system("cls");
return 0;
}

Answer 12

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 <windows.h>
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 <unistd.h>
#include <term.h>
void ClearScreen()
{
if (!cur_term)
{
int result;
setupterm( NULL, STDOUT_FILENO, &result );
if (result <= 0) return;
}
putp( tigetstr( "clear" ) );
}

Answer 13

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 compilación

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

¡Este es un método completamente nuevo!

Answer 14

uso: clrscr ();

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

Answer 15

Para puro C ++

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

El programa podría estar imprimiendo en una impresora, saliendo directamente a un archivo, o siendo redirigido a la entrada de otro programa 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 ++:

• http://www.parashift.com/c++-faq-lite/input-output.html#faq-15.20

Específico del sistema operativo

Si todavía tiene sentido borrar la consola de su programa 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:

• http://www.gnu.org/software/ncurses/ (se ejecuta en sistemas Posix)
• http://gnuwin32.sourceforge.net/packages/ncurses.htm (un poco viejo puerto de Windows)

Answer 16

#include <cstdlib>
void cls(){
#if defined(_WIN32) //if windows
system("cls");
#else
system("clear"); //if other
#endif //finish

}

La llamada simplemente cls () en cualquier lugar

Answer 17

// #define _WIN32_WINNT 0x0500 // windows >= 2000
#include <windows.h>
#include <iostream>
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;
}