Como posso limpar o console?

Como no título. Como posso limpar o console em C ++?

Para puro C ++

Você não pode. C ++ nem sequer tem o conceito de console.

O programa pode estar imprimindo em uma impressora, saindo diretamente para um arquivo ou sendo redirecionado para a input de outro programa para tudo o que importa. Mesmo se você pudesse limpar o console em C ++, isso tornaria esses casos significativamente mais confusos.

Veja esta input na FAQ comp.lang.c ++:

Específico do sistema operacional

Se ainda faz sentido limpar o console em seu programa e você está interessado em soluções específicas do sistema operacional, elas existem.

Para o Windows (como na sua tag), confira este link:

  • Como podemos limpar o console na assembly?

Edit: Esta resposta mencionada anteriormente usando o system("cls"); porque a Microsoft disse para fazer isso. No entanto, tem sido apontado nos comentários que isso não é uma coisa segura a fazer . Eu removi o link para o artigo da Microsoft por causa desse problema.

Bibliotecas (um pouco portáteis)

ncurses é uma biblioteca que suporta manipulação de console:

Para o Windows, via API do 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); } 

Felizmente ignora todos os erros possíveis, mas, ei, é consolo. Não como o system("cls") lida com erros melhor.

Para * nixes, você geralmente pode usar códigos de escape ANSI, então seria:

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

Usando o system para isso é apenas feio.

Para Linux / Unix e talvez alguns outros, mas não para o Windows antes de 10 TH2:

 printf("\033c"); 

irá redefinir o 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; } 

saída de várias linhas para o console da janela é inútil .. apenas adiciona linhas vazias para ele. infelizmente, o caminho é específico do windows e envolve conio.h (e o clrscr () pode não existir, não é um header padrão) ou o 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 o sistema POSIX é muito mais simples, você pode usar ncurses ou funções de terminal

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

Use o system("cls") para limpar a canvas:

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

Para limpar a canvas, primeiro você precisa include um módulo:

 #include  

isso importará os comandos do windows. Então você pode usar a function ‘system’ para executar comandos Batch (que editam o console). No Windows em C ++, o comando para limpar a canvas seria:

 system("CLS"); 

E isso limparia o console. O código inteiro ficaria assim:

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

E isso é tudo que você precisa! Boa sorte 🙂

No Windows:

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

No Linux / Unix:

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

Isso é realmente agitado, mas tente:

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

Isso é difícil de fazer no MAC, já que ele não tem access às funções do Windows que podem ajudar a limpar a canvas. Minha melhor solução é fazer um loop e adicionar linhas até que o terminal esteja limpo e depois executar o programa. No entanto, isso não é tão eficiente ou amigável à memory se você usar isso principalmente e com frequência.

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

Aqui está uma maneira simples de fazer isso:

 #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 ();

Isso limpará (esvaziará) o buffer

Você pode usar o método de consola clara do sistema operacional via sistema (“”);
para windows seria sistema (“cls”); por exemplo
e em vez de liberar três códigos diferentes para sistemas operacionais diferentes. Basta fazer um método para obter o que está em execução.
você pode fazer isso detectando se existem variables ​​de sistema exclusivas com #ifdef
por exemplo

 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 

}

A apenas chamar cls () em qualquer lugar

use: clrscr ();

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

editar: pergunta completamente refeita

Basta testar em qual sistema eles estão e enviar um comando do sistema, dependendo do sistema. embora isso seja definido em tempo de compilation

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

Este é um método completamente novo!

A maneira mais fácil seria liberar o stream várias vezes (idealmente maior que qualquer console possível) 1024 * 1024 é provavelmente um tamanho que nenhuma janela de console poderia ter.

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

O único problema com isso é o cursor de software; essa coisa piscando (ou coisa não piscando) dependendo da plataforma / console será no final do console, em oposição ao topo da mesma. No entanto, isso nunca deve causar problemas.