Como posso limpar o console


95

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


Em qual sistema operacional? É um pouco diferente no Linux vs. Windows, apenas para um exemplo. Se você quiser para Windows, consulte: stackoverflow.com/questions/5866529/…
Jerry Coffin

Você está tentando imprimir um monte de linhas e depois eliminá-las ou eliminá-las após cada linha?
jpm de

1
Eu quero redefinir a exibição do console às vezes. Eu não quero console de spam com milhões de novas linhas.
Thomas B

Eu perguntei como fazer isso em C, usando um identificador de janela de console. Esta é a resposta que recebi. Esperançosamente, isso ajuda no seu caso.
Agi Hammerthief

Respostas:


72

Para C ++ puro

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

O programa pode estar imprimindo em uma impressora, emitindo diretamente para um arquivo ou sendo redirecionado para a entrada de outro programa para todos os cuidados. Mesmo se você pudesse limpar o console em C ++, tornaria esses casos significativamente mais confusos.

Veja esta entrada no comp.lang.c ++ FAQ:

Específico do sistema operacional

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

Para Windows (como em sua tag), verifique este link:

Edit: Esta resposta mencionada anteriormente usando system("cls");, porque a Microsoft disse para fazer isso. No entanto, foi apontado nos comentários que isso não é uma coisa segura a se fazer . Removi o link para o artigo da Microsoft devido a esse problema.

Bibliotecas (um tanto portáteis)

ncurses é uma biblioteca que oferece suporte à manipulação de console:


6
@Alf: Eu copiei e colei isso do artigo da MS, então vote abaixo deles, não eu;) Vou corrigir isso.
Merlyn Morgan-Graham

11
a origem não importa - código que nem mesmo compila (com g ++) não é bom. Mas desde que você consertou, eu removi o downvote. :-)
Saúde e hth. - Alf

1
@YoushaAleayoub editou a resposta para remover o link MS que sugere o uso systeme adicionou um link ao seu artigo explicando o porquê.
Merlyn Morgan-Graham

53

Para Windows, por meio da 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, ele ignora todos os erros possíveis, mas hey, é a limpeza do console. Não como system("cls")lida melhor com erros.

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

Usar systempara isso é simplesmente feio.


6
"Usar o sistema para isso é simplesmente feio." - Por quê? Com certeza parece mais limpo para mim :)
Merlyn Morgan-Graham

17
@ MerlynMorgan-Graham: Ele gera um processo shell para limpar um console maldito. De que forma isso é uma solução limpa? : P É como usar echovia em system()vez de escrever para stdout.
Cat Plus Plus

1
One liner FTW! ;) Sim, estou sendo jocoso. O fato de que ele gera um processo shell é uma boa informação para sua resposta. +1 para a versão * nix.
Merlyn Morgan-Graham

8
Usar system()é um erro comum. Da mesma forma, é o seu método sugerido para Unices. Isso é o que se deve fazer em sistemas POSIX. Você acertou a parte do Win32, embora não tenha incorporado a convenção de "rolar para trás".
JdeBP de

1
Não há necessidade de arquivos. jdebp.eu./FGA/clearing-the-tui-screen.html#CLS existe.
JdeBP de

22

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

printf("\033c");

irá reiniciar o terminal.


16

A maneira mais fácil para mim sem ter que reinventar a roda.

void Clear()
{
#if defined _WIN32
    system("cls");
    //clrscr(); // including header file : conio.h
#elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)
    system("clear");
    //std::cout<< u8"\033[2J\033[1;1H"; //Using ANSI Escape Sequences 
#elif defined (__APPLE__)
    system("clear");
#endif
}
  • No Windows, você pode usar o cabeçalho "conio.h" e chamar a função clrscr para evitar o uso da função do sistema .
#include <conio.h>
clrscr();
  • No Linux, você pode usar sequências ANSI Escape para evitar o uso da função do sistema . Verifique esta referência Sequências de escape ANSI
    std::cout<< u8"\033[2J\033[1;1H"; 
  • No MacOS Investigando ...

Não funciona para mim: impressãoTERM environment variable not set.
secavfr

8

enviar várias linhas para o console da janela é inútil ... ele apenas adiciona linhas vazias a ele. infelizmente, o modo é específico do Windows e envolve conio.h (e clrscr () pode não existir, também não é um cabeçalho padrão) ou o 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 o sistema POSIX é muito mais simples, você pode usar ncurses ou funções 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;
}

4

Para limpar a tela, você primeiro precisa incluir um módulo:

#include <stdlib.h>

isso importará os comandos do Windows. Depois, você pode usar a função 'sistema' para executar comandos em lote (que editam o console). No Windows em C ++, o comando para limpar a tela seria:

system("CLS");

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

#include <iostream>
#include <stdlib.h>

using namespace std;

int main()
{
system("CLS");
}

E isso é tudo que você precisa! Boa sorte :)


3
system ("cls") não é uma solução portátil para esse problema, mas funciona em sistemas Windows.
CMS_95

4
Isso não é um "módulo". C ++ não possui "módulos". Além disso, stdlib.hé especificado pelo padrão C e não tem nada a ver com "importação de comandos do Windows" nem com o próprio Windows. Exceto por detalhes, você está bem.
Lightness Races in Orbit

3

No Windows:

#include <cstdlib>

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

Em Linux / Unix:

#include <cstdlib>

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

3

Isso é difícil de fazer no MAC visto que não tem acesso às funções do Windows que podem ajudar a limpar a tela. Minha melhor solução é fazer um loop e adicionar linhas até que o terminal esteja limpo e, em seguida, executar o programa. No entanto, isso não é tão eficiente ou de memória amigável se você usar principalmente e com freqüência.

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

2

Use system("cls")para limpar a tela:

#include <stdlib.h>

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

2
Já mencionado na resposta aceita. Nenhuma informação nova aqui.
Dialecticus

Em seguida, livre-se de cout / wcout e simplesmente canalize tudo para o sistema ("echo" + sua saída);
Tanveer Badar

2

No Windows, temos várias opções:

  1. clrscr () (arquivo de cabeçalho: conio.h)

  2. sistema ("cls") (arquivo de cabeçalho: stdlib.h)

No Linux, use system ("clear") (arquivo de cabeçalho: stdlib.h)


Observe que qualquer chamada para system () pode ser um problema de segurança.
John Doe

0

Esta é uma maneira simples de fazer isso:

#include <iostream>

using namespace std;

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

-1

Use System :: Console :: Clear ();

Isso irá limpar (esvaziar) o buffer


3
[Erro] 'Sistema' não foi declarado.
LoveToCode

6
Isso é para c ++ / CLI (também conhecido como .NET c ++)
FryGuy

-1
#include <cstdlib>

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

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

}

Basta chamar cls () em qualquer lugar


Não é isso que o OP está procurando. Leia o comentário adicionado à pergunta.
Agi Hammerthief

-2

Você pode usar o método de console claro do sistema operacional via sistema ("");
para windows seria system ("cls"); por exemplo, em
vez de liberar três códigos diferentes para sistemas operacionais diferentes. basta fazer um método para obter o que o sistema operacional está executando.
você pode fazer isso detectando se existem variáveis ​​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

}

-2

editar: pergunta completamente refeita

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

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

Este é um método completamente novo!


3
Uma maneira muito ruim de fazer isso. Além disso, ele não está limpando o console, está apenas adicionando linhas em branco. Não vai ajudar.
Vishnu Narang

Para piorar a situação, coutpode ter sido redirecionado para um arquivo. Então não há conceito de console.
Tanveer Badar

-3

use: clrscr ();

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

3
"Costumava ser uma função em <conio.h>, nos antigos compiladores Borland C. Não é uma função padrão C ++." stackoverflow.com/a/930141/1058115
cojack

-7

A maneira mais fácil seria liberar o fluxo várias vezes (de preferência maior do 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 do software; aquela coisa piscando (ou não piscando) dependendo da plataforma / console estará no final do console, oposto ao topo dele. No entanto, isso nunca deve induzir qualquer problema, espero.


2
Essa resposta é um erro comum .
JdeBP de
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.