Comment puis-je effacer la console ?

Question

Comme dans le titre. Comment effacer la console en C++ ?

Answer 1

Pour le C++ pur

Vous ne pouvez pas. Le C++ n'a même pas le concept de console.

Le programme pourrait imprimer sur une imprimante, sortir directement dans un fichier ou être redirigé vers l'entrée d'un autre programme. Même si vous pouviez effacer la console en C++, cela rendrait ces cas beaucoup plus compliqués.

Voir cette entrée dans la FAQ de comp.lang.c++ :

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

Spécifique au système d'exploitation

S'il est toujours utile d'effacer la console dans votre programme et que vous êtes intéressé par des solutions spécifiques au système d'exploitation, il en existe.

Pour Windows (comme dans votre étiquette), consultez ce lien :

• Comment effacer la console dans l'assemblage ?

Edit : Cette réponse mentionnait précédemment l'utilisation de system("cls"); parce que Microsoft a dit de le faire. Cependant, il a été souligné dans les commentaires que ce n'est pas une chose sûre à faire . J'ai supprimé le lien vers l'article de Microsoft en raison de ce problème.

Bibliothèques (quelque peu portables)

ncurses est une bibliothèque qui permet de manipuler la console :

• http://www.gnu.org/software/ncurses/ (fonctionne sur les systèmes Posix)
• http://gnuwin32.sourceforge.net/packages/ncurses.htm (ancien portage Windows)

Answer 2

Pour Windows, via l'API 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);
}

Il ignore joyeusement toutes les erreurs possibles, mais il s'agit d'un nettoyage de la console. Ce n'est pas comme system("cls") ne gère pas mieux les erreurs.

Pour les *nixes, vous pouvez généralement utiliser les codes d'échappement ANSI, donc ce serait :

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

Utilisation system car c'est tout simplement laid.

Answer 3

C'est le moyen le plus simple pour moi, sans avoir à réinventer la roue.

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
}

• Sur Fenêtres vous pouvez utiliser "conio.h" et appeler clrscr afin d'éviter l'utilisation de la fonction système fonction.

  include <conio.h>

  clrscr();

• Sur Linux vous pouvez utiliser des séquences d'échappement ANSI pour éviter l'utilisation de système fonction. Vérifier cette référence Séquences d'échappement ANSI

  std::cout<< u8"\033[2J\033[1;1H"; 

• Sur MacOS Enquête...

Answer 4

Pour Linux/Unix et peut-être quelques autres, mais pas pour Windows avant 10 TH2 :

printf("\033c");

réinitialise le terminal.

Answer 5

L'affichage de plusieurs lignes dans la console de la fenêtre est inutile il ne fait qu'ajouter des lignes vides à la console. Malheureusement, la méthode est spécifique à Windows et implique soit conio.h (et clrscr() n'existe peut-être pas, ce n'est pas un en-tête standard non plus), soit une méthode 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 );
  }

Pour les systèmes POSIX, c'est beaucoup plus simple, vous pouvez utiliser ncurses ou les fonctions 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" ) );
  }