web-dev-qa-db-fra.com

Comment puis-je effacer la console

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

73
Thomas B

Pour C++ pur

Tu ne peux pas. C++ n'a même pas le concept de console.

Le programme peut imprimer sur une imprimante, sortir directement dans un fichier ou être redirigé vers l’entrée d’un autre programme pour tous les soucis. 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 comp.lang.c ++:

Spécifique à l'OS

S'il est toujours judicieux d'effacer la console de votre programme et que des solutions spécifiques au système d'exploitation vous intéressent, elles existent.

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

Éditer: Cette réponse mentionnait précédemment l’utilisation de system("cls");, car Microsoft avait 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 à cause de ce problème.

Bibliothèques (quelque peu portables)

ncurses est une bibliothèque qui supporte la manipulation de console:

61

Pour Windows, via l’API de la 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 heureusement toutes les erreurs possibles, mais bon, ça efface la console. Pas comme system("cls") gère mieux les erreurs.

Pour * nixes, vous pouvez généralement utiliser des codes d'échappement ANSI. Ce serait donc:

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

Utiliser system pour cela est simplement moche.

45
Cat Plus Plus

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

printf("\033c");

va réinitialiser le terminal.

13
NoAngel

la sortie de plusieurs lignes sur la console de fenêtre est inutile .. elle ne fait qu'ajouter des lignes vides . Malheureusement, le chemin est spécifique à Windows et implique soit conio.h (et clrscr () peut ne pas exister, ce n'est pas un entête standard) Méthode 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 );
  }

Pour les systèmes POSIX, c'est plus simple, vous pouvez utiliser ncurses ou des 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" ) );
  }
4
Swift - Friday Pie
// #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
Firefox_

Ceci est vraiment agité mais essayez:

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

Utilisez system("cls") pour effacer l'écran:

#include <stdlib.h>

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

Pour effacer l'écran, vous devez d'abord inclure un module:

#include <stdlib.h>

cela importera des commandes Windows. Vous pouvez ensuite utiliser la fonction 'système' pour exécuter les commandes Batch (qui permettent d’éditer la console). Sous Windows en C++, la commande pour effacer l'écran serait:

system("CLS");

Et cela effacerait la console. Le code entier ressemblerait à ceci:

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

using namespace std;

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

Et c'est tout ce dont vous avez besoin! Bonne chance :)

3
user3179329

Sous Windows:

#include <cstdlib>

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

Sous Linux/Unix:

#include <cstdlib>

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

C'est difficile à faire sur MAC, vu qu'il n'a pas accès aux fonctions de Windows qui peuvent aider à effacer l'écran. Ma meilleure solution est de boucler et d’ajouter des lignes jusqu’à ce que le terminal soit vide, puis d’exécuter le programme. Toutefois, cela n’est pas aussi efficace ni plus convivial pour la mémoire si vous l’utilisez principalement et souvent.

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

Le moyen le plus simple pour moi sans avoir à réinventer la roue.

void Clear()
{
#if defined _WIN32
    system("cls");
#Elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)
    system("clear");
#Elif defined (__Apple__)
    system("clear");
#endif
}
1
Joma

Voici un moyen simple de le faire:

#include <iostream>

using namespace std;

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

Sous Windows, nous avons plusieurs options:

  1. clrscr () (Fichier d'en-tête: conio.h)

  2. system ("cls") (Fichier d'en-tête: stdlib.h)

Sous Linux, utilisez system ("clear") (Fichier d'en-tête: stdlib.h)

0
Anurag Singh