¿Cómo puedo borrar la consola?


92

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


¿En qué sistema operativo? Es bastante diferente en Linux frente a Windows, solo por un ejemplo. Si lo desea para Windows, consulte: stackoverflow.com/questions/5866529/…
Jerry Coffin

¿Está intentando imprimir un montón de líneas y luego borrarlas, o borrarlas después de cada línea?
jpm

1
A veces quiero restablecer la vista de la consola. No quiero enviar spam a la consola con millones de líneas nuevas.
Thomas B

Pregunté cómo hacer esto en C, usando un identificador de ventana de consola. Esta es la respuesta que recibí. Con suerte, le ayudará con su caso.
Agi Hammerthief

Respuestas:


71

Para C ++ puro

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

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

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

Específico del sistema operativo

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

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

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

Bibliotecas (algo portátiles)

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


6
@Alf: Copié y pegué eso del artículo de MS, así que vote a ellos, no a mí;) Sin embargo, lo arreglaré.
Merlyn Morgan-Graham

11
el origen no importa: el código que ni siquiera se compila (con g ++) es incorrecto. Pero desde que lo arreglaste, eliminé el voto negativo. :-)
Saludos y hth. - Alf

1
@YoushaAleayoub editó la respuesta para eliminar el enlace de MS que sugiere su uso systemy agregó un enlace a su artículo que explica por qué.
Merlyn Morgan-Graham

53

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 errores posibles, pero bueno, está borrando la consola. No como system("cls")maneja mejor los errores.

Para * nixes, generalmente puede usar 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 systempara esto es simplemente feo.


6
"Usar el sistema para esto es feo". - ¿Por qué? Claro que me parece más limpio :)
Merlyn Morgan-Graham

17
@ MerlynMorgan-Graham: genera un proceso de shell para borrar una maldita consola. ¿De qué manera es esa una solución limpia? : P Es como usar echovia en system()lugar de escribir en stdout.
Cat Plus Plus

1
¡Un revestimiento FTW! ;) Sí, estoy bromeando. El hecho de que genere un proceso de shell es una buena información para su respuesta. +1 para la versión * nix.
Merlyn Morgan-Graham

8
Usar system()es un error común. También lo es su método sugerido para Unices. Esto es lo que se debe hacer en los sistemas POSIX. Obtuvo la parte de Win32 correcta, aunque no incorporó la convención de "desplazamiento hacia atrás".
JdeBP

1
Sin necesidad de archivos. jdebp.eu./FGA/clearing-the-tui-screen.html#CLS existe.
JdeBP

20

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

printf("\033c");

restablecerá el terminal.


14

La forma más fácil para mí sin tener que reinventar la rueda.

void Clear()
{
#if defined _WIN32
    system("cls");
#elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)
    system("clear");
#elif defined (__APPLE__)
    system("clear");
#endif
}

8

enviar varias líneas a la consola de la ventana es inútil ... solo agrega líneas vacías. Lamentablemente, la forma es específica de Windows e implica conio.h (y es posible que clrscr () no exista, tampoco es un encabezado estándar) o el método de API Win

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

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

3

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 limpiarí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 :)


3
system ("cls") no es una solución portátil para este problema, sin embargo, funciona en sistemas Windows.
CMS_95

4
Eso no es un "módulo". C ++ no tiene "módulos". Además, stdlib.hestá especificado por el estándar C, y no tiene nada que ver con "importar comandos de Windows" ni tampoco con Windows mismo. Aparte de eso, estás bien.
Lightness Races in Orbit

3

En Windows:

#include <cstdlib>

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

En Linux / Unix:

#include <cstdlib>

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

2

Úselo system("cls")para limpiar la pantalla:

#include <stdlib.h>

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

2
Ya mencionado en la respuesta aceptada. No hay nueva información aquí.
Dialecticus

Luego deshazte de cout / wcout y simplemente canaliza cosas al sistema ("echo" + tu salida);
Tanveer Badar

2

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

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

2

En Windows tenemos múltiples opciones:

  1. clrscr () (Archivo de encabezado: conio.h)

  2. system ("cls") (Archivo de encabezado: stdlib.h)

En Linux, use system ("borrar") (Archivo de encabezado: stdlib.h)


Tenga en cuenta que cualquier llamada a system () podría ser un problema de seguridad.
John Doe

0

Aquí tienes una forma sencilla de hacerlo:

#include <iostream>

using namespace std;

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

-1

Utilice System :: Console :: Clear ();

Esto borrará (vaciará) el búfer


3
[Error] 'Sistema' no ha sido declarado.
LoveToCode

6
Esto es para c ++ / CLI (también conocido como .NET c ++)
FryGuy

-1
#include <cstdlib>

void cls(){
#if defined(_WIN32) //if windows
    system("cls");

#else
    system("clear");    //if other
#endif  //finish

}

Simplemente llame a cls () en cualquier lugar


Esto no es lo que busca el OP. Lea el comentario agregado a la pregunta.
Agi Hammerthief

-2

Puede utilizar el método de consola clara del sistema operativo a través del sistema ("");
para Windows sería system ("cls"); por ejemplo
y en lugar de publicar tres códigos diferentes para diferentes sistemas operativos. solo crea un método para obtener el sistema operativo que se está ejecutando.
puede hacer esto detectando si existen variables de sistema únicas con #ifdef,
por ejemplo

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

}

-2

editar: pregunta completamente rehecha

Simplemente pruebe en qué sistema se encuentran y envíe un comando de 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!


3
Una muy, muy mala forma de hacerlo. Además, no borra la consola, solo agrega líneas en blanco. No te va a ayudar.
Vishnu Narang

Para colmo de males, coutpodría haber sido redirigido a un archivo. Entonces no existe el concepto de una consola en absoluto.
Tanveer Badar

-3

uso: clrscr ();

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

3
"Solía ​​ser una función en <conio.h>, en los antiguos compiladores de Borland C. No es una función estándar de C ++". stackoverflow.com/a/930141/1058115
cojack

-7

La forma más fácil sería descargar la transmisión 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, opuesto a la parte superior. Sin embargo, esto nunca debería provocar ningún problema, con suerte.


2
Esta respuesta es un error común .
JdeBP
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.