¿Cómo puedo borrar la consola?

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

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

• 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 en su programa y está interesado en soluciones específicas del sistema operativo, existen.

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

• ¿Cómo limpiamos la consola en ensamblaje?

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:

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

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.

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

printf("\033c");

restablecerá el terminal.

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
}

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

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

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

En Windows:

#include <cstdlib>

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

En Linux / Unix:

#include <cstdlib>

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

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

#include <stdlib.h>

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

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

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)

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
}

Utilice System :: Console :: Clear ();

Esto borrará (vaciará) el búfer

#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

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

}

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!

uso: clrscr ();

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

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.